private void handlePlayerDeath(Player subject) {
EntityDamageEvent cause = subject.getLastDamageCause();
// Increment the PlayerData total death stat
PlayerData playerData =
this.plugin.getPlayerData(subject.getName(), "MineJMX found a new Player");
playerData.incDeaths();
// Increment the ServerData statistics
plugin.serverData.incPlayersKilled();
if (cause instanceof EntityDamageByEntityEvent) {
Entity predicate = ((EntityDamageByEntityEvent) cause).getDamager();
if (predicate instanceof Player) {
// The player was killed by another player, dick move bro
PlayerData killerData = this.plugin.getPlayerData(((Player) predicate).getName(), "");
killerData.incPlayersKilled();
// Increment the victim's PvP death stat
playerData.incDeathsByPlayer();
} else {
// The player was killed by a mob, increment the NpeData statistics
NpeData killerData = this.plugin.getNpeDataByClass(predicate.getClass());
killerData.incPlayersKilled();
// Increment the victim's death by NPE stat
playerData.incDeathsByNpe();
}
} else if (cause instanceof EntityDamageByBlockEvent) {
// as it turns out this is only valid for cacti/lava...it might be
// completely obsolete in favor of the following switch statement,
// but I'm going to leave it in for the time being just in case
playerData.incDeathsByEnvironment();
} else {
// drowned, burned, fell, etc...increment the environmental death counter
switch (cause.getCause()) {
case CONTACT:
case DROWNING:
case FALL:
case FIRE:
case FIRE_TICK:
case LAVA:
case LIGHTNING:
playerData.incDeathsByEnvironment();
break;
}
}
}
@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();
}
}
}
}
}
}
@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);
}
}
}
}
@Override
public EntityDamageEvent getLastDamageCause() {
return caller.getLastDamageCause();
}
/*
*
* ################################################
*
* 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);
}
@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);
}
}
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);
}
