@EventHandler
public void onGolemDeath(EntityDeathEvent event) {
    if (!(event.getEntity() instanceof IronGolem)) {
        return;
    }

    IronGolem ironGolem = (IronGolem) event.getEntity();
    for (String name : Main.getGameNames()) {
        Game game = Main.getGame(name);
        if ((game.getStatus() == GameStatus.RUNNING || game.getStatus() == GameStatus.GAME_END_CELEBRATING) && ironGolem.getWorld().equals(game.getGameWorld())) {
            List<SpecialItem> golems = game.getActivedSpecialItems(Golem.class);
            for (SpecialItem item : golems) {
                if (item instanceof Golem) {
                    Golem golem = (Golem) item;
                    if (golem.getEntity().equals(ironGolem)) {
                        event.getDrops().clear();
                    }
                }
            }
        }
    }
}
 

/**
 * Drops the Enderman's block when he dies if he has one
 *
 * @param e - event
 */
@EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
public void onEndermanDeath(final EntityDeathEvent e) {
    if (DEBUG) {
        plugin.getLogger().info(e.getEventName());
    }
    if (!Settings.endermanDeathDrop)
        return;
    if (!inWorld(e.getEntity())) {
        return;
    }
    if (!(e.getEntity() instanceof Enderman)) {
        // plugin.getLogger().info("Not an Enderman!");
        return;
    }
    // Get the block the enderman is holding
    Enderman ender = (Enderman) e.getEntity();
    MaterialData m = ender.getCarriedMaterial();
    if (m != null && !m.getItemType().equals(Material.AIR)) {
        // Drop the item
        // plugin.getLogger().info("Dropping item " + m.toString());
        e.getEntity().getWorld().dropItemNaturally(e.getEntity().getLocation(), m.toItemStack(1));
    }
}
 

@EventHandler
public void onGolemDeath(EntityDeathEvent event) {
    if (!(event.getEntity() instanceof IronGolem)) {
        return;
    }

    IronGolem ironGolem = (IronGolem) event.getEntity();
    for (String name : Main.getGameNames()) {
        Game game = Main.getGame(name);
        if ((game.getStatus() == GameStatus.RUNNING || game.getStatus() == GameStatus.GAME_END_CELEBRATING) && ironGolem.getWorld().equals(game.getGameWorld())) {
            List<SpecialItem> golems = game.getActivedSpecialItems(Golem.class);
            for (SpecialItem item : golems) {
                if (item instanceof Golem) {
                    Golem golem = (Golem) item;
                    if (golem.getEntity().equals(ironGolem)) {
                        event.getDrops().clear();
                    }
                }
            }
        }
    }
}
 

@EventHandler
public void onEntityDeath(EntityDeathEvent ev) {
	if (ev.getEntity() instanceof Ghast) {
		Bukkit.getLogger().info("Modifying drops for Ghast");
		List<ItemStack> drops = new ArrayList<ItemStack>(ev.getDrops());
		ev.getDrops().clear();
		for (ItemStack i : drops) {
			if (i.getType() == Material.GHAST_TEAR) {
				Bukkit.getLogger().info("Added "+i.getAmount()+" ghast tear(s)");
				ev.getDrops().add(new ItemStack(Material.GOLD_INGOT,i.getAmount()));
			} else {
				Bukkit.getLogger().info("Added "+i.getAmount()+" "+i.getType().toString());
				ev.getDrops().add(i);
			}
		}
	}
}
 

/**
 * Tracks the mob kills.
 *
 * @param event the death event
 */
@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGH)
public void onMobDeath(EntityDeathEvent event) {
    LivingEntity entity = event.getEntity();
    //killer is null if it's not a player
    Player killer = entity.getKiller();

    //Check if it's not player because we are already handling it
    if (entity.getType() != EntityType.PLAYER && Settings.isActiveWorld(entity.getWorld().getName())) {
        database.getStats(killer).ifPresent(stats -> {
            //If the cache entry is loaded and the player isn't null, increase the mob kills
            stats.onMobKill();

            ReplaceManager.getInstance().forceUpdate(killer, "mob", stats.getMobkills());
        });
    }
}
 

@EventHandler(ignoreCancelled = true)
public void onKill(EntityDeathEvent e) {
    if (e.getDrops().isEmpty() || e.getEntity().getKiller() == null) {
        return;
    }

    LivingEntity entity = e.getEntity();

    if (!(entity instanceof Player) && !(entity instanceof ArmorStand) && Talisman.checkFor(e, SlimefunItems.TALISMAN_HUNTER)) {
        Collection<ItemStack> extraDrops = getExtraDrops(e.getEntity(), e.getDrops());

        for (ItemStack drop : extraDrops) {
            if (drop != null) {
                e.getDrops().add(drop.clone());
            }
        }
    }
}
 

private void handleGoldDrop(EntityDeathEvent event){
	if(enableGoldDrops && affectedMobs.contains(event.getEntityType())){
		Random r = new Random();
		if(r.nextInt(100) < chance){
			int drop;
			try{
				drop = min+r.nextInt(1+max-min);
			}catch(IllegalArgumentException e){
				drop=0;
			}
			if(drop > 0){
				ItemStack gold = new ItemStack(Material.GOLD_INGOT,drop);
				event.getDrops().add(gold);
			}
		}			
	}
}
 

private static Player getPlayerByEventType(Event e) {
    if (e instanceof EntityDeathEvent) {
        return ((EntityDeathEvent) e).getEntity().getKiller();
    }
    else if (e instanceof BlockBreakEvent) {
        return ((BlockBreakEvent) e).getPlayer();
    }
    else if (e instanceof PlayerEvent) {
        return ((PlayerEvent) e).getPlayer();
    }
    else if (e instanceof EntityEvent) {
        return (Player) ((EntityEvent) e).getEntity();
    }
    else if (e instanceof EnchantItemEvent) {
        return ((EnchantItemEvent) e).getEnchanter();
    }

    return null;
}
 

@EventHandler(priority = EventPriority.HIGHEST)
public void onDeath(EntityDeathEvent e) {
    LivingEntity dead = e.getEntity();
    if(!(dead instanceof Mob)){
        return;
    }
    if(!(StackTools.hasValidStackData(dead))){
        if(StackTools.hasValidData(dead)){
            sm.getLogic().cleanup(dead);
        }
        return;
    }
    int stackAmount = StackTools.getSize(dead);
    
    DeathStep method = sm.getDeathManager().calculateMethod(dead);
    int subtractAmount = sm.getDeathManager().calculateStep(dead, method);
    callEvent(dead, e, subtractAmount);
    multiplication(dead, e.getDrops(), subtractAmount - 1, e.getDroppedExp());
    if(subtractAmount != stackAmount){
        Entity entity = spawnNewEntity(stackAmount - subtractAmount, dead);
        if(method instanceof KillStepDamage){
            ((KillStepDamage)method).onceSpawned(dead, (LivingEntity) entity);
        }
    }
    sm.getLogic().cleanup(dead);
}
 

@SuppressWarnings("deprecation")
@EventHandler(priority = EventPriority.MONITOR)
public void onDeath(EntityDeathEvent event) {
    long time = System.currentTimeMillis();
    LivingEntity dead = event.getEntity();

    if (dead instanceof Player) {
        // Process Death
        SessionCache.getCachedSession(dead.getUniqueId()).ifPresent(Session::died);
    }

    try {
        EntityDamageEvent entityDamageEvent = dead.getLastDamageCause();
        if (!(entityDamageEvent instanceof EntityDamageByEntityEvent)) {
            return;
        }

        EntityDamageByEntityEvent entityDamageByEntityEvent = (EntityDamageByEntityEvent) entityDamageEvent;
        Entity killerEntity = entityDamageByEntityEvent.getDamager();

        UUID uuid = dead instanceof Player ? dead.getUniqueId() : null;
        handleKill(time, uuid, killerEntity);
    } catch (Exception e) {
        errorLogger.log(L.ERROR, e, ErrorContext.builder().related(event, dead).build());
    }
}
 

@Override
public boolean init(final Expression<?>[] vars, final int matchedPattern, final Kleenean isDelayed, final ParseResult parser) {
	if (!ScriptLoader.isCurrentEvent(EntityDamageEvent.class, EntityDeathEvent.class, VehicleDamageEvent.class, VehicleDestroyEvent.class)) {
		Skript.error("The expression 'victim' can only be used in a damage or death event", ErrorQuality.SEMANTIC_ERROR);
		return false;
	}
	final String type = parser.regexes.size() == 0 ? null : parser.regexes.get(0).group();
	if (type == null) {
		this.type = EntityData.fromClass(Entity.class);
	} else {
		final EntityData<?> t = EntityData.parse(type);
		if (t == null) {
			Skript.error("'" + type + "' is not an entity type", ErrorQuality.NOT_AN_EXPRESSION);
			return false;
		}
		this.type = t;
	}
	return true;
}
 

@Nullable
	private static Entity getAttacker(final @Nullable Event e) {
		if (e == null)
			return null;
		if (e instanceof EntityDamageByEntityEvent) {
			if (((EntityDamageByEntityEvent) e).getDamager() instanceof Projectile) {
				final Object o = ProjectileUtils.getShooter((Projectile) ((EntityDamageByEntityEvent) e).getDamager());
				if (o instanceof Entity)
					return (Entity) o;
				return null;
			}
			return ((EntityDamageByEntityEvent) e).getDamager();
//		} else if (e instanceof EntityDamageByBlockEvent) {
//			return ((EntityDamageByBlockEvent) e).getDamager();
		} else if (e instanceof EntityDeathEvent) {
			return getAttacker(((EntityDeathEvent) e).getEntity().getLastDamageCause());
		} else if (e instanceof VehicleDamageEvent) {
			return ((VehicleDamageEvent) e).getAttacker();
		} else if (e instanceof VehicleDestroyEvent) {
			return ((VehicleDestroyEvent) e).getAttacker();
		}
		return null;
	}
 

@Override
public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
	cancelItems = parseResult.mark == 0 || parseResult.mark == 1;
	cancelExps = parseResult.mark == 0 || parseResult.mark == 2;
	if (ScriptLoader.isCurrentEvent(BlockBreakEvent.class)) {
		if (cancelItems && !CAN_CANCEL_BLOCK_ITEM_DROPS) {
			Skript.error("Cancelling drops of items in a block break event requires Minecraft 1.12 or newer");
			return false;
		}
	} else if (!ScriptLoader.isCurrentEvent(EntityDeathEvent.class)) {
		Skript.error("The cancel drops effect can't be used outside of a death" +
			(CAN_CANCEL_BLOCK_ITEM_DROPS ? " or block break" : "") + " event");
		return false;
	}
	if (isDelayed.isTrue()) {
		Skript.error("Can't cancel the drops anymore after the event has already passed");
		return false;
	}
	return true;
}
 

/**
 * Called when any entity dies.
 */
public void whenSomethingDies(EntityDeathEvent event) {
    UUID id = event.getEntity().getUniqueId();
    if (needsDropsClear.contains(id)) {
        needsDropsClear.remove(id);
        if (event.getEntity().getType() != EntityType.PLAYER) {
            if (SentinelPlugin.debugMe) {
                debug("A " + event.getEntity().getType() + " with id " + id + " died. Clearing its drops.");
            }
            event.getDrops().clear();
            event.setDroppedExp(0);
        }
    }
    else {
        if (SentinelPlugin.debugMe) {
            debug("A " + event.getEntity().getType() + " with id " + id + " died, but that's none of my business.");
        }
    }
    targetingHelper.removeTarget(id);
}
 

@EventHandler
public void onDeath(EntityDeathEvent event) {

    EliteMobEntity eliteMobEntity = EntityTracker.getEliteMobEntity(event.getEntity());
    if (eliteMobEntity == null) return;

    if (!eliteMobEntity.hasPower(this)) return;

    if (!event.getEntity().getLocation().getBlock().getType().equals(Material.AIR)) return;

    blocks.add(event.getEntity().getLocation().getBlock());
    event.getEntity().getLocation().getBlock().setType(Material.BONE_BLOCK);

    new BukkitRunnable() {
        @Override
        public void run() {
            blocks.remove(event.getEntity().getLocation().getBlock());
            if (event.getEntity().getLocation().getBlock().getType().equals(Material.BONE_BLOCK))
                event.getEntity().getLocation().getBlock().setType(Material.AIR);
        }
    }.runTaskLater(MetadataHandler.PLUGIN, 20 * 60 * 2);

}
 

@EventHandler
public void onEntityDeath(EntityDeathEvent event) {
    World world = event.getEntity().getWorld();

    if (event.getEntity() instanceof LivingEntity) {
        LivingEntity entity = event.getEntity();
        GameWorld gameWorld = plugin.getGameWorld(world);
        if (gameWorld != null) {
            if (gameWorld.isPlaying()) {
                DMob dMob = (DMob) plugin.getDungeonMob(entity);
                if (dMob != null) {
                    dMob.onDeath(plugin, event);
                }
            }
        }
    }
}
 

@EventHandler
public void onEntityDeath(EntityDeathEvent event) {
	final LivingEntity livingEntity = event.getEntity();
	final int entityId = livingEntity.getEntityId();
	
	if(livingEntity instanceof Player) return; // we have a seperate method for players
	
	if(DisguiseManager.isDisguised(livingEntity)) {
		Bukkit.getScheduler().runTaskLater(plugin, new Runnable() {
			
			public void run() {
				DisguiseManager.undisguise(livingEntity);
			}
			
		}, 100L);
	}
	
	Bukkit.getScheduler().runTaskLater(plugin, new Runnable() {
		
		public void run() {
			EntityIdList.removeEntity(entityId);
		}
		
	}, 200L);
}
 

@EventHandler(ignoreCancelled = true)
public void onEntityDeath(EntityDeathEvent event) {
    int i = 0;
    while (event.getEntity().hasMetadata("betonquest-drops-" + i)) {
        try {
            List<MetadataValue> metadata = event.getEntity().getMetadata("betonquest-drops-" + i);
            for (MetadataValue m : metadata) {
                String item = m.asString();
                int index = item.indexOf(':');
                event.getDrops().add(new QuestItem(new ItemID(null, item.substring(0, index)))
                        .generate(Integer.valueOf(item.substring(index + 1))));
            }
        } catch (Exception e) {
            LogUtils.getLogger().log(Level.WARNING, "Error when dropping custom item from entity: " + e.getMessage());
            LogUtils.logThrowable(e);
        }
        i++;
    }
}
 

@EventHandler
public void onEntityDeath(EntityDeathEvent event) {
    try {
        final LivingEntity entity = event.getEntity();
        final Player killer = entity.getKiller();
        if (killer == null) return;

        final Location location = killer.getLocation();
        final IslandManager islandManager = IridiumSkyblock.getIslandManager();
        if (!islandManager.isIslandWorld(location)) return;

        final User user = User.getUser(killer);
        final Island userIsland = user.getIsland();
        if (userIsland == null) return;

        for (Mission mission : IridiumSkyblock.getMissions().missions) {
            final Map<String, Integer> levels = userIsland.getMissionLevels();
            levels.putIfAbsent(mission.name, 1);

            final MissionData level = mission.levels.get(levels.get(mission.name));
            if (level.type != MissionType.ENTITY_KILL) continue;

            final List<String> conditions = level.conditions;
            if (conditions.isEmpty() || conditions.contains(entity.toString()))
                userIsland.addMission(mission.name, 1);
        }

        if (userIsland.getExpBooster() != 0)
            event.setDroppedExp(event.getDroppedExp() * 2);
    } catch (Exception e) {
        IridiumSkyblock.getInstance().sendErrorMessage(e);
    }
}
 

public void unregister() {
    InventoryClickEvent.getHandlerList().unregister(this);
    InventoryDragEvent.getHandlerList().unregister(this);
    InventoryCloseEvent.getHandlerList().unregister(this);
    InventoryMoveItemEvent.getHandlerList().unregister(this);
    BlockDispenseEvent.getHandlerList().unregister(this);
    BlockBreakEvent.getHandlerList().unregister(this);
    EntityDeathEvent.getHandlerList().unregister(this);
}
 

@EventHandler
public void onEntityDeath(EntityDeathEvent event) {
	
	if (event.getEntityType() == EntityType.ZOMBIE) {

		// Remove normal drops and exp.
		event.getDrops().clear();
		event.setDroppedExp(0);
		
		// Spawn the floating item with a label.
		final Hologram hologram = HologramsAPI.createHologram(this, event.getEntity().getLocation().add(0.0, 0.9, 0.0));
		hologram.appendTextLine(ChatColor.AQUA  + "" + ChatColor.BOLD + "Speed PowerUp");
		ItemLine icon = hologram.appendItemLine(new ItemStack(Material.SUGAR));
		
		icon.setPickupHandler(new PickupHandler() {
			
			@Override
			public void onPickup(Player player) {
				
				// Play an effect.
				player.playEffect(hologram.getLocation(), Effect.MOBSPAWNER_FLAMES, null);
				
				// 30 seconds of speed II.
				player.addPotionEffect(new PotionEffect(PotionEffectType.SPEED, 30 * 20, 1), true);
				
				// Delete the hologram.
				hologram.delete();
				
			}
		});
		
	}
}
 

/**
 * Killing mobs gives enhancement stone.
 *
 * @param e
 */
@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGH)
public void onKilling(EntityDeathEvent e) {
    // If the killed entity is a monster
    if (e.getEntity() instanceof Monster) {
        if (e.getEntity().getKiller() instanceof Player) {
            Player player = e.getEntity().getKiller();
            if (DropManager.killingChance > random.nextDouble()) {
                DropManager.randomDrop(player, DropManager.killingLootTable);
            }
        }
    }
}
 

@EventHandler
public void onEntityDeath(EntityDeathEvent e){
    if (e.getEntityType() != EntityType.ENDER_DRAGON){
        return;
    }

    if (e.getEntity().getKiller() == null) {
        return;
    }

    Player killer = e.getEntity().getKiller();
    UhcPlayer uhcKiller = getPlayersManager().getUhcPlayer(killer);

    List<UhcPlayer> spectators = new ArrayList<>();

    for (UhcPlayer playingPlayer : getPlayersManager().getAllPlayingPlayers()){

        if (!playingPlayer.isInTeamWith(uhcKiller)){
            spectators.add(playingPlayer);
        }
    }

    for (UhcPlayer spectator : spectators){
        spectator.setState(PlayerState.DEAD);

        try {
            Player all = spectator.getPlayer();
            all.setGameMode(GameMode.SPECTATOR);
            all.teleport(killer);
        }catch (UhcPlayerNotOnlineException exeption){
            // Nothing
        }
    }

    getPlayersManager().checkIfRemainingPlayers();
}
 

@EventHandler(priority = EventPriority.HIGHEST)
public void onDeath(EntityDeathEvent e) {
    if (e.getEntity().hasMetadata(METADATA_KEY)) {
        AndroidInstance obj = (AndroidInstance) e.getEntity().getMetadata(METADATA_KEY).get(0).value();

        Slimefun.runSync(() -> {
            List<ItemStack> items = new ArrayList<>();

            // Collect any nearby dropped items
            for (Entity n : e.getEntity().getNearbyEntities(0.5D, 0.5D, 0.5D)) {
                if (n instanceof Item && n.isValid() && !SlimefunUtils.hasNoPickupFlag((Item) n)) {
                    items.add(((Item) n).getItemStack());
                    n.remove();
                }
            }

            addExtraDrops(items, e.getEntityType());

            obj.getAndroid().addItems(obj.getBlock(), items.toArray(new ItemStack[0]));
            ExperienceOrb exp = (ExperienceOrb) e.getEntity().getWorld().spawnEntity(e.getEntity().getLocation(), EntityType.EXPERIENCE_ORB);
            exp.setExperience(1 + ThreadLocalRandom.current().nextInt(6));
        }, 1L);

        // Removing metadata to prevent memory leaks
        e.getEntity().removeMetadata(METADATA_KEY, SlimefunPlugin.instance);
    }
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onEntityKilled(EntityDeathEvent e) {
    if (e.getEntity().getType() != EntityType.SHEEP || !plugin.getConfig().getBoolean("options.sheep.dropMutton", true) || !e.getEntity().getWorld().isGameRule("doMobLoot") || !(e.getEntity() instanceof Ageable)) {
        return;
    }
    Ageable entity = (Ageable) e.getEntity();
    if (!entity.isAdult()) {
        return;
    }
    boolean fireaspect = false;
    int looting = 1;
    if (entity.getLastDamageCause() instanceof EntityDamageByEntityEvent) {
        EntityDamageByEntityEvent dEvent = (EntityDamageByEntityEvent) entity.getLastDamageCause();
        if (dEvent.getDamager() != null && dEvent.getDamager() instanceof Player) {
            ItemStack hand = ((Player) dEvent.getDamager()).getItemInHand();
            fireaspect = hand.containsEnchantment(Enchantment.FIRE_ASPECT);
            if (hand.containsEnchantment(Enchantment.LOOT_BONUS_MOBS))
                looting += hand.getEnchantmentLevel(Enchantment.LOOT_BONUS_MOBS);
            if (looting < 1) //Incase a plugin sets an enchantment level to be negative
                looting = 1;
        } else if (dEvent.getDamager() != null && dEvent.getDamager() instanceof Arrow) {
            Arrow a = (Arrow) dEvent.getDamager();
            if (a.getFireTicks() > 0)
                fireaspect = true;
        }
    }
    if (entity.getLastDamageCause().getCause() == DamageCause.FIRE_TICK || entity.getLastDamageCause().getCause() == DamageCause.FIRE
            || entity.getLastDamageCause().getCause() == DamageCause.LAVA || fireaspect)
        e.getDrops().add(new ItemStack(Carbon.injector().cookedMuttonItemMat, random.nextInt(2) + 1 + random.nextInt(looting)));
    else
        e.getDrops().add(new ItemStack(Carbon.injector().muttonItemMat, random.nextInt(2) + 1 + random.nextInt(looting)));
}
 

@EventHandler(priority = EventPriority.HIGHEST)
public void onEntityDeath(EntityDeathEvent event) {
	handleMobLoot(event);
	handleGoldDrop(event);
	handleGhastTearDrop(event);
	handleOfflineZombieDeath(event);
}
 

private void handleMobLoot(EntityDeathEvent event){
	EntityType entity = event.getEntityType();
	if(mobLoots.containsKey(entity)){
		MobLootConfiguration lootConfig = mobLoots.get(entity);
		event.getDrops().clear();
		event.getDrops().add(lootConfig.getLoot().clone());
		event.setDroppedExp(lootConfig.getAddXp());
		UhcItems.spawnExtraXp(event.getEntity().getLocation(),lootConfig.getAddXp());
	}
}
 

private void handleGhastTearDrop(EntityDeathEvent event){
	if(event.getEntityType().equals(EntityType.GHAST) && !allowGhastTearDrop){
		for(int i = event.getDrops().size()-1 ; i>=0 ; i--){
			if(event.getDrops().get(i).getType().equals(Material.GHAST_TEAR)){
				event.getDrops().remove(i);
			}
		}
	}
}
 

@Override
public void setEventExp(EntityDeathEvent event, double xp, Object o, MarriagePlayer player, Marriage marriage)
{
	BonusXPDropEvent bonusXPDropEvent = new BonusXPDropEvent(player, marriage, (int) Math.round(xp));
	Bukkit.getServer().getPluginManager().callEvent(bonusXPDropEvent);
	if(!bonusXPDropEvent.isCancelled())
	{
		event.setDroppedExp(bonusXPDropEvent.getAmount());
	}
}
 

@EventHandler
public void onVillagerDeath(EntityDeathEvent event) {
    if (!(event.getEntity() instanceof Villager)) {
        return;
    }
    Location location = event.getEntity().getLocation();
    Town town = TownManager.getInstance().getTownAt(location);
    if (town == null) {
        return;
    }
    TownManager.getInstance().setTownPower(town,
            town.getPower() - ConfigManager.getInstance().getPowerPerNPCKill());
}