Package org.bukkit.entity

Examples of org.bukkit.entity.Player


    }
   
    // run through all online players and check their playtime
    Iterator<Entry<String, Integer>> it = CommandsEX.playTimes.entrySet().iterator();
    while (it.hasNext()) {
      Player p;
      Integer playerValue;
      if (players.length > 0) {
        p = players[0];
        playerValue = CommandsEX.playTimes.get(p.getName());
      } else {
        Map.Entry<String, Integer> playTimePairs = (Map.Entry<String, Integer>)it.next();
        p = Bukkit.getServer().getPlayer(playTimePairs.getKey());
        playerValue = playTimePairs.getValue();
      }
View Full Code Here


    }
   
    // load up settings from config file
    FileConfiguration f = CommandsEX.getConf();
    ConfigurationSection configGroups = f.getConfigurationSection("timedPromote");
    Player p = (Player)sender;
    Long currentGroupTime = f.getLong("timedPromote." + Vault.perms.getPrimaryGroup(p));
    Long nextGroupTime = 9223372036854775807L; // maximum value of LONG in Java
    String nextRankName = "?";
    for (String s : configGroups.getKeys(true)) {
      // ignore default group with time 0, since that one is an example record
      Long t = f.getLong("timedPromote." + s);
      if (s.equals("default") && (t == 0)) continue;
     
      // check if this group has more time set than current one and set it as the next group's time
      if (t > currentGroupTime) {
        // if our current time for next group is higher than the one we found now, use the one we found,
        // otherwise leave the previous one, since it's closer to our current rank
        if (nextGroupTime > t) {
          nextGroupTime = t;
          nextRankName = s;
        }
      }
    }
   
    if (nextGroupTime == 9223372036854775807L) {
      // there are no higher ranks
      LogHelper.showInfo("timedPromoteHighestRank", sender, ChatColor.GREEN);
    } else {
      // calculate how much time we have left until the next rank
      Long remain = nextGroupTime - CommandsEX.playTimes.get(p.getName());
      Map<String, Integer> m = Utils.parseTimeStamp(remain);
      LogHelper.showInfo("timedPromoteTime2RankLeft#####[" + (m.get("days") + " #####days#####[, ") + (m.get("hours") + " #####hours#####[, ") + (m.get("minutes") + " #####minutes#####[, ") + (m.get("seconds") + " #####seconds"), sender);
      LogHelper.showInfo("timedPromoteTime2RankNextRank#####[" + nextRankName, sender);
    }
View Full Code Here

   * @param args
   * @return
   */
  public static Boolean run(CommandSender sender, String alias, String[] args) {
    if (PlayerHelper.checkIsPlayer(sender)) {
      Player player = (Player)sender;
      // check permissions and call to action
      if (args.length > 0) {
        Boolean hasPerms = true;
        if ((args.length == 1) && args[0].toLowerCase().equals("set") && (hasPerms = Permissions.checkPerms(player, "cex.sethome"))) {
          /***
 
View Full Code Here

  public static Boolean run(CommandSender sender, String alias, String[] args){
    if (!PlayerHelper.checkIsPlayer(sender)){
      return true;
    }
   
    Player player = (Player) sender;
   
    if (args.length > 0){
      Commands.showCommandHelpAndUsage(sender, "cex_afk", alias);
      return true;
    }
View Full Code Here

    if (args.length == 0 || args.length > 2 || (args.length == 1 && !(sender instanceof Player))){
      Commands.showCommandHelpAndUsage(sender, "cex_nametag", alias);
      return true;
    }
   
    Player target;
    String tagTo;
   
    if (args.length == 1){
      target = (Player) sender;
      tagTo = args[0];
    } else {
      if (!sender.hasPermission("cex.nametag.others")){
        LogHelper.showInfo("tagOthersNoPerm", sender, ChatColor.RED);
        return true;
      }
     
      target = Bukkit.getPlayer(args[0]);
      if (target == null){
        LogHelper.showInfo("invalidPlayer", sender, ChatColor.RED);
        return true;
      }
     
      tagTo = args[1];
    }
   
    // if nickto = reset then reset their nametag to default
    if (tagTo.equalsIgnoreCase("reset")){
      resetTag(target);
     
      if (!sender.equals(target)){
        LogHelper.showInfo("tagResetConfirm#####[" + Nicknames.getNick(target.getName()), sender, ChatColor.AQUA);
        LogHelper.showInfo("[" + Nicknames.getNick(sender.getName()) + " #####tagResetNotify", target, ChatColor.AQUA);
      } else {
        LogHelper.showInfo("tagResetSelf", sender, ChatColor.AQUA);
      }
     
      return true;
    }
   
    if (Utils.hasChatColor(tagTo)){
      if (!sender.hasPermission("cex.nametag.color")){
        LogHelper.showInfo("tagColorNoPerm", sender);
        return true;
      }
    }
   
    setTag(target.getName(), tagTo);
   
    if (!sender.equals(target)){
      LogHelper.showInfo("tagConfirm#####[" + Nicknames.getNick(target.getName()) + " #####nickSetTo#####[" + Utils.replaceChatColors(tagTo), sender, ChatColor.AQUA);
      LogHelper.showInfo("[" + Nicknames.getNick(sender.getName()) + " #####tagNotify#####[" + Utils.replaceChatColors(tagTo), target, ChatColor.AQUA);
    } else {
      LogHelper.showInfo("tagSelf#####[" + Utils.replaceChatColors(tagTo), sender, ChatColor.AQUA);
    }
   
View Full Code Here

        if (Permissions.checkPerms(sender, "cex.economy.balance")){
          if (args.length > 2){
            sender.sendMessage(getEconomyHelp(sender));
          } else if (args.length == 2){
            if (Permissions.checkPerms(sender, "cex.economy.balance.others")){
              Player target = Bukkit.getPlayer(args[1]);
              if (target != null){
                LogHelper.showInfo("[" + target.getName() + " #####economyBalanceOther#####[" + getCurrencySymbol() + fixDecimals(getBalance(target.getName())), sender);
              } else {
                LogHelper.showWarning("invalidPlayer", sender);
              }
            }
          } else {
            LogHelper.showInfo("economyBalance#####[" + getCurrencySymbol() + fixDecimals(getBalance(sName)), sender);
          }
        }
      } else {
        LogHelper.showWarning("inWorldCommandOnly", sender);
      }
    } else if (function.equalsIgnoreCase("pay")){
      if (Permissions.checkPerms(sender, "cex.economy.pay")){
        if (args.length != 3){
          sender.sendMessage(getEconomyHelp(sender));
        } else {
          Player target = Bukkit.getPlayer(args[1]);
          if (target != null){
            try {
              double amount = Double.parseDouble(args[2]);
             
              // this avoids players giving a negative number
              // which allows them to basically spawn money
              if (amount < 0){
                LogHelper.showWarning("economyNegative", sender);
                return true;
              }
             
              if (has(sName, amount)){
                withdraw(sName, amount);
                deposit(target.getName(), amount);
               
                LogHelper.showInfo("economySent#####[" + getCurrencySymbol() + fixDecimals(amount) + " #####to#####[" + target.getName(), sender);
                LogHelper.showInfo("[" + sName + " #####economyPayNotify1#####[" + getCurrencySymbol() + fixDecimals(amount) + " #####economyPayNotify2", target);
              } else {
                LogHelper.showWarning("economyNotEnough", sender);
              }
            } catch (NumberFormatException e){
              LogHelper.showWarning("economyIncorrectAmount", sender);
            }
          } else {
            LogHelper.showWarning("invalidPlayer", sender);
          }
        }
      }
    } else if (function.equalsIgnoreCase("take")){
      if (Permissions.checkPerms(sender, "cex.economy.take")){
        if (args.length != 3){
          sender.sendMessage(getEconomyHelp(sender));
        } else {
          Player target = Bukkit.getPlayer(args[1]);
          if (target != null){
            try {
              double amount = Double.parseDouble(args[2]);
             
              // this avoids players giving a negative number
              // which allows them to basically spawn money
              if (amount < 0){
                LogHelper.showWarning("economyNegative", sender);
                return true;
              }
             
              if (has(target.getName(), amount)){
                withdraw(target.getName(), amount);
                deposit(sName, amount);
               
                LogHelper.showInfo("economyTake#####[" + getCurrencySymbol() + fixDecimals(amount) + " #####from#####[" + target.getName(), sender);
                LogHelper.showInfo("[" + sName + " #####economyTakeNotify1#####[" + getCurrencySymbol() + fixDecimals(amount) + " #####economyTakeNotify2", target);
              } else {
                LogHelper.showWarning("economyTakeNotEnough", sender);
              }
            } catch (NumberFormatException e){
              LogHelper.showWarning("economyIncorrectAmount", sender);
            }
          } else {
            LogHelper.showWarning("invalidPlayer", sender);
          }
        }
      }
    } else if (function.equalsIgnoreCase("set")){
      if (args.length != 3){
        sender.sendMessage(getEconomyHelp(sender));
      } else {
        Player target = Bukkit.getPlayer(args[1]);
        if (target != null){
          try {
            double amount = Double.parseDouble(args[2]);
           
            // this avoids players giving a negative number
            // which allows them to basically spawn money
            if (amount < 0){
              LogHelper.showWarning("economyNegative", sender);
              return true;
            }
           
            setBalance(target.getName(), amount);
            LogHelper.showInfo("economySet#####[" + target.getName() + " #####to#####[" + fixDecimals(amount), sender);
          } catch (NumberFormatException e){
            LogHelper.showWarning("economyIncorrectAmount", sender);
          }
        } else {
          LogHelper.showWarning("invalidPlayer", sender);
        }
      }
    } else if (function.equalsIgnoreCase("request")){
      if (args.length == 3 || args.length == 2){
        if (PlayerHelper.checkIsPlayer(sender)){
          if (args[1].equalsIgnoreCase("accept") && Permissions.checkPerms(sender, "cex.economy.request.accept")){
            if (args.length == 3){
              Pair<String, String> pair = new Pair<String, String>(sName, args[2]);
             
              if (requests.containsKey(pair)){
                Player player = Bukkit.getPlayerExact(pair.first);
                if (player != null){
                  double amount = requests.get(pair).first;
                  LogHelper.showInfo("economySent#####[" + getCurrencySymbol() + fixDecimals(amount) + " #####to#####[" + pair.first, sender);
                  LogHelper.showInfo("[" + sName + " #####economyRequestAccepted#####[" + getCurrencySymbol() + fixDecimals(amount), sender);
                 
                  withdraw(sName, amount);
                  deposit(pair.first, amount);
                 
                  // cancel task to expire request
                  requests.get(pair).second.cancel();
                  requests.remove(pair);
                } else {
                  LogHelper.showWarning("[" + pair.first + " #####economyRequestAcceptOffline", sender);
                }
              } else {
                LogHelper.showWarning("economyRequestInvalid", sender);
              }
            } else {
              sender.sendMessage(getEconomyHelp(sender));
            }
          } else if (args[1].equalsIgnoreCase("deny") && Permissions.checkPerms(sender, "cex.economy.request.deny")){
            if (args.length == 3){
              Pair<String, String> pair = new Pair<String, String>(sName, args[2]);
             
              if (requests.containsKey(pair)){
                Player player = Bukkit.getPlayerExact(pair.first);
               
                if (player != null){
                  double amount = requests.get(pair).first;
                  LogHelper.showInfo("economyRequestDeny#####[" + pair.first + " #####for#####[ " + getCurrencySymbol() + fixDecimals(amount), sender);
                  LogHelper.showInfo("[" + sName + " #####economyRequestDenied#####[" + getCurrencySymbol() + fixDecimals(amount), player);
                  requests.get(pair).second.cancel();
                  requests.remove(pair);
                } else {
                  LogHelper.showWarning("[" + pair.first + " #####economyRequestDenyOffline", sender);
                }
              } else {
                LogHelper.showWarning("economyRequestInvalid", sender);
              }
            } else {
              sender.sendMessage(getEconomyHelp(sender));
            }
          } else if (Permissions.checkPerms(sender, "cex.economy.request")){
            if (args.length == 2){
              Player target = Bukkit.getPlayerExact(args[2]);

              if (target != null){
                try {
                  final double amount = Double.parseDouble(args[2]);

                  // this avoids players giving a negative number
                  // which allows them to basically spawn money
                  if (amount < 0){
                    LogHelper.showWarning("economyNegative", sender);
                    return true;
                  }
                 
                  if (has(target.getName(), amount)){
                    final Pair<String, String> pair = new Pair<String, String>(target.getName(), sName);
                    if (requests.containsKey(pair)){
                      requests.remove(pair);
                    }
                   
                    BukkitTask task = Bukkit.getScheduler().runTaskLaterAsynchronously(CommandsEX.plugin, new Runnable(){
                      @Override
                      public void run() {
                        requests.remove(pair);
                        Player player = Bukkit.getPlayerExact(pair.second);
                        if (player != null){
                          LogHelper.showWarning("economyRequestExpired1#####[" + getCurrencySymbol() + fixDecimals(amount) + " #####from#####[ " + pair.first + "#####economyRequestExpired2", player);
                        }
                       
                        Player target = Bukkit.getPlayerExact(pair.first);
                        if (target != null){
                          LogHelper.showInfo("economyRequestExpiredNotify1#####[" + pair.second + " #####for#####[ " + getCurrencySymbol() + fixDecimals(amount) + " #####economyRequestExpiredNotify1", target);
                        }
                      }
                    }, CommandsEX.getConf().getInt("economy.requestExpireTime") * 20);
                   
                    requests.put(pair, new Pair<Double, BukkitTask>(amount, task));
                   
                    LogHelper.showInfo("economyRequest#####[" + getCurrencySymbol() + fixDecimals(amount) + " #####to#####[ " + target, sender);
                   
                    LogHelper.showInfo("[" + sName + "economyRequestNotify1#####[" + fixDecimals(amount) + " #####economyRequestNotify2", target);
                    LogHelper.showInfo("economyRequestNotify3#####[" + sName, target);
                    LogHelper.showInfo("economyRequestNotify4#####[" + sName, target);
                  } else {
                    LogHelper.showWarning("economyTakeNotEnough", sender);
                  }
                } catch (NumberFormatException e){
                  LogHelper.showWarning("economyIncorrectAmount", sender);
                }
              } else {
                LogHelper.showWarning("invalidPlayer", sender);
              }
            } else {
              sender.sendMessage(getEconomyHelp(sender));
            }
          }
        }
      } else {
        sender.sendMessage(getEconomyHelp(sender));
      }
    } else if (function.equalsIgnoreCase("spawn")){
      if (Permissions.checkPerms(sender, "cex.economy.spawn")){
        if (args.length != 2 || args.length != 3){
          sender.sendMessage(getEconomyHelp(sender));
        } else {
          Player target = null;
         
          if (args.length == 2){
            if (sender instanceof Player){
              target = (Player) sender;
            } else {
              sender.sendMessage(getEconomyHelp(sender));
              return true;
            }
          } else {
            target = Bukkit.getPlayer(args[1]);
          }
         
          if (target == null){
            LogHelper.showWarning("invalidPlayer", sender);
          }
         
          boolean self = false;
         
          if (target.equals(sender)){
            self = true;
          }

          try {
            double amount = Double.parseDouble((self ? args[1] : args[2]));
           
            // this avoids players giving a negative number
            if (amount < 0){
              LogHelper.showWarning("economyNegative", sender);
              return true;
            }
           
            deposit(target.getName(), amount);
            LogHelper.showInfo("economySpawn#####[" + fixDecimals(amount) + " #####" + (self ? "economySpawnAccount" : "for#####[ " + target.getName()), sender);
          } catch (NumberFormatException e){
            LogHelper.showWarning("economyIncorrectAmount", sender);
          }
        }
      }
View Full Code Here

    saveNicks();
  }
 
  @EventHandler
  public void onPlayerJoin(PlayerJoinEvent e){
    Player player = e.getPlayer();
    showNick(player);
  }
View Full Code Here

    }
   
    nicknames.put(pName, nickname);
   
    // if the player is online, set their nickname
    Player player = Bukkit.getPlayerExact(pName);
    if (player != null){
      showNick(player);
    }
   
    return true;
View Full Code Here

 
  public static Boolean run(CommandSender sender, String alias, String[] args) {
    if (!Utils.checkCommandSpam((Player) sender, "smite") && ((!(sender instanceof Player)) || ((sender instanceof Player) && Permissions.checkPerms((Player) sender, "cex.smite")))) {
      if(args.length > 0) {
        // get variables about the player
        Player smited = Bukkit.getServer().getPlayer(args[0]);
        if (smited == null) {
          LogHelper.showWarning("invalidPlayer", sender);
          return true;
        }
       
        Location loc = smited.getLocation();
        // smite the player
        smited.getWorld().strikeLightningEffect(loc);
        // set last damage cause for custom death messages
        smited.setLastDamageCause(new EntityDamageEvent(smited, DamageCause.LIGHTNING, 20));
        smited.setHealth(0);
     
        // show the sender a message
        LogHelper.showInfo("smitePlayer#####[" + Nicknames.getNick(smited.getName()), sender);
       
        // config variable
        Boolean showMessageOnSmite = CommandsEX.getConf().getBoolean("showMessageOnSmite");
       
        // show who smited the smitee (is that a word)
View Full Code Here

   * @param args
   * @return
   */
  public static Boolean run(CommandSender sender, String alias, String[] args) {
    if (PlayerHelper.checkIsPlayer(sender)) {
      Player player = (Player)sender;

      if (!Utils.checkCommandSpam(player, "tp-tpahere")) {
        if (args.length > 0) {
          if (Permissions.checkPerms(player, "cex.tpahere")) {
            // check if the requested player is online
            Player tpaPlayer = Bukkit.getServer().getPlayer(args[0]);
 
            // if player is offline...
            if (tpaPlayer == null) {
              LogHelper.showWarning("invalidPlayer", sender);
              return true;
            }
           
            // disallow TPAHERE to ourselves
            if (player.getName().equals(tpaPlayer.getName())) {
              LogHelper.showWarning("tpCannotTeleportSelf", sender);
              return true;
            }
           
            // if another TPA or TPAHERE request is pending...
            String id = player.getName() + "#####" + tpaPlayer.getName();
            if (Teleportation.tpahereRequests.contains(id) || Teleportation.tpaRequests.contains(id) || Teleportation.tpaallRequests.contains(id)) {
              LogHelper.showWarning("tpRequestPending", sender);
              return true;
            }
           
            // load TPAHERE timeout from config if not present
            if (tTimeout == 0) {
              Integer t = CommandsEX.getConf().getInt("tpahereTimeout");
              if (t > 0) {
                tTimeout = t;
              } else {
                // fallback to default if we didn't find a valid config value
                tTimeout = 50;
              }
            }
           
            // add names of TPAHERE players and send message
            Teleportation.tpahereRequests.add(id);
            tpaPlayer.sendMessage(ChatColor.GREEN + Nicknames.getNick(player.getName()) + " " + _("tpRequest1a", sender.getName()));
            tpaPlayer.sendMessage(ChatColor.GREEN + _("tpRequest2", sender.getName()));
            tpaPlayer.sendMessage(ChatColor.GREEN + _("tpRequest3", sender.getName()));
           
            // set timeout function that will cancel TPAHERE request if timeout is reached
            CommandsEX.plugin.getServer().getScheduler().scheduleSyncDelayedTask(CommandsEX.plugin, new TpRequestCanceller("tpahere", id), (20 * tTimeout));
           
            // send confimation message to the original player
View Full Code Here

TOP

Related Classes of org.bukkit.entity.Player

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.