@EventHandler
 public void onPlayerDeath(PlayerDeathEvent event) {
   if (event.getEntity().getKiller() == null) {
     return;
   } else {
     Player p = event.getEntity();
     plugin.punished.put(p, p.getKiller());
     p.sendMessage(
         ChatColor.GRAY
             + "You have been slain by "
             + ChatColor.RED
             + p.getKiller().getName()
             + ChatColor.GRAY
             + "!");
     if (lastIndict.containsKey(p)) {
       if (System.currentTimeMillis() < (lastIndict.get(p) + plugin.timeBetweenIndicts)) {
         p.sendMessage(
             ChatColor.GRAY + "Not enough time has passed for their karma to be affected again!");
         return;
       }
     }
     p.sendMessage(
         ChatColor.GRAY
             + "Please use "
             + ChatColor.RED
             + "'/indict'"
             + ChatColor.GRAY
             + " to punish the crime or "
             + ChatColor.GREEN
             + "'/forgive' "
             + ChatColor.GRAY
             + "to absolve them!");
     lastIndict.put(p, System.currentTimeMillis());
   }
 }
Ejemplo n.º 2
0
  @EventHandler
  public void onPlayerDeath(PlayerDeathEvent e) {
    Player p = e.getEntity();
    Player k = p.getKiller();

    if (k instanceof Player && p instanceof Player) {
      if (FileUtils.hasBounty(p.getName())) {
        p.sendMessage(
            config
                .getString("bountyVictim")
                .replace("%prefix", config.getString("Prefix"))
                .replace("%target", k.getName())
                .replace("&", "¤"));
        k.sendMessage(
            config
                .getString("bountyMurderer")
                .replace("%prefix", config.getString("Prefix"))
                .replace("%target", p.getName())
                .replace("&", "¤"));

        Bountys.economy.depositPlayer(k, FileUtils.getBounty(p.getName()));

        FileUtils.removeBounty(p.getName());
      }
    }
  }
Ejemplo n.º 3
0
  /**
   * Monitor PlayerDeath events.
   *
   * @param event The event to watch
   */
  @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
  public void onPlayerDeath(PlayerDeathEvent event) {
    Player player = event.getEntity();

    if (Misc.isNPCPlayer(player)) {
      return;
    }

    if (!Permissions.hardcoremodeBypass(player)) {
      Player killer = player.getKiller();

      if (killer != null && Hardcore.vampirismEnabled) {
        Hardcore.invokeVampirism(killer, player);
      }

      Hardcore.invokeStatPenalty(player);
    }
  }
Ejemplo n.º 4
0
 @EventHandler(priority = EventPriority.HIGH)
 public void playerKillPlayer(PlayerDeathEvent event) {
   if (!(event.getEntity().getKiller() instanceof Player)) {
     return;
   }
   Player killed = event.getEntity();
   Player killer = killed.getKiller();
   if (vanishNoPacket.isPlayerInvisible(killer)) {
     return;
   }
   Set<Snitch> snitches = snitchManager.findSnitches(killed.getWorld(), killed.getLocation());
   for (Snitch snitch : snitches) {
     if (!isOnSnitch(snitch, killer.getName()) || isDebugging()) {
       if (checkProximity(snitch, killed.getName()) || checkProximity(snitch, killer.getName())) {
         plugin.getJaLogger().logSnitchPlayerKill(snitch, killer, killed);
       }
     }
   }
 }
Ejemplo n.º 5
0
 @EventHandler
 public void onKill(PlayerDeathEvent evt) {
   Player dead = evt.getEntity();
   Player killer = dead.getKiller();
   if (killer == null) return;
   Kit k = Main.playerkits.get(killer.getName());
   if (!(k instanceof Kit_Barbarian)) return;
   ItemStack item = killer.getItemInHand();
   if (item == null) return;
   ItemMeta meta = item.getItemMeta();
   if (meta == null) return;
   String name = meta.getDisplayName();
   if (name == null) return;
   if (!(name.substring(0, swordname.indexOf(':') + 2))
           .equals(swordname.substring(0, swordname.indexOf(':') + 2))
       && meta.getLore().equals(swordlore)) return;
   addkill(item);
   killer.setItemInHand(item);
 }
Ejemplo n.º 6
0
  @EventHandler(priority = EventPriority.HIGHEST)
  public void onEntityDeath(EntityDeathEvent event) {
    // Handles deaths inside arenas
    Entity died = event.getEntity();
    if (died == null) return;

    // Clear the drops if in an arena
    if (plugin.isInArena(died.getLocation())) {
      event.getDrops().clear();
      event.setDroppedExp(0);
    }

    if (died instanceof Player) {
      Player pdied = (Player) died;
      ArenaPlayer dp = plugin.getArenaPlayer(pdied);
      if (dp != null) {
        // Prevent duplicate deaths
        if (dp.isDead()) return;
        dp.onDeath();

        Arena ar = dp.getArena();

        if (pdied.getKiller() instanceof Player) {
          Player killer = pdied.getKiller();
          if (killer.getName().equals(pdied.getName())) // Suicide
          {
            ar.tellPlayers("&e{0} &3commited &esuicide&3!", pdied.getName());
            dp.displayStats();
          } else {
            // PvP
            ar.tellPlayers(
                "&e{0} &3killed &e{1} &3with {2}",
                killer.getName(), pdied.getName(), getWeapon(killer));
            dp.displayStats();

            // Handle killer
            ArenaPlayer kp = plugin.getArenaPlayer(killer);
            if (kp != null) {
              kp.setKills(kp.getKills() + 1);
              kp.setKillStreak(kp.getKillStreak() + 1);
              kp.getArena().handleKillStreak(kp);
              kp.addXP(100);

              kp.displayStats();
            }
          }
        } else {
          // From this point on, we will return when there is a valid match
          if (pdied.getKiller() instanceof LivingEntity) {
            LivingEntity lentity = pdied.getKiller();
            String name = FormatUtil.getFriendlyName(lentity.getType());

            ar.tellPlayers(
                "&e{0} &3was killed by &3{1} &e{2}",
                pdied.getName(), FormatUtil.getArticle(name), name);
            dp.displayStats();
            return;
          } else if (pdied.getKiller() instanceof Projectile) {
            Projectile proj = (Projectile) pdied.getKiller();
            if (proj.getShooter() instanceof Player) {
              Player killer = (Player) proj.getShooter();
              ar.tellPlayers(
                  "&e{0} &3killed &e{1} &3with &e{2}",
                  killer.getName(), pdied.getName(), getWeapon(killer));
              dp.displayStats();

              // Handle killer
              ArenaPlayer kp = plugin.getArenaPlayer(killer);
              kp.setKills(kp.getKills() + 1);
              kp.setKillStreak(kp.getKillStreak() + 1);
              kp.getArena().handleKillStreak(kp);
              kp.addXP(100);

              kp.displayStats();
              return;
            } else if (proj.getShooter() instanceof LivingEntity) {
              LivingEntity lentity = pdied.getKiller();
              String name = FormatUtil.getFriendlyName(lentity.getType());

              ar.tellPlayers(
                  "&e{0} &3was killed by {1} &e{2}",
                  pdied.getName(), FormatUtil.getArticle(name), name);
              dp.displayStats();
              return;
            }
          }

          // Attempt to grab from their last damage cause
          EntityDamageEvent damageEvent = pdied.getLastDamageCause();
          DamageCause cause = damageEvent != null ? damageEvent.getCause() : null;

          if (cause == DamageCause.ENTITY_ATTACK) {
            if (damageEvent instanceof EntityDamageByEntityEvent) {
              EntityDamageByEntityEvent damageByEntity = (EntityDamageByEntityEvent) damageEvent;
              Entity damager = damageByEntity.getDamager();
              if (damager != null) {
                if (damager instanceof Player) {
                  Player killer = (Player) damager;
                  ar.tellPlayers(
                      "&e{0} &3killed &e{1} &3with {2}",
                      killer.getName(), pdied.getName(), getWeapon(killer));
                  dp.displayStats();

                  // Handle killer
                  ArenaPlayer kp = plugin.getArenaPlayer(killer);
                  if (kp != null) {
                    kp.setKills(kp.getKills() + 1);
                    kp.setKillStreak(kp.getKillStreak() + 1);
                    kp.getArena().handleKillStreak(kp);
                    kp.addXP(100);

                    kp.displayStats();
                  }
                } else {
                  String name = FormatUtil.getFriendlyName(damager.getType());
                  ar.tellPlayers(
                      "&e{0} &3was killed by &3{1} &e{2}",
                      pdied.getName(), FormatUtil.getArticle(name), name);
                  dp.displayStats();
                }

                return;
              }
            }
          } else if (cause == DamageCause.PROJECTILE) {
            if (damageEvent instanceof EntityDamageByEntityEvent) {
              EntityDamageByEntityEvent damageByEntity = (EntityDamageByEntityEvent) damageEvent;
              Entity damager = damageByEntity.getDamager();
              if (damager != null) {
                if (damager instanceof Projectile) {
                  Projectile proj = (Projectile) damager;
                  if (proj.getShooter() != null) {
                    if (proj.getShooter() instanceof Player) {
                      Player killer = (Player) proj.getShooter();

                      ar.tellPlayers(
                          "&e{0} &3killed &e{1} &3with {2}",
                          killer.getName(), pdied.getName(), getWeapon(killer));

                      dp.displayStats();

                      // Handle killer
                      ArenaPlayer kp = plugin.getArenaPlayer(killer);
                      if (kp != null) {
                        kp.setKills(kp.getKills() + 1);
                        kp.setKillStreak(kp.getKillStreak() + 1);
                        kp.getArena().handleKillStreak(kp);
                        kp.addXP(100);

                        kp.displayStats();
                      }
                    } else {
                      String name = "";
                      if (proj.getShooter() instanceof LivingEntity)
                        name =
                            FormatUtil.getFriendlyName(
                                ((LivingEntity) proj.getShooter()).getType());

                      ar.tellPlayers(
                          "&e{0} &3was shot by &3{1} &e{2}",
                          pdied.getName(), FormatUtil.getArticle(name), name);
                      dp.displayStats();
                    }

                    return;
                  }
                }
              }
            }
          } else if (cause != null) {
            // There's probably nothing else we can do here, so just turn it into a string
            ar.tellPlayers(
                "&e{0} &3was killed by &e{1}", pdied.getName(), FormatUtil.getFriendlyName(cause));
            dp.displayStats();
          } else if (ar instanceof SpleefArena) {
            // If they were in spleef, they probably fell through the floor
            ar.tellPlayers("&e{0} &3fell through the floor!", pdied.getName());
            dp.displayStats();
          } else {
            // No idea
            ar.tellPlayers("&e{0} &3died of unknown causes", pdied.getName());
            dp.displayStats();
          }
        }
      }
    } else {
      if (died instanceof LivingEntity) {
        LivingEntity lentity = (LivingEntity) died;
        if (lentity.getKiller() instanceof Player) {
          Player killer = lentity.getKiller();
          if (plugin.isInArena(killer)) {
            ArenaPlayer ak = plugin.getArenaPlayer(killer);

            // Selectively count mob kills
            if (ak.getArena().isCountMobKills()) {
              ak.addXP(25);
              ak.setKills(ak.getKills() + 1);
              ak.setKillStreak(ak.getKillStreak() + 1);
              ak.getArena().handleKillStreak(ak);

              String name = FormatUtil.getFriendlyName(lentity.getType());
              ak.sendMessage(
                  "&e{0} &3killed {1} &e{2}", killer.getName(), FormatUtil.getArticle(name), name);
              ak.displayStats();
            }
          }
        }
      }
    }
  }
Ejemplo n.º 7
0
  @EventHandler(priority = EventPriority.HIGHEST)
  public void onPlayerDie(PlayerDeathEvent pde) {
    final Player player = pde.getEntity();
    Game game = Main.getInstance().getGameManager().getGameOfPlayer(player);

    if (game == null) {
      return;
    }

    if (game.getState() == GameState.RUNNING) {
      pde.setDroppedExp(0);
      pde.setDeathMessage(null);

      if (!Main.getInstance().getBooleanConfig("player-drops", false)) {
        pde.getDrops().clear();
      }

      try {
        if (!Main.getInstance().isSpigot()) {
          Class<?> clazz = null;
          try {
            clazz =
                Class.forName(
                    "io.github.yannici.bedwars.Com."
                        + Main.getInstance().getCurrentVersion()
                        + ".PerformRespawnRunnable");
          } catch (ClassNotFoundException ex) {
            clazz = Class.forName("io.github.yannici.bedwars.Com.Fallback.PerformRespawnRunnable");
          }

          BukkitRunnable respawnRunnable =
              (BukkitRunnable) clazz.getDeclaredConstructor(Player.class).newInstance(player);
          respawnRunnable.runTaskLater(Main.getInstance(), 20L);
        } else {
          new BukkitRunnable() {

            @Override
            public void run() {
              player.spigot().respawn();
            }
          }.runTaskLater(Main.getInstance(), 20L);
        }

      } catch (Exception e) {
        e.printStackTrace();
      }

      try {
        pde.getClass().getMethod("setKeepInventory", new Class<?>[] {boolean.class});
        pde.setKeepInventory(false);
      } catch (Exception ex) {
        player.getInventory().clear();
      }

      Player killer = player.getKiller();
      if (killer == null) {
        killer = game.getPlayerDamager(player);
      }

      game.getCycle().onPlayerDies(player, killer);
    }
  }
Ejemplo n.º 8
0
 @EventHandler(ignoreCancelled = true)
 public void onEntityDeath(EntityDeathEvent e) {
   if (e.getEntity() instanceof Player) {
     Player dead = (Player) e.getEntity();
     if (checkSpectator(dead)) {
       e.setDroppedExp(0);
       e.getDrops().clear();
       return;
     }
     if (checkIngame(dead)) {
       Player killer = null;
       if (dead.getKiller() instanceof Player) {
         killer = dead.getKiller();
       } else {
         if (dead.getLastDamageCause() instanceof EntityDamageByEntityEvent) {
           EntityDamageByEntityEvent ev = (EntityDamageByEntityEvent) dead.getLastDamageCause();
           if (ev.getDamager() instanceof Projectile) {
             Projectile proj = (Projectile) ev.getDamager();
             if (proj.getShooter() instanceof Player) {
               killer = (Player) proj.getShooter();
             }
           }
         }
       }
       if (killer != null) {
         if (checkIngame(killer)) {
           pl.ingameList.get(killer).addKill(pl.ingameList.get(dead));
         } else {
           killer.kickPlayer("killed player playing dota");
         }
         pl.ingameList.get(dead).addDeath();
       } else {
         pl.ingameList.get(dead).addNeutralDeath();
       }
     }
   } else {
     e.getEntity().getEquipment().setArmorContents(null);
     e.getDrops().clear();
     if (pl.useControllableMobs) {
       LivingEntity en = e.getEntity();
       if (pl.laneCreeps.containsKey(en)) {
         pl.laneCreeps.remove(en);
         if (e.getEntity().getKiller() != null) {
           pl.ingameList.get(e.getEntity().getKiller()).addLH();
         }
       } else if (pl.jungleSpecialCreeps.containsKey(en)) {
         if (e.getEntity().getKiller() != null) {
           Player killer = e.getEntity().getKiller();
           pl.ingameList.get(killer).addJungleLH();
           int n = pl.jungleSpecialCreeps.get(en);
           if (n == 1) { // red
             killer.addPotionEffect(
                 new PotionEffect(PotionEffectType.INCREASE_DAMAGE, 20 * 90, 0), true);
           } else if (n == 2) { // blue
             killer.addPotionEffect(
                 new PotionEffect(PotionEffectType.ABSORPTION, 20 * 90, 1), true);
           }
         }
         e.setDroppedExp(pl.getRandom(12, 14));
         pl.jungleSpecialCreeps.remove(en);
       } else if (pl.jungleCreeps.containsKey(en)) {
         pl.jungleCreeps.remove(en);
         if (e.getEntity().getKiller() != null) {
           pl.ingameList.get(e.getEntity().getKiller()).addJungleLH();
         }
         e.setDroppedExp(pl.getRandom(7, 9));
       }
       ControllableMobs.releaseControl(pl.controlMobs.get(en));
     } else {
       LivingEntity en = e.getEntity();
       if (pl.spawnedMobs.contains(en)) {
         if (pl.laneEntityCreeps.contains(en)) {
           pl.laneEntityCreeps.remove(en);
           if (e.getEntity().getKiller() != null) {
             pl.ingameList.get(en.getKiller()).addLH();
           }
         } else if (pl.jungleEntitySpecialCreeps.containsKey(en)) {
           if (e.getEntity().getKiller() != null) {
             Player killer = e.getEntity().getKiller();
             pl.ingameList.get(killer).addJungleLH();
             int n = pl.jungleEntitySpecialCreeps.get(en);
             if (n == 1) { // red
               killer.addPotionEffect(
                   new PotionEffect(PotionEffectType.INCREASE_DAMAGE, 20 * 90, 0), true);
             } else if (n == 2) { // blue
               killer.addPotionEffect(
                   new PotionEffect(PotionEffectType.ABSORPTION, 20 * 90, 1), true);
             }
           }
           e.setDroppedExp(pl.getRandom(7, 9));
           pl.jungleEntitySpecialCreeps.remove(en);
         } else if (pl.jungleEntityCreeps.contains(en)) {
           if (e.getEntity().getKiller() != null) {
             Player killer = e.getEntity().getKiller();
             pl.ingameList.get(killer).addJungleLH();
           }
           e.setDroppedExp(pl.getRandom(7, 9));
           pl.jungleEntityCreeps.remove(en);
         }
         pl.spawnedMobs.remove(en);
       }
     }
   }
 }
Ejemplo n.º 9
0
 @Override
 public Player getKiller() {
   return caller.getKiller();
 }
Ejemplo n.º 10
0
  /*
   *
   * ################################################
   *
   * 			   HANDLE PLAYER DEATH
   *
   *  PLAYERS DIE A REAL DEATH WHICH IS HANDLED HERE
   *
   * ################################################
   *
   *
   */
  public void playerDeath(PlayerDeathEvent e) {
    final Player p = e.getEntity();
    if (!activePlayers.contains(p)) return;

    sm.playerDied(p, activePlayers.size(), gameID, new Date().getTime() - startTime);
    scoreBoard.playerDead(p);
    activePlayers.remove(p);
    inactivePlayers.add(p);
    for (Object in : spawns.keySet().toArray()) {
      if (spawns.get(in) == p) spawns.remove(in);
    }

    PlayerKilledEvent pk = null;
    if (mode != GameMode.WAITING
        && p.getLastDamageCause() != null
        && p.getLastDamageCause().getCause() != null) {
      DamageCause cause = p.getLastDamageCause().getCause();
      switch (cause) {
        case ENTITY_ATTACK:
          if (p.getLastDamageCause().getEntityType() == EntityType.PLAYER) {
            EntityType enttype = p.getLastDamageCause().getEntityType();
            Player killer = p.getKiller();
            String killername = "Unknown";

            if (killer != null) {
              killername = killer.getName();
            }

            String itemname = "Unknown Item";
            if (killer != null) {
              itemname = ItemReader.getFriendlyItemName(killer.getItemInHand().getType());
            }

            msgFall(
                PrefixType.INFO,
                "death." + enttype,
                "player-" + p.getName(),
                "killer-" + killername,
                "item-" + itemname);

            if (killer != null && p != null) {
              sm.addKill(killer, p, gameID);
              scoreBoard.incScore(killer);
            }
            pk = new PlayerKilledEvent(p, this, killer, cause);
          } else {
            msgFall(
                PrefixType.INFO,
                "death." + p.getLastDamageCause().getEntityType(),
                "player-" + p.getName(),
                "killer-" + p.getLastDamageCause().getEntityType());
            pk = new PlayerKilledEvent(p, this, null, cause);
          }
          break;
        default:
          msgFall(
              PrefixType.INFO, "death." + cause.name(), "player-" + p.getName(), "killer-" + cause);
          pk = new PlayerKilledEvent(p, this, null, cause);

          break;
      }
      Bukkit.getServer().getPluginManager().callEvent(pk);

      if (getActivePlayers() > 1) {
        for (Player pl : getAllPlayers()) {
          msgmgr.sendMessage(
              PrefixType.INFO,
              ChatColor.DARK_AQUA
                  + "There are "
                  + ChatColor.YELLOW
                  + ""
                  + getActivePlayers()
                  + ChatColor.DARK_AQUA
                  + " players remaining!",
              pl);
        }
      }
    }

    for (Player pe : activePlayers) {
      Location l = pe.getLocation();
      l.setY(l.getWorld().getMaxHeight());
      l.getWorld().strikeLightningEffect(l);
    }

    if (getActivePlayers() <= config.getInt("endgame.players")
        && config.getBoolean("endgame.fire-lighting.enabled")
        && !endgameRunning) {

      tasks.add(
          Bukkit.getScheduler()
              .scheduleSyncRepeatingTask(
                  GameManager.getInstance().getPlugin(),
                  new EndgameManager(),
                  0,
                  config.getInt("endgame.fire-lighting.interval") * 20));
    }

    if (activePlayers.size() < 2 && mode == GameMode.INGAME) {
      mode = GameMode.FINISHING;
      LobbyManager.getInstance().updateWall(gameID);
      tasks.add(
          Bukkit.getScheduler()
              .scheduleSyncDelayedTask(
                  GameManager.getInstance().getPlugin(),
                  new Runnable() {
                    public void run() {
                      playerWin(p);
                      endGame();
                    }
                  },
                  10L));
    }
    LobbyManager.getInstance().updateWall(gameID);
  }
Ejemplo n.º 11
0
  @EventHandler(ignoreCancelled = true)
  public void onPlayerDeath(PlayerDeathEvent event) {
    Player player = event.getEntity();
    event.getDeathMessage();
    DamageCause deathCause = player.getLastDamageCause().getCause();

    if (player.getKiller() != null && getSettingsManager().isPvpDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("deaths.pvp", player);
      event.setDeathMessage(null);
    } else if (event.getDeathMessage().toLowerCase().contains("wolf")
        && getSettingsManager().isMonsterDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("monsters.wolf", player);
      event.setDeathMessage(null);
    } else if (event.getDeathMessage().toLowerCase().contains("ocelot")
        && getSettingsManager().isMonsterDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("monsters.ocelot", player);
      event.setDeathMessage(null);
    } else if (event.getDeathMessage().toLowerCase().contains("pigman")
        && getSettingsManager().isMonsterDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("monsters.pigzombie", player);
      event.setDeathMessage(null);
    } else if (event.getDeathMessage().toLowerCase().contains("zombie")
        && getSettingsManager().isMonsterDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("monsters.zombie", player);
      event.setDeathMessage(null);
    } else if (event.getDeathMessage().toLowerCase().contains("skeleton")
        && getSettingsManager().isMonsterDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("monsters.skeleton", player);
      event.setDeathMessage(null);
    } else if (event.getDeathMessage().toLowerCase().contains("cave spider")
        && getSettingsManager().isMonsterDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("monsters.cavespider", player);
      event.setDeathMessage(null);
    } else if (event.getDeathMessage().toLowerCase().contains("spider")
        && getSettingsManager().isMonsterDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("monsters.spider", player);
      event.setDeathMessage(null);
    } else if (event.getDeathMessage().toLowerCase().contains("silverfish")
        && getSettingsManager().isMonsterDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("monsters.silverfish", player);
      event.setDeathMessage(null);
    } else if (event.getDeathMessage().toLowerCase().contains("slime")
        && getSettingsManager().isMonsterDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("monsters.slime", player);
      event.setDeathMessage(null);
    } else if (event.getDeathMessage().toLowerCase().contains("blew up")
        && getSettingsManager().isMonsterDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("monsters.creeper", player);
      event.setDeathMessage(null);
    } else if (event.getDeathMessage().toLowerCase().contains("enderman")
        && getSettingsManager().isMonsterDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("monsters.enderman", player);
      event.setDeathMessage(null);
    } else if (event.getDeathMessage().toLowerCase().contains("ghast")
        && getSettingsManager().isMonsterDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("monsters.ghast", player);
      event.setDeathMessage(null);
    } else if (event.getDeathMessage().toLowerCase().contains("blaze")
        && getSettingsManager().isMonsterDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("monsters.blaze", player);
      event.setDeathMessage(null);
    } else if (event.getDeathMessage().toLowerCase().contains("ender dragon")
        && getSettingsManager().isMonsterDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("monsters.enderdragon", player);
      event.setDeathMessage(null);
    } else if (event.getDeathMessage().toLowerCase().contains("wither skeleton")
        && getSettingsManager().isMonsterDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("monsters.witch", player);
      event.setDeathMessage(null);
    } else if (event.getDeathMessage().toLowerCase().contains("wither")
        && getSettingsManager().isMonsterDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("monsters.wither", player);
      event.setDeathMessage(null);
    } else if (event.getDeathMessage().toLowerCase().contains("anvil")
        && getSettingsManager().isMonsterDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("deaths.anvil", player);
      event.setDeathMessage(null);
    } else if (deathCause == DamageCause.DROWNING
        && getSettingsManager().isNaturalDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("deaths.drowning", player);
      event.setDeathMessage(null);
    } else if (deathCause == DamageCause.SUFFOCATION
        && getSettingsManager().isNaturalDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("deaths.suffocation", player);
      event.setDeathMessage(null);
    } else if (deathCause == DamageCause.SUICIDE
        && getSettingsManager().isNaturalDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("deaths.suicide", player);
      event.setDeathMessage(null);
    } else if (deathCause == DamageCause.FALL
        && getSettingsManager().isNaturalDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("deaths.fall", player);
      event.setDeathMessage(null);
    } else if (deathCause == DamageCause.VOID
        && getSettingsManager().isNaturalDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("deaths.void", player);
      event.setDeathMessage(null);
    } else if (deathCause == DamageCause.LAVA
        && getSettingsManager().isNaturalDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("deaths.lava", player);
      event.setDeathMessage(null);
    } else if (deathCause == DamageCause.FIRE
        && getSettingsManager().isNaturalDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("deaths.fire", player);
      event.setDeathMessage(null);
    } else if (deathCause == DamageCause.CONTACT
        && getSettingsManager().isNaturalDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("deaths.cactus", player);
      event.setDeathMessage(null);
    } else if (deathCause == DamageCause.WITHER
        && getSettingsManager().isNaturalDeathTranslationEnabled()) {
      Localisation.sendGlobalMessage("deaths.wither", player);
      event.setDeathMessage(null);
    }
  }
Ejemplo n.º 12
0
  public void collect(Player player, List<ItemStack> itemDrops, EntityDeathEvent event) {
    if (itemDrops.isEmpty() && !levelAllow(player) && !expAllow(player)) {
      return;
    }

    if (plugin.config.dropOnPVPDeath() && player.getKiller() instanceof Player) {
      plugin.message(player, plugin.config.msgPVPDeath());
      return;
    }

    if (plugin.config.residence()) {
      ClaimedResidence res = Residence.getResidenceManager().getByLoc(player.getLocation());
      if (res != null) {
        ResidencePermissions perms = res.getPermissions();
        if (perms.playerHas(player.getName(), plugin.config.resFlag(), true)) {
          plugin.logDebug(
              "Player '"
                  + player.getName()
                  + "' is not allowed to use Scavenger in this residence. Items will be dropped.");
          plugin.message(player, plugin.config.msgInsideRes());
          return;
        } else {
          plugin.logDebug(
              "Player '" + player.getName() + "' is allowed to use Scavenger in this residence.");
        }
      }
    }

    if (plugin.config.factionEnemyDrops() && plugin.factionHook != null) {
      if (plugin.factionHook.isPlayerInEnemyFaction(player)) {
        return;
      }
    }

    if (plugin.config.dungeonMazeDrops() && plugin.dmHook != null) {
      plugin.logDebug("Checking if '" + player.getName() + "' is in DungeonMaze.");
      if (plugin.dmHook.isPlayerInDungeon(player)) {
        plugin.logDebug("Player '" + player.getName() + "' is in DungeonMaze.");
        plugin.message(player, plugin.config.msgInsideDungeonMaze());
        return;
      }
    }

    if (plugin.getWorldGuard() != null) {
      plugin.logDebug("Checking region support for '" + player.getWorld().getName() + "'");
      if (plugin.getWorldGuard().getRegionManager(player.getWorld()) != null) {
        try {
          RegionManager regionManager = plugin.getWorldGuard().getRegionManager(player.getWorld());
          ApplicableRegionSet set = regionManager.getApplicableRegions(player.getLocation());
          if (set.allows(DefaultFlag.PVP) && plugin.config.wgPVPIgnore()) {
            plugin.logDebug(
                "This is a WorldGuard PVP zone and WorldGuardPVPIgnore is "
                    + plugin.config.wgPVPIgnore());
            if (!plugin.config.msgInsideWGPVP().isEmpty()) {
              plugin.message(player, plugin.config.msgInsideWGPVP());
            }
            return;
          }
          if (!set.allows(DefaultFlag.PVP) && plugin.config.wgGuardPVPOnly()) {
            plugin.logDebug(
                "This is NOT a WorldGuard PVP zone and WorldGuardPVPOnly is "
                    + plugin.config.wgGuardPVPOnly());
            if (!plugin.config.msgInsideWGPVP().isEmpty()) {
              plugin.message(player, plugin.config.msgInsideWGPVPOnly());
            }
            return;
          }
        } catch (NullPointerException ex) {
          plugin.logDebug(ex.getMessage());
        }
      } else {
        plugin.logDebug("Region support disabled for '" + player.getWorld().getName() + "'");
      }
    }

    if (plugin.getUltimateArena() != null) {
      if (UltimateArenaAPI.hookIntoUA(plugin).isInArena(player)) {
        if (!plugin.config.msgInsideUA().isEmpty()) {
          plugin.message(player, plugin.config.msgInsideUA());
        }
        return;
      }
    }

    if (plugin.maHandler != null && plugin.maHandler.isPlayerInArena(player)) {
      if (!plugin.config.msgInsideMA().isEmpty()) {
        plugin.message(player, plugin.config.msgInsideMA());
      }
      return;
    }

    if (plugin.pvpHandler != null && !PVPArenaAPI.getArenaName(player).equals("")) {
      String x = plugin.config.msgInsidePA();
      if (!x.isEmpty()) {
        x = x.replace("%ARENA%", PVPArenaAPI.getArenaName(player));
        plugin.message(player, x);
      }
      return;
    }

    if (plugin.battleArena) {
      mc.alk.arena.objects.ArenaPlayer ap = mc.alk.arena.BattleArena.toArenaPlayer(player);
      if (ap != null) {
        Match match = BattleArena.getBAController().getMatch(ap);
        if (match != null) {
          if (match.isInMatch(ap)) {
            String x = plugin.config.msgInsideBA();
            if (!x.isEmpty()) {
              plugin.message(player, x);
            }
            return;
          }
        }
      }
    }

    if (plugin.minigames != null) {
      if (plugin.minigames.playerInMinigame(player)) {
        plugin.logDebug(
            "Player '" + player.getName() + "' is in a Minigame. Not recovering items.");
        return;
      }
    }

    if (hasRestoration(player)) {
      plugin.error(player, "Restoration already exists, ignoring.");
      return;
    }

    if (plugin.getEconomy() != null
        && !(player.hasPermission(PERM_FREE) || (player.isOp() && plugin.config.opsAllPerms()))
        && plugin.config.economyEnabled()) {
      NumberFormat formatter = NumberFormat.getInstance(new Locale(plugin.config.countryCode()));
      formatter.setMaximumFractionDigits(plugin.config.decimalPlaces());
      double restoreCost = plugin.config.restoreCost();
      double withdrawAmount;
      double playerBalance = plugin.getEconomy().getBalance(player);
      double percentCost = plugin.config.percentCost();
      double minCost = plugin.config.minCost();
      double maxCost = plugin.config.maxCost();
      EconomyResponse er;
      String currency;
      if (plugin.config.percent()) {
        if (playerBalance < 0) {
          withdrawAmount = 0;
        } else {
          withdrawAmount = playerBalance * (percentCost / 100.0);
        }
        plugin.logDebug("withdrawAmount: " + withdrawAmount);
        plugin.logDebug("playeBalance: " + playerBalance);
        plugin.logDebug("percentCost: " + percentCost + "(" + (percentCost / 100.0) + ")");
        if (plugin.config.addMin()) {
          withdrawAmount = withdrawAmount + minCost;
          plugin.logDebug("withdrawAmount (addMin): " + withdrawAmount);
        } else if (withdrawAmount < minCost) {
          withdrawAmount = minCost;
        }
        if (withdrawAmount > maxCost && maxCost > 0) {
          withdrawAmount = maxCost;
        }
      } else {
        withdrawAmount = restoreCost;
      }
      er = plugin.getEconomy().withdrawPlayer(player, withdrawAmount);
      if (er.transactionSuccess()) {
        plugin.logDebug("Withdraw success!");
        if (withdrawAmount == 1) {
          currency = plugin.getEconomy().currencyNameSingular();
        } else {
          currency = plugin.getEconomy().currencyNamePlural();
        }
        String x = plugin.config.msgSaveForFee();
        if (!x.isEmpty()) {
          x = x.replace("%COST%", formatter.format(withdrawAmount));
          x = x.replace("%CURRENCY%", currency);
          plugin.message(player, x);
        }
        if (!plugin.config.depositDestination().isEmpty()) {
          plugin.logDebug("DepositDesination: " + plugin.config.depositDestination());
          if (plugin.config.depositType().equalsIgnoreCase("bank")) {
            plugin.logDebug("DepositType: BANK");
            if (plugin.getEconomy().hasBankSupport()) {
              plugin.logDebug("Bank support is enabled");
              plugin.getEconomy().bankDeposit(plugin.config.depositDestination(), withdrawAmount);
            } else {
              plugin.logDebug("Bank support is NOT enabled");
            }
          } else if (plugin.config.depositType().equalsIgnoreCase("player")) {
            plugin.logDebug("DepositType: PLAYER");
            plugin.logDebug("DepositDestination: " + plugin.config.depositDestination());
            if (plugin.getEconomy().hasAccount(plugin.config.depositDestination())) {
              plugin.logDebug("DepositDestination: VALID");
              plugin.getEconomy().depositPlayer(plugin.config.depositDestination(), withdrawAmount);
            } else {
              plugin.logDebug("DepositDestination: INVALID");
            }
          } else {
            plugin.logDebug("DepositType: INVALID");
          }
        } else {
          plugin.logDebug("No deposit destination!");
        }
      } else {
        plugin.logDebug("Withdraw fail! " + er.errorMessage);
        if (playerBalance == 1) {
          currency = plugin.getEconomy().currencyNameSingular();
        } else {
          currency = plugin.getEconomy().currencyNamePlural();
        }
        String x = plugin.config.msgNotEnoughMoney();
        if (!x.isEmpty()) {
          x = x.replace("%BALANCE%", formatter.format(playerBalance));
          x = x.replace("%COST%", formatter.format(withdrawAmount));
          x = x.replace("%CURRENCY%", currency);
          x = x.replace("%ERRORMESSAGE%", er.errorMessage);
          plugin.message(player, x);
        }
        return;
      }
    } else {
      plugin.message(player, plugin.config.msgSaving());
    }

    Restoration restoration = new Restoration();
    restoration.enabled = false;

    // temporary fix for 1.9
    restoration.inventory = Arrays.copyOfRange(player.getInventory().getContents(), 0, 36);
    restoration.armour = player.getInventory().getArmorContents();
    if (plugin.isMc19or110()) {
      restoration.offHand = player.getInventory().getItemInOffHand();
    }
    restoration.playerName = player.getDisplayName();
    itemDrops.clear();

    if (levelAllow(player)) {
      plugin.logDebug("Collecting level " + player.getLevel() + " for " + player.getName());
      restoration.level = player.getLevel();
    }
    if (expAllow(player)) {
      plugin.logDebug("Collecting exp " + player.getExp() + " for " + player.getName());
      restoration.exp = player.getExp();
      event.setDroppedExp(0);
    }

    String deathCause = "NULL";
    if (player.getLastDamageCause() != null) {
      if (player.getLastDamageCause().getCause() != null) {
        deathCause = player.getLastDamageCause().getCause().toString();
      }
    }
    String deathCausePermission = PERM_SCAVENGE_PREFIX + deathCause;
    plugin.logDebug(
        "[p:"
            + player.getName()
            + "] ["
            + PERM_SCAVENGE
            + ":"
            + player.hasPermission(PERM_SCAVENGE)
            + "]"
            + " ["
            + deathCausePermission
            + ":"
            + player.hasPermission(deathCausePermission)
            + "]");
    if (player.hasPermission(PERM_SCAVENGE) || player.hasPermission(deathCausePermission)) {
      plugin.logDebug("Permissions are okay. Time to scavenge...");
      if (plugin.config.chanceToDrop() > 0 && !player.hasPermission(PERM_NO_CHANCE)) {
        checkChanceToDropItems(restoration.armour, itemDrops);
        checkChanceToDropItems(restoration.inventory, itemDrops);
        if (plugin.isMc19or110()) {
          checkChanceToDropItems(restoration.offHand, itemDrops);
        }
      }
      if (plugin.config.singleItemDrops()) {
        checkSingleItemDrops(player, restoration.armour, itemDrops);
        checkSingleItemDrops(player, restoration.inventory, itemDrops);
        checkSingleItemDrops(player, restoration.offHand, itemDrops);
      } else if (plugin.config.singleItemKeeps()) {
        checkSingleItemKeeps(player, "armour", restoration.armour, itemDrops);
        checkSingleItemKeeps(player, "inv", restoration.inventory, itemDrops);
        if (plugin.isMc19or110()) {
          checkSingleItemKeeps(player, "offhand", restoration.offHand, itemDrops, 1);
        }
      } else if (plugin.config.slotBasedRecovery()) {
        checkSlots(player, "armour", restoration.armour, itemDrops);
        checkSlots(player, "inv", restoration.inventory, itemDrops);
        if (plugin.isMc19or110()) {
          checkSlots(player, "offhand", restoration.offHand, itemDrops, 1);
        }
      }
    } else {
      plugin.logDebug("Permissions are NOT okay. Dropping items...");
      dropItems(restoration.armour, itemDrops);
      dropItems(restoration.inventory, itemDrops);
      dropItem(restoration.offHand, itemDrops);
    }
    addRestoration(player, restoration);
  }