From a94d583f0be2e0eb31481eee9460c718b47d8579 Mon Sep 17 00:00:00 2001 From: NavidK0 Date: Fri, 4 Mar 2016 23:45:38 -0500 Subject: [PATCH] Fix a strange issue with .gitignore excluding files, fixes Jenkins again --- .gitignore | 11 +- README.md | 3 + .../libraryaddict/disguise/LibsDisguises.java | 20 +- .../commands/BaseDisguiseCommand.java | 765 ++++++++++++++++++ ...Command.java => CloneDisguiseCommand.java} | 2 +- ...ommand.java => EntityDisguiseCommand.java} | 2 +- ...pCommand.java => HelpDisguiseCommand.java} | 4 +- ...ommand.java => PlayerDisguiseCommand.java} | 2 +- ...ommand.java => RadiusDisguiseCommand.java} | 4 +- 9 files changed, 792 insertions(+), 21 deletions(-) create mode 100644 src/main/java/me/libraryaddict/disguise/commands/BaseDisguiseCommand.java rename src/main/java/me/libraryaddict/disguise/commands/{DisguiseCloneCommand.java => CloneDisguiseCommand.java} (97%) rename src/main/java/me/libraryaddict/disguise/commands/{DisguiseEntityCommand.java => EntityDisguiseCommand.java} (97%) rename src/main/java/me/libraryaddict/disguise/commands/{DisguiseHelpCommand.java => HelpDisguiseCommand.java} (99%) rename src/main/java/me/libraryaddict/disguise/commands/{DisguisePlayerCommand.java => PlayerDisguiseCommand.java} (98%) rename src/main/java/me/libraryaddict/disguise/commands/{DisguiseRadiusCommand.java => RadiusDisguiseCommand.java} (98%) diff --git a/.gitignore b/.gitignore index 87aa62d3..dcaa91a9 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,7 @@ -* -!src -!build.gradle -!settings.gradle \ No newline at end of file +.gradle +.idea +build +libs +*.iml +*.ipr +*.iws diff --git a/README.md b/README.md index 353f4646..bb2734f7 100644 --- a/README.md +++ b/README.md @@ -5,6 +5,9 @@ A disguise plugin made by libraryaddict which is pretty cool.
NOTE: These versions will NOT work with Spigot 1.8.8 and before. +Spigot page: Link + + When posting an issue:
Please make sure you
1) Post a stack trace error, if no stack trace, then post the odd behavior
diff --git a/src/main/java/me/libraryaddict/disguise/LibsDisguises.java b/src/main/java/me/libraryaddict/disguise/LibsDisguises.java index 9d7587e3..d1493643 100644 --- a/src/main/java/me/libraryaddict/disguise/LibsDisguises.java +++ b/src/main/java/me/libraryaddict/disguise/LibsDisguises.java @@ -3,14 +3,14 @@ package me.libraryaddict.disguise; import com.comphenix.protocol.reflect.FieldAccessException; import com.comphenix.protocol.wrappers.WrappedDataWatcher; import com.comphenix.protocol.wrappers.WrappedWatchableObject; -import me.libraryaddict.disguise.commands.DisguiseCloneCommand; +import me.libraryaddict.disguise.commands.CloneDisguiseCommand; import me.libraryaddict.disguise.commands.DisguiseCommand; -import me.libraryaddict.disguise.commands.DisguiseEntityCommand; -import me.libraryaddict.disguise.commands.DisguiseHelpCommand; -import me.libraryaddict.disguise.commands.DisguisePlayerCommand; -import me.libraryaddict.disguise.commands.DisguiseRadiusCommand; import me.libraryaddict.disguise.commands.DisguiseViewSelf; +import me.libraryaddict.disguise.commands.EntityDisguiseCommand; +import me.libraryaddict.disguise.commands.HelpDisguiseCommand; import me.libraryaddict.disguise.commands.LibsDisguisesCommand; +import me.libraryaddict.disguise.commands.PlayerDisguiseCommand; +import me.libraryaddict.disguise.commands.RadiusDisguiseCommand; import me.libraryaddict.disguise.commands.UndisguiseCommand; import me.libraryaddict.disguise.commands.UndisguiseEntityCommand; import me.libraryaddict.disguise.commands.UndisguisePlayerCommand; @@ -64,14 +64,14 @@ public class LibsDisguises extends JavaPlugin { Bukkit.getPluginManager().registerEvents(listener, this); getCommand("disguise").setExecutor(new DisguiseCommand()); getCommand("undisguise").setExecutor(new UndisguiseCommand()); - getCommand("disguiseplayer").setExecutor(new DisguisePlayerCommand()); + getCommand("disguiseplayer").setExecutor(new PlayerDisguiseCommand()); getCommand("undisguiseplayer").setExecutor(new UndisguisePlayerCommand()); getCommand("undisguiseentity").setExecutor(new UndisguiseEntityCommand()); - getCommand("disguiseentity").setExecutor(new DisguiseEntityCommand()); - getCommand("disguiseradius").setExecutor(new DisguiseRadiusCommand(getConfig().getInt("DisguiseRadiusMax"))); + getCommand("disguiseentity").setExecutor(new EntityDisguiseCommand()); + getCommand("disguiseradius").setExecutor(new RadiusDisguiseCommand(getConfig().getInt("DisguiseRadiusMax"))); getCommand("undisguiseradius").setExecutor(new UndisguiseRadiusCommand(getConfig().getInt("UndisguiseRadiusMax"))); - getCommand("disguisehelp").setExecutor(new DisguiseHelpCommand()); - getCommand("disguiseclone").setExecutor(new DisguiseCloneCommand()); + getCommand("disguisehelp").setExecutor(new HelpDisguiseCommand()); + getCommand("disguiseclone").setExecutor(new CloneDisguiseCommand()); getCommand("libsdisguises").setExecutor(new LibsDisguisesCommand()); getCommand("disguiseviewself").setExecutor(new DisguiseViewSelf()); registerValues(); diff --git a/src/main/java/me/libraryaddict/disguise/commands/BaseDisguiseCommand.java b/src/main/java/me/libraryaddict/disguise/commands/BaseDisguiseCommand.java new file mode 100644 index 00000000..b17a2502 --- /dev/null +++ b/src/main/java/me/libraryaddict/disguise/commands/BaseDisguiseCommand.java @@ -0,0 +1,765 @@ +package me.libraryaddict.disguise.commands; + +import me.libraryaddict.disguise.disguisetypes.AnimalColor; +import me.libraryaddict.disguise.disguisetypes.Disguise; +import me.libraryaddict.disguise.disguisetypes.DisguiseType; +import me.libraryaddict.disguise.disguisetypes.FlagWatcher; +import me.libraryaddict.disguise.disguisetypes.MiscDisguise; +import me.libraryaddict.disguise.disguisetypes.MobDisguise; +import me.libraryaddict.disguise.disguisetypes.PlayerDisguise; +import me.libraryaddict.disguise.disguisetypes.RabbitType; +import me.libraryaddict.disguise.utilities.DisguiseUtilities; +import org.bukkit.ChatColor; +import org.bukkit.Material; +import org.bukkit.block.BlockFace; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Ageable; +import org.bukkit.entity.Animals; +import org.bukkit.entity.Monster; +import org.bukkit.inventory.ItemStack; +import org.bukkit.permissions.PermissionAttachmentInfo; +import org.bukkit.potion.PotionEffectType; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map.Entry; + + +/** + * @author libraryaddict + */ +public abstract class BaseDisguiseCommand implements CommandExecutor { + + public class DisguiseParseException extends Exception { + + private static final long serialVersionUID = 1276971370793124510L; + + public DisguiseParseException() { + super(); + } + + public DisguiseParseException(String string) { + super(string); + } + } + + protected ArrayList getAllowedDisguises(HashMap, Boolean>> hashMap) { + ArrayList allowedDisguises = new ArrayList<>(); + for (DisguiseType type : hashMap.keySet()) { + allowedDisguises.add(type.toReadable().replace(" ", "_")); + } + Collections.sort(allowedDisguises, String.CASE_INSENSITIVE_ORDER); + return allowedDisguises; + } + + protected HashMap, Boolean>> getPermissions(CommandSender sender) { + return getPermissions(sender, "libsdisguises." + getClass().getSimpleName().replace("Command", "").toLowerCase() + "."); + } + + protected HashMap getDisguisePermission(CommandSender sender, DisguiseType type) { + switch (type) { + case PLAYER: + case FALLING_BLOCK: + case PAINTING: + case SPLASH_POTION: + case FISHING_HOOK: + case DROPPED_ITEM: + HashMap returns = new HashMap<>(); + String beginning = "libsdisguises.options." + getClass().getSimpleName().toLowerCase().replace("command", "") + "."; + for (PermissionAttachmentInfo permission : sender.getEffectivePermissions()) { + String lowerPerm = permission.getPermission().toLowerCase(); + if (lowerPerm.startsWith(beginning)) { + String[] split = lowerPerm.substring(beginning.length()).split("\\."); + if (split.length > 1) { + if (split[0].replace("_", "").equals(type.name().toLowerCase().replace("_", ""))) { + for (int i = 1; i < split.length; i++) { + returns.put(split[i], permission.getValue()); + } + } + } + } + } + return returns; + default: + return new HashMap<>(); + } + } + + protected Method[] getDisguiseWatcherMethods(Class watcherClass) { + Method[] methods = watcherClass.getMethods(); + methods = Arrays.copyOf(methods, methods.length + 4); + int i = 4; + for (String methodName : new String[]{"setViewSelfDisguise", "setHideHeldItemFromSelf", "setHideArmorFromSelf", + "setHearSelfDisguise"}) { + try { + methods[methods.length - i--] = Disguise.class.getMethod(methodName, boolean.class); + } catch (Exception ex) { + ex.printStackTrace(System.out); + } + } + return methods; + } + + /** + * Get perms for the node. Returns a hashmap of allowed disguisetypes and their options + * + * @param sender + * @param permissionNode + * @return + */ + protected HashMap, Boolean>> getPermissions(CommandSender sender, String permissionNode) { + HashMap, Boolean>> singleDisguises = new HashMap<>(); + HashMap, Boolean>> rangeDisguises = new HashMap<>(); + HashMap perms = new HashMap<>(); + + for (PermissionAttachmentInfo permission : sender.getEffectivePermissions()) { + String perm = permission.getPermission().toLowerCase(); + if (perm.startsWith(permissionNode) && (!perms.containsKey(perm) || !permission.getValue())) { + perms.put(perm, permission.getValue()); + } + } + if (!perms.containsKey(permissionNode + "*") && sender.hasPermission(permissionNode + "*")) { + perms.put(permissionNode + "*", true); + } + if (!perms.containsKey(permissionNode + "*.*") && sender.hasPermission(permissionNode + "*.*")) { + perms.put(permissionNode + "*.*", true); + } + + for (String perm : perms.keySet()) { + if (perms.get(perm)) { + perm = perm.substring(permissionNode.length()); + String disguiseType = perm.split("\\.")[0]; + DisguiseType dType = null; + for (DisguiseType t : DisguiseType.values()) { + if (t.name().replace("_", "").equalsIgnoreCase(disguiseType.replace("_", ""))) { + dType = t; + break; + } + } + if (dType != null) { + HashMap, Boolean> list; + if (singleDisguises.containsKey(dType)) { + list = singleDisguises.get(dType); + } else { + list = new HashMap<>(); + singleDisguises.put(dType, list); + } + HashMap, Boolean> map1 = getOptions(perm); + list.put(map1.keySet().iterator().next(), map1.values().iterator().next()); + } else { + for (DisguiseType type : DisguiseType.values()) { + HashMap, Boolean> options = null; + Class entityClass = type.getEntityClass(); + if (disguiseType.equals("mob")) { + if (type.isMob()) { + options = getOptions(perm); + } + } else if (disguiseType.equals("animal") || disguiseType.equals("animals")) { + if (Animals.class.isAssignableFrom(entityClass)) { + options = getOptions(perm); + } + } else if (disguiseType.equals("monster") || disguiseType.equals("monsters")) { + if (Monster.class.isAssignableFrom(entityClass)) { + options = getOptions(perm); + } + } else if (disguiseType.equals("misc")) { + if (type.isMisc()) { + options = getOptions(perm); + } + } else if (disguiseType.equals("ageable")) { + if (Ageable.class.isAssignableFrom(entityClass)) { + options = getOptions(perm); + } + } else if (disguiseType.equals("*")) { + options = getOptions(perm); + } + if (options != null) { + HashMap, Boolean> list; + if (rangeDisguises.containsKey(type)) { + list = rangeDisguises.get(type); + } else { + list = new HashMap<>(); + rangeDisguises.put(type, list); + } + HashMap, Boolean> map1 = getOptions(perm); + list.put(map1.keySet().iterator().next(), map1.values().iterator().next()); + } + } + } + } + } + for (String perm : perms.keySet()) { + if (!perms.get(perm)) { + perm = perm.substring(permissionNode.length()); + String disguiseType = perm.split("\\.")[0]; + DisguiseType dType = null; + for (DisguiseType t : DisguiseType.values()) { + if (t.name().replace("_", "").equalsIgnoreCase(disguiseType.replace("_", ""))) { + dType = t; + break; + } + } + if (dType != null) { + singleDisguises.remove(dType); + rangeDisguises.remove(dType); + } else { + for (DisguiseType type : DisguiseType.values()) { + boolean foundHim = false; + Class entityClass = type.getEntityClass(); + switch (disguiseType) { + case "mob": + if (type.isMob()) { + foundHim = true; + } + break; + case "animal": + case "animals": + if (Animals.class.isAssignableFrom(entityClass)) { + foundHim = true; + } + break; + case "monster": + case "monsters": + if (Monster.class.isAssignableFrom(entityClass)) { + foundHim = true; + } + break; + case "misc": + if (type.isMisc()) { + foundHim = true; + } + break; + case "ageable": + if (Ageable.class.isAssignableFrom(entityClass)) { + foundHim = true; + } + break; + case "*": + foundHim = true; + break; + } + if (foundHim) { + rangeDisguises.remove(type); + } + } + } + } + } + HashMap, Boolean>> map = new HashMap<>(); + for (DisguiseType type : DisguiseType.values()) { + HashMap, Boolean> temp = new HashMap<>(); + if (singleDisguises.containsKey(type)) { + temp.putAll(singleDisguises.get(type)); + } + if (rangeDisguises.containsKey(type)) { + temp.putAll(rangeDisguises.get(type)); + } + if (!temp.isEmpty()) { + map.put(type, temp); + } + } + return map; + } + + private HashMap, Boolean> getOptions(String perm) { + ArrayList list = new ArrayList<>(); + boolean isRemove = true; + String[] split = perm.split("\\."); + for (int i = 1; i < split.length; i++) { + String option = split[i]; + boolean value = option.startsWith("-"); + if (value) { + option = option.substring(1); + isRemove = false; + } + if (option.equals("baby")) { + option = "setbaby"; + } + list.add(option); + } + HashMap, Boolean> options = new HashMap<>(); + options.put(list, isRemove); + return options; + } + + protected boolean isDouble(String string) { + try { + Float.parseFloat(string); + return true; + } catch (Exception ex) { + return false; + } + } + + protected boolean isNumeric(String string) { + try { + Integer.parseInt(string); + return true; + } catch (Exception ex) { + return false; + } + } + + /** + * Returns the disguise if it all parsed correctly. Returns a exception with a complete message if it didn't. The commandsender is purely used for checking permissions. Would defeat the purpose otherwise. To reach this point, the disguise has been feed a proper disguisetype. + * + * @param sender + * @param args + * @param map + * @return + * @throws BaseDisguiseCommand.DisguiseParseException + * @throws java.lang.IllegalAccessException + * @throws java.lang.reflect.InvocationTargetException + */ + protected Disguise parseDisguise(CommandSender sender, String[] args, HashMap, Boolean>> map) throws DisguiseParseException, + IllegalAccessException, InvocationTargetException { + if (map.isEmpty()) { + throw new DisguiseParseException(ChatColor.RED + "You are forbidden to use this command."); + } + if (args.length == 0) { + sendCommandUsage(sender, map); + throw new DisguiseParseException(); + } + // How many args to skip due to the disugise being constructed + // Time to start constructing the disguise. + // We will need to check between all 3 kinds of disguises + int toSkip = 1; + ArrayList usedOptions = new ArrayList<>(); + Disguise disguise = null; + HashMap, Boolean> optionPermissions; + if (args[0].startsWith("@")) { + if (sender.hasPermission("libsdisguises.disguise.disguiseclone")) { + disguise = DisguiseUtilities.getClonedDisguise(args[0].toLowerCase()); + if (disguise == null) { + throw new DisguiseParseException(ChatColor.RED + "Cannot find a disguise under the reference " + args[0]); + } + } else { + throw new DisguiseParseException(ChatColor.RED + "You do not have perimssion to use disguise references!"); + } + optionPermissions = (map.containsKey(disguise.getType()) ? map.get(disguise.getType()) + : new HashMap, Boolean>()); + } else { + DisguiseType disguiseType = null; + if (args[0].equalsIgnoreCase("p")) { + disguiseType = DisguiseType.PLAYER; + } else { + for (DisguiseType type : DisguiseType.values()) { + if (args[0].equalsIgnoreCase(type.name()) || args[0].equalsIgnoreCase(type.name().replace("_", ""))) { + disguiseType = type; + break; + } + } + } + if (disguiseType == null) { + throw new DisguiseParseException(ChatColor.RED + "Error! The disguise " + ChatColor.GREEN + args[0] + + ChatColor.RED + " doesn't exist!"); + } + if (disguiseType.isUnknown()) { + throw new DisguiseParseException(ChatColor.RED + "Error! You cannot disguise as " + ChatColor.GREEN + "Unknown!"); + } + if (disguiseType.getEntityType() == null) { + throw new DisguiseParseException(ChatColor.RED + "Error! This version of minecraft does not have that disguise!"); + } + if (!map.containsKey(disguiseType)) { + throw new DisguiseParseException(ChatColor.RED + "You are forbidden to use this disguise."); + } + optionPermissions = map.get(disguiseType); + HashMap disguiseOptions = this.getDisguisePermission(sender, disguiseType); + if (disguiseType.isPlayer()) { + // If he is doing a player disguise + if (args.length == 1) { + // He needs to give the player name + throw new DisguiseParseException(ChatColor.RED + "Error! You need to give a player name!"); + } else { + if (!disguiseOptions.isEmpty() + && (!disguiseOptions.containsKey(args[1].toLowerCase()) || !disguiseOptions + .get(args[1].toLowerCase()))) { + throw new DisguiseParseException(ChatColor.RED + "Error! You don't have permission to use that name!"); + } + args[1] = args[1].replace("\\_", " "); + // Construct the player disguise + disguise = new PlayerDisguise(ChatColor.translateAlternateColorCodes('&', args[1])); + toSkip++; + } + } else { + if (disguiseType.isMob()) { // Its a mob, use the mob constructor + boolean adult = true; + if (args.length > 1) { + if (args[1].equalsIgnoreCase("baby") || args[1].equalsIgnoreCase("adult")) { + usedOptions.add("setbaby"); + doCheck(optionPermissions, usedOptions); + adult = args[1].equalsIgnoreCase("adult"); + toSkip++; + } + } + disguise = new MobDisguise(disguiseType, adult); + } else if (disguiseType.isMisc()) { + // Its a misc, we are going to use the MiscDisguise constructor. + int miscId = -1; + int miscData = -1; + String secondArg = null; + if (args.length > 1) { + // They have defined more arguements! + // If the first arg is a number + if (args[1].contains(":")) { + String[] split = args[1].split(":"); + if (isNumeric(split[1])) { + secondArg = split[1]; + } + args[1] = split[0]; + } + if (isNumeric(args[1])) { + miscId = Integer.parseInt(args[1]); + } else { + if (disguiseType == DisguiseType.FALLING_BLOCK || disguiseType == DisguiseType.DROPPED_ITEM) { + for (Material mat : Material.values()) { + if (mat.name().replace("_", "").equalsIgnoreCase(args[1].replace("_", ""))) { + miscId = mat.getId(); + break; + } + } + } + } + if (miscId != -1) { + switch (disguiseType) { + case PAINTING: + case FALLING_BLOCK: + case SPLASH_POTION: + case DROPPED_ITEM: + case FISHING_HOOK: + case TIPPED_ARROW: + case SPECTRAL_ARROW: + case SMALL_FIREBALL: + case FIREBALL: + case WITHER_SKULL: + break; + default: + throw new DisguiseParseException(ChatColor.RED + "Error! " + disguiseType.toReadable() + + " doesn't know what to do with " + args[1] + "!"); + } + toSkip++; + // If they also defined a data value + if (args.length > 2 && secondArg == null && isNumeric(args[2])) { + secondArg = args[2]; + toSkip++; + } + if (secondArg != null) { + if (disguiseType != DisguiseType.FALLING_BLOCK && disguiseType != DisguiseType.DROPPED_ITEM) { + throw new DisguiseParseException(ChatColor.RED + "Error! Only the disguises " + + DisguiseType.FALLING_BLOCK.toReadable() + " and " + + DisguiseType.DROPPED_ITEM.toReadable() + " uses a second number!"); + } + miscData = Integer.parseInt(secondArg); + } + } + } + if (!disguiseOptions.isEmpty() && miscId != -1) { + String toCheck = "" + miscId; + if (miscData == 0 || miscData == -1) { + if (!disguiseOptions.containsKey(toCheck) || !disguiseOptions.get(toCheck)) { + toCheck += ":0"; + } + } else { + toCheck += ":" + miscData; + } + if (!disguiseOptions.containsKey(toCheck) || !disguiseOptions.get(toCheck)) { + throw new DisguiseParseException(ChatColor.RED + + "Error! You do not have permission to use the parameter " + toCheck + " on the " + + disguiseType.toReadable() + " disguise!"); + } + } + if (miscId != -1) { + if (disguiseType == DisguiseType.FALLING_BLOCK) { + usedOptions.add("setblock"); + doCheck(optionPermissions, usedOptions); + } else if (disguiseType == DisguiseType.PAINTING) { + usedOptions.add("setpainting"); + doCheck(optionPermissions, usedOptions); + } else if (disguiseType == DisguiseType.SPLASH_POTION) { + usedOptions.add("setpotionid"); + doCheck(optionPermissions, usedOptions); + } + } + // Construct the disguise + disguise = new MiscDisguise(disguiseType, miscId, miscData); + } + } + } + // Copy strings to their new range + String[] newArgs = new String[args.length - toSkip]; + System.arraycopy(args, toSkip, newArgs, 0, args.length - toSkip); + args = newArgs; + Method[] methods = this.getDisguiseWatcherMethods(disguise.getWatcher().getClass()); + for (int i = 0; i < args.length; i += 2) { + String methodName = args[i]; + String valueString = (args.length - 1 == i ? null : args[i + 1]); + Method methodToUse = null; + Object value = null; + DisguiseParseException storedEx = null; + int c = 0; + while (c < methods.length) { + try { + Entry entry = getMethod(methods, methodName, c); + if (entry == null) { + break; + } + methodToUse = entry.getKey(); + c = entry.getValue(); + methodName = methodToUse.getName(); + Class[] types = methodToUse.getParameterTypes(); + Class param = types[0]; + if (valueString != null) { + if (int.class == param) { + // Parse to integer + if (isNumeric(valueString)) { + value = Integer.parseInt(valueString); + } else { + throw parseToException("number", valueString, methodName); + } + } else if (float.class == param || double.class == param) { + // Parse to number + if (isDouble(valueString)) { + float obj = Float.parseFloat(valueString); + if (param == float.class) { + value = obj; + } else if (param == double.class) { + value = (double) obj; + } + } else { + throw parseToException("number.0", valueString, methodName); + } + } else if (param == String.class) { + // Parse to string + value = ChatColor.translateAlternateColorCodes('&', valueString); + } else if (param == AnimalColor.class) { + // Parse to animal color + try { + value = AnimalColor.valueOf(valueString.toUpperCase()); + } catch (Exception ex) { + throw parseToException("animal color", valueString, methodName); + } + } else if (param == ItemStack.class) { + // Parse to itemstack + try { + value = parseToItemstack(valueString); + } catch (Exception ex) { + throw new DisguiseParseException(String.format(ex.getMessage(), methodName)); + } + } else if (param == ItemStack[].class) { + // Parse to itemstack array + ItemStack[] items = new ItemStack[4]; + String[] split = valueString.split(","); + if (split.length == 4) { + for (int a = 0; a < 4; a++) { + try { + items[a] = parseToItemstack(split[a]); + } catch (Exception ex) { + throw parseToException("item ID,ID,ID,ID" + ChatColor.RED + " or " + ChatColor.GREEN + + "ID:Data,ID:Data,ID:Data,ID:Data combo", valueString, methodName); + } + } + } else { + throw parseToException("item ID,ID,ID,ID" + ChatColor.RED + " or " + ChatColor.GREEN + + "ID:Data,ID:Data,ID:Data,ID:Data combo", valueString, methodName); + } + value = items; + } else if (param.getSimpleName().equals("Color")) { + // Parse to horse color + value = callValueOf(param, valueString, methodName, "a horse color"); + } else if (param.getSimpleName().equals("Style")) { + // Parse to horse style + value = callValueOf(param, valueString, methodName, "a horse style"); + } else if (param.getSimpleName().equals("Profession")) { + // Parse to villager profession + value = callValueOf(param, valueString, methodName, "a villager profession"); + } else if (param.getSimpleName().equals("Art")) { + // Parse to art type + value = callValueOf(param, valueString, methodName, "a painting art"); + } else if (param.getSimpleName().equals("Type")) { + // Parse to ocelot type + value = callValueOf(param, valueString, methodName, "a ocelot type"); + } else if (param == PotionEffectType.class) { + // Parse to potion effect + try { + PotionEffectType potionType = PotionEffectType.getByName(valueString.toUpperCase()); + if (potionType == null && isNumeric(valueString)) { + potionType = PotionEffectType.getById(Integer.parseInt(valueString)); + } + if (potionType == null) { + throw new DisguiseParseException(); + } + value = potionType; + } catch (Exception ex) { + throw parseToException("a potioneffect type", valueString, methodName); + } + } else if (param == int[].class) { + String[] split = valueString.split(","); + int[] values = new int[split.length]; + for (int b = 0; b < values.length; b++) { + try { + values[b] = Integer.parseInt(split[b]); + } catch (NumberFormatException ex) { + throw parseToException("Number,Number,Number...", valueString, methodName); + } + } + value = values; + } else if (param == BlockFace.class) { + try { + BlockFace face = BlockFace.valueOf(valueString.toUpperCase()); + if (face.ordinal() > 4) { + throw new DisguiseParseException(); + } + value = face; + } catch (Exception ex) { + throw parseToException("a direction (north, east, south, west, up)", valueString, methodName); + } + } else if (param == RabbitType.class) { + try { + for (RabbitType type : RabbitType.values()) { + if (type.name().replace("_", "") + .equalsIgnoreCase(valueString.replace("_", "").replace(" ", ""))) { + value = type; + break; + } + } + if (value == null) { + throw new Exception(); + } + } catch (Exception ex) { + throw parseToException("rabbit type (white, brown, patches...)", valueString, methodName); + } + } + } + if (value == null && boolean.class == param) { + if (valueString == null) { + value = true; + i--; + } else if (valueString.equalsIgnoreCase("true")) { + value = true; + } else if (valueString.equalsIgnoreCase("false")) { + value = false; + } else { + if (getMethod(methods, valueString, 0) == null) { + throw parseToException("true/false", valueString, methodName); + } else { + value = true; + i--; + } + } + } + if (value != null) { + break; + } + } catch (DisguiseParseException ex) { + storedEx = ex; + methodToUse = null; + } catch (Exception ex) { + ex.printStackTrace(System.out); + methodToUse = null; + } + } + if (methodToUse == null) { + if (storedEx != null) { + throw storedEx; + } + throw new DisguiseParseException(ChatColor.RED + "Cannot find the option " + methodName); + } + if (value == null) { + throw new DisguiseParseException(ChatColor.RED + "No value was given for the option " + methodName); + } + if (!usedOptions.contains(methodName.toLowerCase())) { + usedOptions.add(methodName.toLowerCase()); + } + doCheck(optionPermissions, usedOptions); + if (FlagWatcher.class.isAssignableFrom(methodToUse.getDeclaringClass())) { + methodToUse.invoke(disguise.getWatcher(), value); + } else { + methodToUse.invoke(disguise, value); + } + } + // Alright. We've constructed our disguise. + return disguise; + } + + private Entry getMethod(Method[] methods, String methodName, int toStart) { + for (int i = toStart; i < methods.length; i++) { + Method method = methods[i]; + if (!method.getName().startsWith("get") && method.getName().equalsIgnoreCase(methodName) + && method.getAnnotation(Deprecated.class) == null && method.getParameterTypes().length == 1) { + return new HashMap.SimpleEntry(method, ++i); + } + } + return null; + } + + private Object callValueOf(Class param, String valueString, String methodName, String description) + throws DisguiseParseException { + Object value; + try { + value = param.getMethod("valueOf", String.class).invoke(null, valueString.toUpperCase()); + } catch (Exception ex) { + throw parseToException(description, valueString, methodName); + } + return value; + } + + private boolean passesCheck(HashMap, Boolean> map1, ArrayList usedOptions) { + boolean hasPermission = false; + for (ArrayList list : map1.keySet()) { + boolean myPerms = true; + for (String option : usedOptions) { + if (!(map1.get(list) && list.contains("*")) && (list.contains(option) != map1.get(list))) { + myPerms = false; + break; + } + } + if (myPerms) { + hasPermission = true; + } + } + return hasPermission; + } + + private void doCheck(HashMap, Boolean> optionPermissions, ArrayList usedOptions) + throws DisguiseParseException { + if (!passesCheck(optionPermissions, usedOptions)) { + throw new DisguiseParseException(ChatColor.RED + "You do not have the permission to use the option " + + usedOptions.get(usedOptions.size() - 1)); + } + } + + private DisguiseParseException parseToException(String expectedValue, String receivedInstead, String methodName) { + return new DisguiseParseException(ChatColor.RED + "Expected " + ChatColor.GREEN + expectedValue + ChatColor.RED + + ", received " + ChatColor.GREEN + receivedInstead + ChatColor.RED + " instead for " + ChatColor.GREEN + + methodName); + } + + private ItemStack parseToItemstack(String string) throws Exception { + String[] split = string.split(":", -1); + if (isNumeric(split[0])) { + int itemId = Integer.parseInt(split[0]); + short itemDura = 0; + if (split.length > 1) { + if (isNumeric(split[1])) { + itemDura = Short.parseShort(split[1]); + } else { + throw parseToException("item ID:Durability combo", string, "%s"); + } + } + return new ItemStack(itemId, 1, itemDura); + } else { + if (split.length == 1) { + throw parseToException("item ID", string, "%s"); + } else { + throw parseToException("item ID:Durability combo", string, "%s"); + } + } + } + + protected abstract void sendCommandUsage(CommandSender sender, HashMap, Boolean>> map); +} diff --git a/src/main/java/me/libraryaddict/disguise/commands/DisguiseCloneCommand.java b/src/main/java/me/libraryaddict/disguise/commands/CloneDisguiseCommand.java similarity index 97% rename from src/main/java/me/libraryaddict/disguise/commands/DisguiseCloneCommand.java rename to src/main/java/me/libraryaddict/disguise/commands/CloneDisguiseCommand.java index 4559b9a9..fd77c87e 100644 --- a/src/main/java/me/libraryaddict/disguise/commands/DisguiseCloneCommand.java +++ b/src/main/java/me/libraryaddict/disguise/commands/CloneDisguiseCommand.java @@ -11,7 +11,7 @@ import org.bukkit.command.CommandSender; import java.util.ArrayList; import java.util.HashMap; -public class DisguiseCloneCommand extends BaseDisguiseCommand { +public class CloneDisguiseCommand extends BaseDisguiseCommand { @Override public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) { diff --git a/src/main/java/me/libraryaddict/disguise/commands/DisguiseEntityCommand.java b/src/main/java/me/libraryaddict/disguise/commands/EntityDisguiseCommand.java similarity index 97% rename from src/main/java/me/libraryaddict/disguise/commands/DisguiseEntityCommand.java rename to src/main/java/me/libraryaddict/disguise/commands/EntityDisguiseCommand.java index 7977643e..7a7d64a6 100644 --- a/src/main/java/me/libraryaddict/disguise/commands/DisguiseEntityCommand.java +++ b/src/main/java/me/libraryaddict/disguise/commands/EntityDisguiseCommand.java @@ -13,7 +13,7 @@ import java.lang.reflect.InvocationTargetException; import java.util.ArrayList; import java.util.HashMap; -public class DisguiseEntityCommand extends BaseDisguiseCommand { +public class EntityDisguiseCommand extends BaseDisguiseCommand { @Override public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) { diff --git a/src/main/java/me/libraryaddict/disguise/commands/DisguiseHelpCommand.java b/src/main/java/me/libraryaddict/disguise/commands/HelpDisguiseCommand.java similarity index 99% rename from src/main/java/me/libraryaddict/disguise/commands/DisguiseHelpCommand.java rename to src/main/java/me/libraryaddict/disguise/commands/HelpDisguiseCommand.java index 71391d35..2656a21f 100644 --- a/src/main/java/me/libraryaddict/disguise/commands/DisguiseHelpCommand.java +++ b/src/main/java/me/libraryaddict/disguise/commands/HelpDisguiseCommand.java @@ -19,7 +19,7 @@ import java.util.Arrays; import java.util.Collections; import java.util.HashMap; -public class DisguiseHelpCommand extends BaseDisguiseCommand { +public class HelpDisguiseCommand extends BaseDisguiseCommand { private class EnumHelp { @@ -65,7 +65,7 @@ public class DisguiseHelpCommand extends BaseDisguiseCommand { private ArrayList enumHelp = new ArrayList<>(); - public DisguiseHelpCommand() { + public HelpDisguiseCommand() { try { enumHelp.add(new EnumHelp("AnimalColor", "Animal colors", ChatColor.RED + "/disguisehelp AnimalColors " + ChatColor.GREEN + "- View all the colors you can use for a animal color", AnimalColor.values())); diff --git a/src/main/java/me/libraryaddict/disguise/commands/DisguisePlayerCommand.java b/src/main/java/me/libraryaddict/disguise/commands/PlayerDisguiseCommand.java similarity index 98% rename from src/main/java/me/libraryaddict/disguise/commands/DisguisePlayerCommand.java rename to src/main/java/me/libraryaddict/disguise/commands/PlayerDisguiseCommand.java index ff960c62..e373cde5 100644 --- a/src/main/java/me/libraryaddict/disguise/commands/DisguisePlayerCommand.java +++ b/src/main/java/me/libraryaddict/disguise/commands/PlayerDisguiseCommand.java @@ -15,7 +15,7 @@ import org.bukkit.entity.Player; import java.util.ArrayList; import java.util.HashMap; -public class DisguisePlayerCommand extends BaseDisguiseCommand { +public class PlayerDisguiseCommand extends BaseDisguiseCommand { @Override public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) { diff --git a/src/main/java/me/libraryaddict/disguise/commands/DisguiseRadiusCommand.java b/src/main/java/me/libraryaddict/disguise/commands/RadiusDisguiseCommand.java similarity index 98% rename from src/main/java/me/libraryaddict/disguise/commands/DisguiseRadiusCommand.java rename to src/main/java/me/libraryaddict/disguise/commands/RadiusDisguiseCommand.java index 01acb288..92feb477 100644 --- a/src/main/java/me/libraryaddict/disguise/commands/DisguiseRadiusCommand.java +++ b/src/main/java/me/libraryaddict/disguise/commands/RadiusDisguiseCommand.java @@ -19,12 +19,12 @@ import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; -public class DisguiseRadiusCommand extends BaseDisguiseCommand { +public class RadiusDisguiseCommand extends BaseDisguiseCommand { private int maxRadius = 30; private ArrayList validClasses = new ArrayList<>(); - public DisguiseRadiusCommand(int maxRadius) { + public RadiusDisguiseCommand(int maxRadius) { this.maxRadius = maxRadius; for (Class c : ClassGetter.getClassesForPackage("org.bukkit.entity")) { if (c != Entity.class && Entity.class.isAssignableFrom(c) && c.getAnnotation(Deprecated.class) == null) {