Beispiel #1
0
  public static void broadcastCommandMessage(
      CommandSender source, String message, boolean sendToSource) {
    String result = source.getName() + ": " + message;

    if (source instanceof BlockCommandSender) {
      BlockCommandSender blockCommandSender = (BlockCommandSender) source;

      if (blockCommandSender
          .getBlock()
          .getWorld()
          .getGameRuleValue("commandBlockOutput")
          .equalsIgnoreCase("false")) {
        Bukkit.getConsoleSender().sendMessage(result);
        return;
      }
    } else if (source instanceof CommandMinecart) {
      CommandMinecart commandMinecart = (CommandMinecart) source;

      if (commandMinecart
          .getWorld()
          .getGameRuleValue("commandBlockOutput")
          .equalsIgnoreCase("false")) {
        Bukkit.getConsoleSender().sendMessage(result);
        return;
      }
    }

    Set<Permissible> users =
        Bukkit.getPluginManager()
            .getPermissionSubscriptions(Server.BROADCAST_CHANNEL_ADMINISTRATIVE);
    String colored =
        ChatColor.GRAY
            + ""
            + ChatColor.ITALIC
            + "["
            + result
            + ChatColor.GRAY
            + ChatColor.ITALIC
            + "]";

    if (sendToSource && !(source instanceof ConsoleCommandSender)) {
      source.sendMessage(message);
    }

    for (Permissible user : users) {
      if (user instanceof CommandSender) {
        CommandSender target = (CommandSender) user;

        if (target instanceof ConsoleCommandSender) {
          target.sendMessage(result);
        } else if (target != source) {
          target.sendMessage(colored);
        }
      }
    }
  }
Beispiel #2
0
  /**
   * ********************************************************** onCommand()
   * **********************************************************
   */
  public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
    if (sender instanceof Player) {
      Player player = (Player) sender;

      if (args.length == 0) {
        return false;
      }

      if (args[0].equals("getPos")) {
        this.getPos(player, cmd, label, args);
      } else if (args[0].equals("setPos1")) {
        this.setPos1(player, cmd, label, args);
      } else if (args[0].equals("setPos2")) {
        this.setPos2(player, cmd, label, args);
      } else if (args[0].equals("resetPos")) {
        this.resetPos(player, cmd, label, args);
      } else if (args[0].equals("teleport")) {
        this.cmdTeleport.commandHandler(sender, cmd, label, args, this.pos1, this.pos2);
      } else if (args[0].equals("license")) {
        this.cmdLicense.commandHandler(sender, cmd, label, args);
      } else if (args[0].equals("player")) {
        this.cmdPlayer.commandHandler(sender, cmd, label, args);
      }

      return true;
    } else {
      sender.sendMessage("You must be a player!");
    }

    return false;
  }
Beispiel #3
0
  /**
   * Executed on tab completion for this command, returning a list of options the player can tab
   * through.
   *
   * @param sender Source object which is executing this command
   * @param alias the alias being used
   * @param args All arguments passed to the command, split via ' '
   * @return a list of tab-completions for the specified arguments. This will never be null. List
   *     may be immutable.
   * @throws IllegalArgumentException if sender, alias, or args is null
   */
  public List<String> tabComplete(CommandSender sender, String alias, String[] args)
      throws IllegalArgumentException {
    Validate.notNull(sender, "Sender cannot be null");
    Validate.notNull(args, "Arguments cannot be null");
    Validate.notNull(alias, "Alias cannot be null");

    if (args.length == 0) {
      return ImmutableList.of();
    }

    String lastWord = args[args.length - 1];

    Player senderPlayer = sender instanceof Player ? (Player) sender : null;

    ArrayList<String> matchedPlayers = new ArrayList<String>();
    for (Player player : sender.getServer().getOnlinePlayers()) {
      String name = player.getName();
      if ((senderPlayer == null || senderPlayer.canSee(player))
          && StringUtil.startsWithIgnoreCase(name, lastWord)) {
        matchedPlayers.add(name);
      }
    }

    Collections.sort(matchedPlayers, String.CASE_INSENSITIVE_ORDER);
    return matchedPlayers;
  }
  @Override
  public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
    String name = cmd.getName();
    if (!commandMap.containsKey(name)) {
      // That command doesn't belong to us
      return true;
    }

    SearchResult result = searchCommand(name, args);
    if (result == null || result.container == null) {
      sender.sendMessage(messageBundle.getMessage("message-unknown-command"));
      return true;
    }

    CommandContainer command = result.container;
    int deepness = result.deepness;

    // Cut the args to be suitable to the sub-command-deepness
    String[] cutArgs = new String[args.length - deepness];
    System.arraycopy(args, deepness, cutArgs, 0, args.length - deepness);

    CommandContext context = new CommandContext(cutArgs, command, sender);
    command.execute(
        context, messageBundle, permissionChecker, this.args.toArray(new Object[this.args.size()]));
    return true;
  }
Beispiel #5
0
  @Override
  public void cmdStatus(CommandSender sender) {
    if (!(sender instanceof Player)) return;

    boolean bypass = Config.isPlayerBypassing(((Player) sender).getUniqueId());
    sender.sendMessage(
        C_HEAD + "Border bypass is currently " + enabledColored(bypass) + C_HEAD + " for you.");
  }
Beispiel #6
0
  /**
   * Tests the given {@link CommandSender} to see if they can perform this command.
   *
   * <p>If they do not have permission, they will be informed that they cannot do this.
   *
   * @param target User to test
   * @return true if they can use it, otherwise false
   */
  public boolean testPermission(CommandSender target) {
    if (testPermissionSilent(target)) {
      return true;
    }

    if (permissionMessage == null) {
      target.sendMessage(
          ChatColor.RED
              + "I'm sorry, but you do not have permission to perform this command. Please contact the server administrators if you believe that this is in error.");
    } else if (permissionMessage.length() != 0) {
      for (String line : permissionMessage.replace("<permission>", permission).split("\n")) {
        target.sendMessage(line);
      }
    }

    return false;
  }
  public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
    if (cmd.getName().equalsIgnoreCase("msreload")) {
      if (sender instanceof Player) {
        Player player = (Player) sender;
        if (player.hasPermission("MobspawnSettings.settings") == false) {
          sender.sendMessage("You don't have the required permissions MobspawnSettings.settings");
          return true;
        }
      }

      MsConfig config = main.getMsConfig();
      config.reloadConfiguration(false);
      sender.sendMessage("Reloaded");
      return true;
    }

    return false;
  }
	@Override
	public void showCommandError(final CommandSender sender, final String commandLabel, final Throwable exception)
	{
		sender.sendMessage(_("errorWithMessage", exception.getMessage()));
		if (ess.getSettings().isDebug())
		{
			LOGGER.log(Level.WARNING, _("errorCallingCommand", commandLabel), exception);
		}
	}
 @Override
 public void cmdStatus(CommandSender sender) {
   sender.sendMessage(
       C_HEAD
           + "DynMap border display is "
           + enabledColored(Config.DynmapBorderEnabled())
           + C_HEAD
           + ".");
 }
 @Override
 public int broadcast(String message, String permission) {
   int count = 0;
   for (Permissible permissible : getPluginManager().getPermissionSubscriptions(permission)) {
     if (permissible instanceof CommandSender && permissible.hasPermission(permission)) {
       ((CommandSender) permissible).sendMessage(message);
       ++count;
     }
   }
   return count;
 }
 @Override
 public boolean execute(CommandSender sender, String commandLabel, String[] args) {
   if (exe != null) {
     if (!FOPMR_Rank.isEqualOrHigher(FOPMR_Rank.getRank(sender), rank)) {
       sender.sendMessage(
           ChatColor.RED
               + "You must be "
               + CUtils_Methods.aOrAn(rank.name)
               + " "
               + rank.name
               + " to use this command.");
       return true;
     }
     if (!exe.onCommand(sender, this, commandLabel, args)) {
       sender.sendMessage(this.usageMessage.replaceAll("<command>", command));
       return false;
     }
     return true;
   }
   return false;
 }
Beispiel #12
0
  /**
   * Tests the given {@link CommandSender} to see if they can perform this command.
   *
   * <p>No error is sent to the sender.
   *
   * @param target User to test
   * @return true if they can use it, otherwise false
   */
  public boolean testPermissionSilent(CommandSender target) {
    if ((permission == null) || (permission.length() == 0)) {
      return true;
    }

    for (String p : permission.split(";")) {
      if (target.hasPermission(p)) {
        return true;
      }
    }

    return false;
  }
Beispiel #13
0
  public boolean onCommand(
      final CommandSender sender,
      org.bukkit.command.Command cmd,
      String label,
      final String[] args) {
    if (cmd.getName().equalsIgnoreCase("enablemaps")) {

      if (args.length < 1
          && !args[0].equalsIgnoreCase("battles")
          && !args[0].equalsIgnoreCase("arcade")) {
        sender.sendMessage(ChatColor.RED + "Invalid map type! Options: 'battles','arcade'");
        return false;
      }

      String type = args[0];

      if (type.equalsIgnoreCase("battles")) {
        if (!battleMapsLoaded) {
          loadMaps(BATTLE_MAPS_PACKAGE);
          sender.sendMessage(ChatColor.DARK_AQUA + "Loaded battles maps!");
          battleMapsLoaded = true;
        } else {
          sender.sendMessage(ChatColor.RED + "Battles maps already loaded!");
        }
      }

      if (type.equalsIgnoreCase("arcade")) {
        if (!arcadeMapsLoaded) {
          loadMaps(ARCADE_MAPS_PACKAGE);
          sender.sendMessage(ChatColor.DARK_AQUA + "Loaded arcade maps!");
          arcadeMapsLoaded = true;
        } else {
          sender.sendMessage(ChatColor.RED + "Arcade maps already loaded!");
        }
      }
    }
    return true;
  }
  @Override
  public boolean dispatchCommand(CommandSender sender, String commandLine) throws CommandException {
    if (commandMap.dispatch(sender, commandLine)) {
      return true;
    }

    String firstword = commandLine;
    if (firstword.indexOf(' ') >= 0) {
      firstword = firstword.substring(0, firstword.indexOf(' '));
    }

    sender.sendMessage(ChatColor.GRAY + "Unknown command \"" + firstword + "\", try \"help\"");
    return false;
  }
Beispiel #15
0
  @Override
  public boolean onCommand(CommandSender sender, Command command, String label, String[] split) {
    Player player = (sender instanceof Player) ? (Player) sender : null;

    // if world name is passed inside quotation marks, handle that, and get List<String> instead of
    // String[]
    List<String> params = concatenateQuotedWorldName(split);

    String worldName = null;
    // is second parameter the command and first parameter a world name? definitely world name if it
    // was in quotation marks
    if (wasWorldQuotation
        || (params.size() > 1
            && !subCommands.containsKey(params.get(0))
            && subCommandsWithWorldNames.contains(params.get(1)))) worldName = params.get(0);

    // no command specified? show command examples / help
    if (params.isEmpty()) params.add(0, "commands");

    // determined the command name
    String cmdName =
        (worldName == null) ? params.get(0).toLowerCase() : params.get(1).toLowerCase();

    // remove command name and (if there) world name from front of param array
    params.remove(0);
    if (worldName != null) params.remove(0);

    // make sure command is recognized, default to showing command examples / help if not; also
    // check for specified page number
    if (!subCommands.containsKey(cmdName)) {
      int page = (player == null) ? 0 : 1;
      try {
        page = Integer.parseInt(cmdName);
      } catch (NumberFormatException ignored) {
        sender.sendMessage(WBCmd.C_ERR + "Command not recognized. Showing command list.");
      }
      cmdName = "commands";
      params.add(0, Integer.toString(page));
    }

    WBCmd subCommand = subCommands.get(cmdName);

    // check permission
    if (!Config.HasPermission(player, subCommand.permission)) return true;

    // if command requires world name when run by console, make sure that's in place
    if (player == null
        && subCommand.hasWorldNameInput
        && subCommand.consoleRequiresWorldName
        && worldName == null) {
      sender.sendMessage(
          WBCmd.C_ERR + "This command requires a world to be specified if run by the console.");
      subCommand.sendCmdHelp(sender);
      return true;
    }

    // make sure valid number of parameters has been provided
    if (params.size() < subCommand.minParams || params.size() > subCommand.maxParams) {
      if (subCommand.maxParams == 0)
        sender.sendMessage(WBCmd.C_ERR + "This command does not accept any parameters.");
      else sender.sendMessage(WBCmd.C_ERR + "You have not provided a valid number of parameters.");
      subCommand.sendCmdHelp(sender);
      return true;
    }

    // execute command
    subCommand.execute(sender, player, params, worldName);

    return true;
  }
	@Override
	public boolean handleCommand(final CommandSender sender, final Command command, final String commandLabel, final String[] args)
	{
		boolean disabled = false;
		boolean overridden = false;
		ISettings settings = ess.getSettings();
		settings.acquireReadLock();
		try
		{
			disabled = settings.getData().getCommands().isDisabled(command.getName());
			overridden = !disabled || settings.getData().getCommands().isOverridden(command.getName());
		}
		finally
		{
			settings.unlock();
		}
		// Allow plugins to override the command via onCommand
		if (!overridden && (!commandLabel.startsWith("e") || commandLabel.equalsIgnoreCase(command.getName())))
		{
			final PluginCommand pc = getAlternative(commandLabel);
			if (pc != null)
			{
				
				executed(commandLabel, pc.getLabel());
				try
				{
					return pc.execute(sender, commandLabel, args);
				}
				catch (final Exception ex)
				{
					final ArrayList<StackTraceElement> elements = new ArrayList<StackTraceElement>(Arrays.asList(ex.getStackTrace()));
					elements.remove(0);
					final ArrayList<StackTraceElement> toRemove = new ArrayList<StackTraceElement>();
					for (final StackTraceElement e : elements)
					{
						if (e.getClassName().equals("net.ess3.Essentials"))
						{
							toRemove.add(e);
						}
					}
					elements.removeAll(toRemove);
					final StackTraceElement[] trace = elements.toArray(new StackTraceElement[elements.size()]);
					ex.setStackTrace(trace);
					ex.printStackTrace();
					sender.sendMessage(ChatColor.RED + "An internal error occurred while attempting to perform this command");
					return true;
				}
			}
		}

		try
		{
			IUser user = null;
			if (sender instanceof Player)
			{
				user = ess.getUserMap().getUser((Player)sender);
				LOGGER.log(Level.INFO, String.format("[PLAYER_COMMAND] %s: /%s %s ", ((Player)sender).getName(), commandLabel, EssentialsCommand.getFinalArg(args, 0)));
			}

			// Check for disabled commands
			if (disabled)
			{
				return true;
			}

			final String commandName = command.getName().toLowerCase(Locale.ENGLISH);
			IEssentialsCommand cmd = commands.get(commandName);
			if (cmd == null)
			{
				try
				{
					cmd = (IEssentialsCommand)classLoader.loadClass(commandPath + commandName).newInstance();
					cmd.init(ess, commandName);
					cmd.setEssentialsModule(module);
					commands.put(commandName, cmd);
				}
				catch (Exception ex)
				{
					sender.sendMessage(_("commandNotLoaded", commandName));
					LOGGER.log(Level.SEVERE, _("commandNotLoaded", commandName), ex);
					return true;
				}
			}

			// Check authorization
			if (sender != null && !cmd.isAuthorized(sender))
			{
				LOGGER.log(Level.WARNING, _("deniedAccessCommand", user.getName()));
				user.sendMessage(_("noAccessCommand"));
				return true;
			}

			// Run the command
			try
			{
				if (user == null)
				{
					cmd.run(sender, command, commandLabel, args);
				}
				else
				{
					user.acquireReadLock();
					try
					{
						cmd.run(user, command, commandLabel, args);
					}
					finally
					{
						user.unlock();
					}
				}
				return true;
			}
			catch (NoChargeException ex)
			{
				return true;
			}
			catch (NotEnoughArgumentsException ex)
			{
				sender.sendMessage(command.getDescription());
				sender.sendMessage(command.getUsage().replaceAll("<command>", commandLabel));
				if (!ex.getMessage().isEmpty())
				{
					sender.sendMessage(ex.getMessage());
				}
				return true;
			}
			catch (Throwable ex)
			{
				showCommandError(sender, commandLabel, ex);
				return true;
			}
		}
		catch (Throwable ex)
		{
			LOGGER.log(Level.SEVERE, _("commandFailed", commandLabel), ex);
			return true;
		}
	}