/** * Get a map with all the registered flags. * * <p>The flag names do not have the '-' in front of it. * * <p>If this command is a sub command this will include all the flags from the parent. * * @return Map with registered flags. */ public Map<String, Flag> getAllFlags() { if (isBase()) { return new HashMap<>(flags); } Map<String, Flag> flags = new LinkedHashMap<>(getBaseCmd().getFlags()); flags.putAll(this.flags); return flags; }
/** * Get a map with all the registered modifiers. * * <p>If this command is a sub command this will include all the modifiers from the parent. * * @return Map with registered modifiers. */ public Map<String, Modifier> getAllModifiers() { if (isBase()) { return new HashMap<>(modifiers); } Map<String, Modifier> modifiers = new LinkedHashMap<>(getBaseCmd().getModifiers()); modifiers.putAll(this.modifiers); return modifiers; }
@Override public Map<String, String[]> getCommandAliases() { Map<String, String[]> aliases = new HashMap<>(); ConfigurationSection section = config.getConfigFile(ServerConfig.Key.COMMANDS_FILE).getConfigurationSection("aliases"); if (section == null) { return aliases; } for (String key : section.getKeys(false)) { List<String> list = section.getStringList(key); aliases.put(key, list.toArray(new String[list.size()])); } return aliases; }
/** * Register a command flag for this command. * * <p>A command flag represents a boolean that can be added anywhere in the command. The specified * name must be used by the user to specify the flag. * * <p>For example if the name is 'f' the user can specify '-f' anywhere in the command. * * <p>You don't have to prefix the name with a '-' If you do it will be removed so if you want to * have the user put '--f' you have to set the name as '--f' * * @param name The flag name/key used to identify the flag. This name must be used with the {@link * CmdData} result to check if the flag was specified. This name is also what the user needs * to use to specify the flag. (-{name}) The name '?' is reserved! * @return The added {@link Flag} * @throws IllegalArgumentException if a flag with the specified name is already registered for * this command. */ public Flag addFlag(String name) { if (name.startsWith("-")) { name = name.substring(1); } Flag flag = new Flag(name); if (getAllFlags().containsKey(name.toLowerCase())) { throw new IllegalArgumentException( "The command already has a flag with the name '-" + name + "'!"); } flags.put(name.toLowerCase(), flag); return flag; }
/** * Register a command modifier for this command. * * <p>A command modifier is an optional argument that can be added anywhere in the command. The * specified name must be used by the user to specify the modifier. * * <p>For example if you register a modifier with the name player and the option is a {@link * PlayerO} The user would put player:{player} anywhere in the command to set the modifer value. * * @param name The modifier name/key used to identify the argument. This name must be used with * the {@link CmdData} result to get the modifier value. This name is also what the user needs * to use to specify the modifier. ({name}:{value}) * @param option The {@link SingleOption} used for parsing the modifier. This option determines * the modifier value and everything else. For example if it's a {@link PlayerO} the modifier * value must be a player and the result value would be a player. This option can't be a sub * command option! * @return The added {@link Modifier} * @throws IllegalArgumentException if a modifier with the specified name is already registered * for this command or if the modifier has a sub command option. */ public Modifier addModifier(String name, SingleOption option) { Modifier modifier = new Modifier(name, option); if (option instanceof SubCmdO) { throw new IllegalArgumentException( "Modifiers can not be a sub command option! [modifier=" + name + "]"); } if (getAllModifiers().containsKey(name.toLowerCase())) { throw new IllegalArgumentException( "The command already has a modifier with the name '" + name + "'!"); } modifiers.put(name.toLowerCase(), modifier); return modifier; }
private static ServerConfig parseArguments(String[] args) { final Map<ServerConfig.Key, Object> parameters = new EnumMap<>(ServerConfig.Key.class); String configDirName = "config"; String configFileName = "glowstone.yml"; // Calculate acceptable parameters for (int i = 0; i < args.length; i++) { final String opt = args[i]; if (!opt.startsWith("-")) { System.err.println("Ignored invalid option: " + opt); continue; } // Help and version if ("--help".equals(opt) || "-h".equals(opt) || "-?".equals(opt)) { System.out.println("Available command-line options:"); System.out.println(" --help, -h, -? Shows this help message and exits."); System.out.println(" --version, -v Shows version information and exits."); System.out.println(" --configdir <directory> Sets the configuration directory."); System.out.println(" --configfile <file> Sets the configuration file."); System.out.println(" --port, -p <port> Sets the server listening port."); System.out.println(" --host, -H <ip | hostname> Sets the server listening address."); System.out.println(" --onlinemode, -o <onlinemode> Sets the server's online-mode."); System.out.println(" --jline <true/false> Enables or disables JLine console."); System.out.println(" --plugins-dir, -P <directory> Sets the plugin directory to use."); System.out.println(" --worlds-dir, -W <directory> Sets the world directory to use."); System.out.println( " --update-dir, -U <directory> Sets the plugin update folder to use."); System.out.println(" --max-players, -M <director> Sets the maximum amount of players."); System.out.println(" --world-name, -N <name> Sets the main world name."); System.out.println( " --log-pattern, -L <pattern> Sets the log file pattern (%D for date)."); return null; } else if ("--version".equals(opt) || "-v".equals(opt)) { System.out.println( "Glowstone version: " + GlowServer.class.getPackage().getImplementationVersion()); System.out.println( "Bukkit version: " + GlowServer.class.getPackage().getSpecificationVersion()); System.out.println("Minecraft version: " + GAME_VERSION + " protocol " + PROTOCOL_VERSION); return null; } // Below this point, options require parameters if (i == args.length - 1) { System.err.println("Ignored option specified without value: " + opt); continue; } switch (opt) { case "--configdir": configDirName = args[++i]; break; case "--configfile": configFileName = args[++i]; break; case "--port": case "-p": parameters.put(ServerConfig.Key.SERVER_PORT, Integer.valueOf(args[++i])); break; case "--host": case "-H": parameters.put(ServerConfig.Key.SERVER_IP, args[++i]); break; case "--onlinemode": case "-o": parameters.put(ServerConfig.Key.ONLINE_MODE, Boolean.valueOf(args[++i])); break; case "--jline": parameters.put(ServerConfig.Key.USE_JLINE, Boolean.valueOf(args[++i])); break; case "--plugins-dir": case "-P": parameters.put(ServerConfig.Key.PLUGIN_FOLDER, args[++i]); break; case "--worlds-dir": case "-W": parameters.put(ServerConfig.Key.WORLD_FOLDER, args[++i]); break; case "--update-dir": case "-U": parameters.put(ServerConfig.Key.UPDATE_FOLDER, args[++i]); break; case "--max-players": case "-M": parameters.put(ServerConfig.Key.MAX_PLAYERS, Integer.valueOf(args[++i])); break; case "--world-name": case "-N": parameters.put(ServerConfig.Key.LEVEL_NAME, args[++i]); break; case "--log-pattern": case "-L": parameters.put(ServerConfig.Key.LOG_FILE, args[++i]); break; default: System.err.println("Ignored invalid option: " + opt); } } final File configDir = new File(configDirName); final File configFile = new File(configDir, configFileName); return new ServerConfig(configDir, configFile, parameters); }
/** * Display a detailed help message to the specified {@link CommandSender} * * <p>If the sender is a player or console it will display 'all' details. If it's not it will only * display the usage string. * * @param sender The {@link CommandSender} to send the message to. */ public void showHelp(CommandSender sender, String label, String[] args) { if ((!(sender instanceof Player) && sender instanceof Entity) || sender instanceof BlockCommandSender) { Msg.fromString(getUsage(sender, label, args)).send(sender); return; } String none = Msg.getString("command.none"); String noDesc = Msg.getString("command.no-description"); List<String> blacklisted = new ArrayList<>(); for (SenderType type : getSenderBlacklist()) { blacklisted.add(Str.camelCase(type.toString())); } String perm = ""; if (perm().isEmpty() && getBaseCmd().perm().isEmpty()) { perm = none; } else { if (!perm().isEmpty()) { perm = perm(); } if (isSub() && !getBaseCmd().perm().isEmpty()) { if (!perm.isEmpty()) { perm += " "; } perm += Msg.getString("command.permission-inherit", Param.P("permission", getBaseCmd().perm())); } } List<String> flagFormats = new ArrayList<>(); for (Flag flag : getAllFlags().values()) { boolean inherit = !flags.containsKey(flag.name().toLowerCase()) || flag.name().equals("?") || flag.name().equals("l"); if (sender instanceof Player) { flagFormats.add( Msg.getString( inherit ? "command.flag-entry-inherit" : "command.flag-entry", Param.P("name", flag.name()), Param.P("description", flag.desc().isEmpty() ? noDesc : flag.desc()), Param.P("permission", flag.perm().isEmpty() ? none : flag.perm()))); } else { flagFormats.add((inherit ? "&a&l-" : "&7&l-") + flag.name()); } } List<String> modifierFormats = new ArrayList<>(); for (Modifier mod : getAllModifiers().values()) { boolean inherit = !modifiers.containsKey(mod.name().toLowerCase()) || mod.name().equals("page"); if (sender instanceof Player) { modifierFormats.add( Msg.getString( inherit ? "command.modifier-entry-inherit" : "command.modifier-entry", Param.P("name", mod.name()), Param.P("description", mod.desc().isEmpty() ? noDesc : mod.desc()), Param.P("permission", mod.perm().isEmpty() ? none : mod.perm()), Param.P("type", mod.option().getTypeName()))); } else { modifierFormats.add( inherit ? "&a" + mod.name() + ":&8[&a" + mod.option().getTypeName() + "&8]" : "&7" + mod.name() + ":&8[&7" + mod.option().getTypeName() + "&8]"); } } String argClr = Msg.getString("command.argument-name-color"); String msg = Msg.getString( "command.help", Param.P("label", label), Param.P("cmd", getBaseCmd().getName()), Param.P( "usage", sender instanceof ConsoleCommandSender ? new CmdUsageParser(this, sender, label, args, argClr).getString() : new CmdUsageParser(this, sender, label, args, argClr).getJSON()), Param.P("description", desc().isEmpty() ? noDesc : desc()), Param.P("permission", perm), Param.P( "aliases", isSub() ? (((SubCmd) this).getSubAliases().isEmpty() ? none : Str.implode(((SubCmd) this).getSubAliases())) : (getAliases().isEmpty() ? none : Str.implode(getAliases()))), Param.P("flags", flagFormats.isEmpty() ? none : Str.implode(flagFormats, " ")), Param.P("modifiers", modifierFormats.isEmpty() ? none : Str.implode(modifierFormats))); Msg.fromString(msg).send(sender); }