mirror of
https://github.com/plexusorg/Plex.git
synced 2024-05-29 01:51:45 +00:00
572 lines
26 KiB
Java
572 lines
26 KiB
Java
package dev.plex.command;
|
|
|
|
import com.destroystokyo.paper.brigadier.BukkitBrigadierCommandSource;
|
|
import com.google.common.collect.Maps;
|
|
import com.google.gson.GsonBuilder;
|
|
import com.mojang.brigadier.CommandDispatcher;
|
|
import com.mojang.brigadier.arguments.*;
|
|
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
|
|
import com.mojang.brigadier.builder.RequiredArgumentBuilder;
|
|
import com.mojang.brigadier.context.CommandContext;
|
|
import com.mojang.brigadier.tree.CommandNode;
|
|
import com.mojang.brigadier.tree.LiteralCommandNode;
|
|
import dev.plex.Plex;
|
|
import dev.plex.cache.DataUtils;
|
|
import dev.plex.command.annotation.*;
|
|
import dev.plex.command.source.RequiredCommandSource;
|
|
import dev.plex.player.PlexPlayer;
|
|
import dev.plex.util.PlexLog;
|
|
import dev.plex.util.PlexUtils;
|
|
import dev.plex.util.ReflectionsUtil;
|
|
import net.kyori.adventure.audience.Audience;
|
|
import net.kyori.adventure.text.Component;
|
|
import net.kyori.adventure.text.format.NamedTextColor;
|
|
import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
|
|
import org.bukkit.Bukkit;
|
|
import org.bukkit.command.CommandSender;
|
|
import org.bukkit.entity.Player;
|
|
import org.jetbrains.annotations.NotNull;
|
|
|
|
import java.lang.System;
|
|
import java.lang.reflect.Method;
|
|
import java.lang.reflect.Parameter;
|
|
import java.util.*;
|
|
|
|
/**
|
|
* @author Taah
|
|
* @since 2:27 PM [07-07-2023]
|
|
*/
|
|
public abstract class PlexBrigadierCommand
|
|
{
|
|
protected final Plex plugin;
|
|
private CommandDispatcher<BukkitBrigadierCommandSource> commandDispatcher;
|
|
|
|
public PlexBrigadierCommand()
|
|
{
|
|
this.plugin = Plex.get();
|
|
try
|
|
{
|
|
final Object dedicatedServer = ReflectionsUtil.callFunction(getCraftServer(), "getServer");
|
|
final Object minecraftServer = Class.forName("net.minecraft.server.MinecraftServer").cast(dedicatedServer);
|
|
final Object serverFunctionsManager = ReflectionsUtil.callFunction(minecraftServer, "aA");
|
|
this.commandDispatcher = ReflectionsUtil.callFunction(serverFunctionsManager, "b");
|
|
}
|
|
catch (ClassNotFoundException e)
|
|
{
|
|
this.commandDispatcher = null;
|
|
PlexLog.error("Disabling commands as brigadier could not properly be located.");
|
|
}
|
|
|
|
if (!this.getClass().isAnnotationPresent(CommandName.class))
|
|
{
|
|
if (this.commandDispatcher != null)
|
|
{
|
|
this.commandDispatcher.register(execute());
|
|
}
|
|
return;
|
|
}
|
|
|
|
String[] commandName = this.getClass().getAnnotation(CommandName.class).value();
|
|
|
|
final HashMap<String, Method> subcommands = Maps.newHashMap();
|
|
|
|
Method defaultMethod = null;
|
|
for (Method declaredMethod : this.getClass().getDeclaredMethods())
|
|
{
|
|
if (declaredMethod.isAnnotationPresent(SubCommand.class))
|
|
{
|
|
String subcommand = declaredMethod.getAnnotation(SubCommand.class).value();
|
|
subcommands.put(subcommand.toLowerCase(), declaredMethod);
|
|
}
|
|
if (declaredMethod.isAnnotationPresent(Default.class))
|
|
{
|
|
if (defaultMethod != null)
|
|
{
|
|
PlexLog.error("There cannot be more than one default execution.");
|
|
continue;
|
|
}
|
|
defaultMethod = declaredMethod;
|
|
}
|
|
}
|
|
|
|
if (this.commandDispatcher != null)
|
|
{
|
|
for (String name : commandName)
|
|
{
|
|
LiteralArgumentBuilder<BukkitBrigadierCommandSource> builder = LiteralArgumentBuilder.literal(name.toLowerCase());
|
|
|
|
for (Map.Entry<String, Method> stringMethodEntry : subcommands.entrySet())
|
|
{
|
|
String[] subCommandArgs = stringMethodEntry.getKey().split(" ");
|
|
LinkedList<LiteralArgumentBuilder<BukkitBrigadierCommandSource>> builders = new LinkedList<>();
|
|
for (int i = 0; i < subCommandArgs.length; i++)
|
|
{
|
|
LiteralArgumentBuilder<BukkitBrigadierCommandSource> newNode = LiteralArgumentBuilder.literal(subCommandArgs[i]);
|
|
builders.addLast(newNode);
|
|
}
|
|
|
|
if (builders.size() == 1)
|
|
{
|
|
LiteralArgumentBuilder<BukkitBrigadierCommandSource> parent = builders.removeFirst();
|
|
LinkedList<RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> argumentBuilders = new LinkedList<>();
|
|
|
|
LinkedHashMap<Parameter, RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> arguments = getArguments(stringMethodEntry.getValue());
|
|
for (Map.Entry<Parameter, RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> parameterArgumentBuilderEntry : arguments.entrySet())
|
|
{
|
|
argumentBuilders.addLast(parameterArgumentBuilderEntry.getValue());
|
|
}
|
|
boolean setExecution = false;
|
|
CommandNode<BukkitBrigadierCommandSource> parentArg = null;
|
|
CommandNode<BukkitBrigadierCommandSource> currArg = null;
|
|
while (!argumentBuilders.isEmpty())
|
|
{
|
|
if (parentArg == null)
|
|
{
|
|
RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?> newParent = argumentBuilders.removeFirst();
|
|
if (argumentBuilders.isEmpty())
|
|
{
|
|
newParent.executes(context -> execute(stringMethodEntry.getValue(), context, arguments.keySet()));
|
|
setExecution = true;
|
|
}
|
|
parentArg = newParent.build();
|
|
parent.then(parentArg);
|
|
currArg = parentArg;
|
|
}
|
|
else
|
|
{
|
|
RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?> newCurr = argumentBuilders.removeFirst();
|
|
if (argumentBuilders.isEmpty())
|
|
{
|
|
newCurr.executes(context -> execute(stringMethodEntry.getValue(), context, arguments.keySet()));
|
|
setExecution = true;
|
|
}
|
|
CommandNode<BukkitBrigadierCommandSource> newCurrNode = newCurr.build();
|
|
currArg.addChild(newCurrNode);
|
|
currArg = newCurrNode;
|
|
}
|
|
}
|
|
if (!setExecution)
|
|
{
|
|
parent.executes(context -> execute(stringMethodEntry.getValue(), context, arguments.keySet()));
|
|
}
|
|
builder.then(parent);
|
|
}
|
|
else if (builders.size() > 1)
|
|
{
|
|
LiteralCommandNode<BukkitBrigadierCommandSource> parent = builders.removeFirst().build();
|
|
LiteralCommandNode<BukkitBrigadierCommandSource> curr = null;
|
|
while (!builders.isEmpty())
|
|
{
|
|
LiteralArgumentBuilder<BukkitBrigadierCommandSource> newCurr = builders.removeFirst();
|
|
PlexLog.debug("Adding subcommand " + newCurr.getLiteral());
|
|
if (builders.isEmpty())
|
|
{
|
|
LinkedList<RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> argumentBuilders = new LinkedList<>();
|
|
LinkedHashMap<Parameter, RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> arguments = getArguments(stringMethodEntry.getValue());
|
|
for (Map.Entry<Parameter, RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> parameterArgumentBuilderEntry : arguments.entrySet())
|
|
{
|
|
argumentBuilders.addLast(parameterArgumentBuilderEntry.getValue());
|
|
}
|
|
boolean setExecution = false;
|
|
CommandNode<BukkitBrigadierCommandSource> parentArg = null;
|
|
CommandNode<BukkitBrigadierCommandSource> currArg = null;
|
|
while (!argumentBuilders.isEmpty())
|
|
{
|
|
if (parentArg == null)
|
|
{
|
|
RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?> newParent = argumentBuilders.removeFirst();
|
|
if (argumentBuilders.isEmpty())
|
|
{
|
|
newParent.executes(context -> execute(stringMethodEntry.getValue(), context, arguments.keySet()));
|
|
setExecution = true;
|
|
}
|
|
parentArg = newParent.build();
|
|
newCurr.then(parentArg);
|
|
currArg = parentArg;
|
|
}
|
|
else
|
|
{
|
|
RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?> newCurrArg = argumentBuilders.removeFirst();
|
|
if (argumentBuilders.isEmpty())
|
|
{
|
|
newCurrArg.executes(context -> execute(stringMethodEntry.getValue(), context, arguments.keySet()));
|
|
setExecution = true;
|
|
}
|
|
CommandNode<BukkitBrigadierCommandSource> newCurrNode = newCurrArg.build();
|
|
currArg.addChild(newCurrNode);
|
|
currArg = newCurrNode;
|
|
}
|
|
}
|
|
if (!setExecution)
|
|
{
|
|
newCurr.executes(context -> execute(stringMethodEntry.getValue(), context, arguments.keySet()));
|
|
}
|
|
}
|
|
if (curr == null)
|
|
{
|
|
LiteralCommandNode<BukkitBrigadierCommandSource> temp = newCurr.build();
|
|
parent.addChild(temp);
|
|
curr = temp;
|
|
}
|
|
else
|
|
{
|
|
LiteralCommandNode<BukkitBrigadierCommandSource> temp = newCurr.build();
|
|
curr.addChild(temp);
|
|
curr = temp;
|
|
}
|
|
}
|
|
builder.then(parent);
|
|
}
|
|
PlexLog.debug("Overall Builder: " + new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create().toJson(builder));
|
|
}
|
|
|
|
if (defaultMethod != null)
|
|
{
|
|
LinkedList<RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> argumentBuilders = new LinkedList<>();
|
|
LinkedHashMap<Parameter, RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> arguments = getArguments(defaultMethod);
|
|
for (Map.Entry<Parameter, RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> parameterArgumentBuilderEntry : arguments.entrySet())
|
|
{
|
|
argumentBuilders.addLast(parameterArgumentBuilderEntry.getValue());
|
|
}
|
|
boolean setExecution = false;
|
|
CommandNode<BukkitBrigadierCommandSource> parentArg = null;
|
|
CommandNode<BukkitBrigadierCommandSource> currArg = null;
|
|
while (!argumentBuilders.isEmpty())
|
|
{
|
|
if (parentArg == null)
|
|
{
|
|
RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?> newParent = argumentBuilders.removeFirst();
|
|
if (argumentBuilders.isEmpty())
|
|
{
|
|
Method finalDefaultMethod = defaultMethod;
|
|
newParent.executes(context -> execute(finalDefaultMethod, context, arguments.keySet()));
|
|
setExecution = true;
|
|
}
|
|
parentArg = newParent.build();
|
|
builder.then(parentArg);
|
|
currArg = parentArg;
|
|
}
|
|
else
|
|
{
|
|
RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?> newCurrArg = argumentBuilders.removeFirst();
|
|
if (argumentBuilders.isEmpty())
|
|
{
|
|
Method finalDefaultMethod1 = defaultMethod;
|
|
newCurrArg.executes(context -> execute(finalDefaultMethod1, context, arguments.keySet()));
|
|
setExecution = true;
|
|
}
|
|
CommandNode<BukkitBrigadierCommandSource> newCurrNode = newCurrArg.build();
|
|
currArg.addChild(newCurrNode);
|
|
currArg = newCurrNode;
|
|
}
|
|
}
|
|
if (!setExecution)
|
|
{
|
|
Method finalDefaultMethod2 = defaultMethod;
|
|
builder.executes(context -> execute(finalDefaultMethod2, context, arguments.keySet()));
|
|
}
|
|
}
|
|
|
|
this.commandDispatcher.register(builder);
|
|
}
|
|
|
|
this.commandDispatcher.register(LiteralArgumentBuilder.<BukkitBrigadierCommandSource>literal("testing")
|
|
.then(RequiredArgumentBuilder.<BukkitBrigadierCommandSource, Integer>argument("test0", IntegerArgumentType.integer())
|
|
.then(RequiredArgumentBuilder.<BukkitBrigadierCommandSource, String>argument("test", StringArgumentType.word())
|
|
.then(RequiredArgumentBuilder.<BukkitBrigadierCommandSource, String>argument("test1", StringArgumentType.word())
|
|
.executes(context ->
|
|
{
|
|
send(context, context.getArgument("test", String.class));
|
|
send(context, context.getArgument("test1", String.class));
|
|
return 1;
|
|
})))));
|
|
}
|
|
}
|
|
|
|
public LiteralArgumentBuilder<BukkitBrigadierCommandSource> execute()
|
|
{
|
|
return LiteralArgumentBuilder.literal(this.getClass().getName().toLowerCase());
|
|
}
|
|
|
|
/**
|
|
* Gets a PlexPlayer from Player object
|
|
*
|
|
* @param player The player object
|
|
* @return PlexPlayer Object
|
|
* @see PlexPlayer
|
|
*/
|
|
protected PlexPlayer getPlexPlayer(@NotNull Player player)
|
|
{
|
|
return DataUtils.getPlayer(player.getUniqueId());
|
|
}
|
|
|
|
protected void send(Audience audience, Component component)
|
|
{
|
|
audience.sendMessage(component);
|
|
}
|
|
|
|
/**
|
|
* Sends a message to an Audience
|
|
*
|
|
* @param audience The Audience to send the message to
|
|
* @param s The message to send
|
|
*/
|
|
protected void send(Audience audience, String s)
|
|
{
|
|
audience.sendMessage(componentFromString(s));
|
|
}
|
|
|
|
/**
|
|
* Sends a message to a CommandSender
|
|
*
|
|
* @param context The Command Context's sender to send the message to
|
|
* @param s The message to send
|
|
*/
|
|
protected void send(CommandContext<BukkitBrigadierCommandSource> context, String s)
|
|
{
|
|
context.getSource().getBukkitSender().sendMessage(componentFromString(s));
|
|
}
|
|
|
|
/**
|
|
* Sends a message to a CommandSender
|
|
*
|
|
* @param context The Command Context's sender to send the message to
|
|
* @param component The Component to send
|
|
*/
|
|
protected void send(CommandContext<BukkitBrigadierCommandSource> context, Component component)
|
|
{
|
|
context.getSource().getBukkitSender().sendMessage(component);
|
|
}
|
|
|
|
/**
|
|
* Converts a String to a MiniMessage Component
|
|
*
|
|
* @param s The String to convert
|
|
* @return A Kyori Component
|
|
*/
|
|
protected Component mmString(String s)
|
|
{
|
|
return PlexUtils.mmDeserialize(s);
|
|
}
|
|
|
|
/**
|
|
* Converts a String to a legacy Kyori Component
|
|
*
|
|
* @param s The String to convert
|
|
* @return A Kyori component
|
|
*/
|
|
protected Component componentFromString(String s)
|
|
{
|
|
return LegacyComponentSerializer.legacyAmpersand().deserialize(s).colorIfAbsent(NamedTextColor.GRAY);
|
|
}
|
|
|
|
/**
|
|
* Checks if a player is an admin
|
|
*
|
|
* @param plexPlayer The PlexPlayer object
|
|
* @return true if the player is an admin
|
|
* @see PlexPlayer
|
|
*/
|
|
protected boolean isAdmin(PlexPlayer plexPlayer)
|
|
{
|
|
return Plex.get().getRankManager().isAdmin(plexPlayer);
|
|
}
|
|
|
|
/**
|
|
* Checks if a sender is an admin
|
|
*
|
|
* @param sender A command sender
|
|
* @return true if the sender is an admin or if console
|
|
*/
|
|
protected boolean isAdmin(CommandSender sender)
|
|
{
|
|
if (!(sender instanceof Player player))
|
|
{
|
|
return true;
|
|
}
|
|
PlexPlayer plexPlayer = getPlexPlayer(player);
|
|
return plugin.getRankManager().isAdmin(plexPlayer);
|
|
}
|
|
|
|
/**
|
|
* Checks if a username is an admin
|
|
*
|
|
* @param name The username
|
|
* @return true if the username is an admin
|
|
*/
|
|
protected boolean isAdmin(String name)
|
|
{
|
|
PlexPlayer plexPlayer = DataUtils.getPlayer(name);
|
|
return plugin.getRankManager().isAdmin(plexPlayer);
|
|
}
|
|
|
|
/**
|
|
* Checks if a sender is a senior admin
|
|
*
|
|
* @param sender A command sender
|
|
* @return true if the sender is a senior admin or if console
|
|
*/
|
|
protected boolean isSeniorAdmin(CommandSender sender)
|
|
{
|
|
if (!(sender instanceof Player player))
|
|
{
|
|
return true;
|
|
}
|
|
PlexPlayer plexPlayer = getPlexPlayer(player);
|
|
return plugin.getRankManager().isSeniorAdmin(plexPlayer);
|
|
}
|
|
|
|
/**
|
|
* Gets the UUID of the sender
|
|
*
|
|
* @param sender A command sender
|
|
* @return A unique ID or null if the sender is console
|
|
* @see UUID
|
|
*/
|
|
protected UUID getUUID(CommandSender sender)
|
|
{
|
|
if (!(sender instanceof Player player))
|
|
{
|
|
return null;
|
|
}
|
|
return player.getUniqueId();
|
|
}
|
|
|
|
private LinkedHashMap<Parameter, RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> getArguments(Method method)
|
|
{
|
|
LinkedHashMap<Parameter, RequiredArgumentBuilder<BukkitBrigadierCommandSource, ?>> result = new LinkedHashMap<>();
|
|
if (!method.canAccess(this))
|
|
{
|
|
method.setAccessible(true);
|
|
}
|
|
for (Parameter parameter : method.getParameters())
|
|
{
|
|
if (parameter.isAnnotationPresent(Argument.class))
|
|
{
|
|
Argument argument = parameter.getAnnotation(Argument.class);
|
|
if (String.class.isAssignableFrom(parameter.getType()))
|
|
{
|
|
result.put(parameter, RequiredArgumentBuilder.argument(argument.value(), argument.argumentType() == StringArgumentType.StringType.SINGLE_WORD ? StringArgumentType.word() : StringArgumentType.greedyString()));
|
|
}
|
|
else if (int.class.isAssignableFrom(parameter.getType()))
|
|
{
|
|
result.put(parameter, RequiredArgumentBuilder.argument(argument.value(), IntegerArgumentType.integer(argument.min() == Double.MIN_VALUE ? Integer.MIN_VALUE : (int) argument.min(), argument.max() == Double.MAX_VALUE ? Integer.MAX_VALUE : (int) argument.max())));
|
|
}
|
|
else if (double.class.isAssignableFrom(parameter.getType()))
|
|
{
|
|
result.put(parameter, RequiredArgumentBuilder.argument(argument.value(), DoubleArgumentType.doubleArg(argument.min(), argument.max())));
|
|
}
|
|
else if (float.class.isAssignableFrom(parameter.getType()))
|
|
{
|
|
result.put(parameter, RequiredArgumentBuilder.argument(argument.value(), FloatArgumentType.floatArg(argument.min() == Double.MIN_VALUE ? Float.MIN_VALUE : (int) argument.min(), argument.max() == Double.MAX_VALUE ? Float.MAX_VALUE : (int) argument.max())));
|
|
}
|
|
else if (boolean.class.isAssignableFrom(parameter.getType()))
|
|
{
|
|
result.put(parameter, RequiredArgumentBuilder.argument(argument.value(), BoolArgumentType.bool()));
|
|
}
|
|
else if (long.class.isAssignableFrom(parameter.getType()))
|
|
{
|
|
result.put(parameter, RequiredArgumentBuilder.argument(argument.value(), LongArgumentType.longArg(argument.min() == Double.MIN_VALUE ? Long.MIN_VALUE : (int) argument.min(), argument.max() == Double.MAX_VALUE ? Long.MAX_VALUE : (int) argument.max())));
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private Object getArgument(Class<?> clazz, CommandContext<BukkitBrigadierCommandSource> context, String name)
|
|
{
|
|
if (String.class.isAssignableFrom(clazz))
|
|
{
|
|
return StringArgumentType.getString(context, name);
|
|
}
|
|
else if (int.class.isAssignableFrom(clazz))
|
|
{
|
|
return IntegerArgumentType.getInteger(context, name);
|
|
}
|
|
else if (double.class.isAssignableFrom(clazz))
|
|
{
|
|
return DoubleArgumentType.getDouble(context, name);
|
|
}
|
|
else if (float.class.isAssignableFrom(clazz))
|
|
{
|
|
return FloatArgumentType.getFloat(context, name);
|
|
}
|
|
else if (boolean.class.isAssignableFrom(clazz))
|
|
{
|
|
return BoolArgumentType.getBool(context, name);
|
|
}
|
|
else if (long.class.isAssignableFrom(clazz))
|
|
{
|
|
return LongArgumentType.getLong(context, name);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private int execute(Method method, CommandContext<BukkitBrigadierCommandSource> context, Set<Parameter> arguments)
|
|
{
|
|
if (method.isAnnotationPresent(CommandPermission.class))
|
|
{
|
|
String permission = method.getAnnotation(CommandPermission.class).value();
|
|
if (!context.getSource().getBukkitSender().hasPermission(permission))
|
|
{
|
|
send(context, PlexUtils.messageComponent("noPermissionNode", permission));
|
|
return 1;
|
|
}
|
|
}
|
|
try
|
|
{
|
|
List<Object> params = arguments
|
|
.stream().map(bukkitBrigadierCommandSourceArgumentBuilder -> getArgument(bukkitBrigadierCommandSourceArgumentBuilder.getType(), context, bukkitBrigadierCommandSourceArgumentBuilder.getAnnotation(Argument.class).value())).toList();
|
|
LinkedList<Object> parameters = new LinkedList<>(params);
|
|
// parameters.addFirst(context.getSource().getBukkitSender());
|
|
if (method.isAnnotationPresent(CommandSource.class)) {
|
|
RequiredCommandSource commandSource = method.getAnnotation(CommandSource.class).value();
|
|
if (commandSource == RequiredCommandSource.IN_GAME) {
|
|
if (!(context.getSource().getBukkitSender() instanceof Player player)) {
|
|
send(context, PlexUtils.messageComponent("noPermissionConsole"));
|
|
return 1;
|
|
} else {
|
|
parameters.addFirst(player);
|
|
}
|
|
} else if (commandSource == RequiredCommandSource.CONSOLE) {
|
|
if (context.getSource().getBukkitSender() instanceof Player) {
|
|
send(context, PlexUtils.messageComponent("noPermissionInGame"));
|
|
return 1;
|
|
}
|
|
parameters.addFirst(context.getSource().getBukkitSender());
|
|
} else {
|
|
parameters.addFirst(context.getSource().getBukkitSender());
|
|
}
|
|
}
|
|
System.out.println(Arrays.toString(parameters.stream().map(Object::getClass).map(Class::getName).toArray()));
|
|
System.out.println(Arrays.toString(Arrays.stream(method.getParameterTypes()).map(Class::getName).toArray()));
|
|
method.invoke(this, parameters.toArray());
|
|
return 1;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
PlexLog.error(e.getMessage());
|
|
for (StackTraceElement stackTraceElement : e.getStackTrace())
|
|
{
|
|
PlexLog.error(stackTraceElement.toString());
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
private Object getCraftServer()
|
|
{
|
|
String nmsVersion = Bukkit.getServer().getClass().getPackage().getName();
|
|
nmsVersion = nmsVersion.substring(nmsVersion.lastIndexOf('.') + 1);
|
|
try
|
|
{
|
|
Class<?> craftServer = Class.forName("org.bukkit.craftbukkit." + nmsVersion + ".CraftServer");
|
|
return craftServer.cast(Bukkit.getServer());
|
|
}
|
|
catch (ClassNotFoundException e)
|
|
{
|
|
throw new RuntimeException(e);
|
|
}
|
|
}
|
|
}
|