public BlacklistCategory() {
    for (Flag flag : FlagRegistryModule.getInstance().getAll()) {
        this.flagIdBlacklist.put(flag.getName().toLowerCase(), new ArrayList<>());
    }
    this.flagIdBlacklist.put("block-pre", new ArrayList<>());
    this.entityDamageSourceBlacklist.add(DamageCause.CONTACT.name().toLowerCase());
    this.entityDamageSourceBlacklist.add("cramming");
    this.entityDamageSourceBlacklist.add(DamageCause.DROWNING.name().toLowerCase());
    this.entityDamageSourceBlacklist.add(DamageCause.FALLING_BLOCK.name().toLowerCase());
    this.entityDamageSourceBlacklist.add("flyintowall");
    this.entityDamageSourceBlacklist.add(DamageCause.POISON.name().toLowerCase());
    this.entityDamageSourceBlacklist.add(DamageCause.STARVATION.name().toLowerCase());
    this.entityDamageSourceBlacklist.add(DamageCause.SUFFOCATION.name().toLowerCase());
    this.entityDamageSourceBlacklist.add(DamageCause.SUICIDE.name().toLowerCase());
    this.entityDamageSourceBlacklist.add(DamageCause.VOID.name().toLowerCase());
}
 

private static EntityDamageEvent callEntityDamageEvent(Entity damager, Entity damagee, DamageCause cause, Map<DamageModifier, Double> modifiers, Map<DamageModifier, Function<? super Double, Double>> modifierFunctions) {
    EntityDamageEvent event;
    if (damager != null) {
        event = new EntityDamageByEntityEvent(damager.getBukkitEntity(), damagee.getBukkitEntity(), cause, modifiers, modifierFunctions);
    } else {
        event = new EntityDamageEvent(damagee.getBukkitEntity(), cause, modifiers, modifierFunctions);
    }

    callEvent(event);

    if (!event.isCancelled()) {
        event.getEntity().setLastDamageCause(event);
    }

    return event;
}
 

@EventHandler
public void onEntityDamage(EntityDamageEvent e) {
    if (e instanceof EntityDamageByEntityEvent
            && !(e.getCause() == DamageCause.BLOCK_EXPLOSION || e.getCause() == DamageCause.ENTITY_EXPLOSION))
        return;
    Entity entity = e.getEntity();
    if (plugin.getLWC().isProtectable(e.getEntity().getType())) {
        int A = 50000 + entity.getUniqueId().hashCode();
        LWC lwc = LWC.getInstance();
        Protection protection = lwc.getPhysicalDatabase().loadProtection(entity.getWorld().getName(), A, A, A);
        if (protection != null) {
            if (e.getCause() != DamageCause.CONTACT)
                e.setCancelled(true);
        }
    }
}
 

@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = false)
public void onEntityDamage(EntityDamageEvent e) {
	if (e.getCause() != DamageCause.FALLING_BLOCK) {
		return;
	}
	
	Entity damaged = e.getEntity();
	if (!(damaged instanceof Player)) {
		return;
	}
	
	SpleefPlayer player = getHeavySpleef().getSpleefPlayer(damaged);
	if (!game.isIngame(player)) {
		return;
	}
	
	e.setCancelled(false);
}
 

public static DisableDamageModule parse(MapModuleContext context, Logger logger, Document doc) throws InvalidXMLException {
    SetMultimap<DamageCause, PlayerRelation> causes = HashMultimap.create();
    for(Element damageCauseElement : doc.getRootElement().getChildren("disabledamage")) {
        for(Element damageEl : damageCauseElement.getChildren("damage")) {
            DamageCause cause = XMLUtils.parseEnum(damageEl, DamageCause.class, "damage type");
            for(PlayerRelation damagerType : PlayerRelation.values()) {
                // Legacy syntax used "other" instead of "neutral"
                String attrName = damagerType.name().toLowerCase();
                Node attr = damagerType == PlayerRelation.NEUTRAL ? Node.fromAttr(damageEl, attrName, "other")
                                                                  : Node.fromAttr(damageEl, attrName);
                if(XMLUtils.parseBoolean(attr, true)) {
                    causes.put(cause, damagerType);

                    // Bukkit 1.7.10 changed TNT from BLOCK_EXPLOSION to ENTITY_EXPLOSION,
                    // so we include them both to keep old maps working.
                    if(cause == DamageCause.BLOCK_EXPLOSION) {
                        causes.put(DamageCause.ENTITY_EXPLOSION, damagerType);
                    }
                }
            }
        }
    }
    return new DisableDamageModule(causes);
}
 

/**
 * Calculates the damage that the armor will take for the specified damage.
 * This is according to the Vanilla Minecraft code, which divides the damage
 * by 4, increases it to at least 1 if it was less, and rounds it to an int.
 * There are also extra checks to prevent an armor piece to be damaged by a
 * forbidden {@link DamageCause} as well as calculations for adding extra
 * damage if the armor piece had Thorns.
 */
public int getArmorDamage(DamageCause cause, float damage, boolean hadThorns) {
	if (!damageCausesWithDurability.contains(cause))
		return 0;

	damage = damage / 4.0F;

	if (damage < 1.0F) {
		damage = 1.0F;
	}

	if (hadThorns)
		return thornsExtraDamage + (int) damage;
	else
		return (int) damage;
}
 

@EventHandler(priority = EventPriority.HIGHEST)
public void onEntityDamage(EntityDamageEvent event) {
	if (event.isCancelled())
		return;

	DamageCause cause = event.getCause();
	Entity damagee = event.getEntity();
	EntityType damageeType = damagee.getType();
	// PlayerCustomArmorDamageEvent
	if (damageeType == EntityType.PLAYER) {
		Player player = (Player) damagee;
		PlayerInventory inv = player.getInventory();
		for (ItemStack armor : inv.getArmorContents())
			// TODO: Speed up
			if (armor != null && armor.getType() != Material.AIR && AdditionsAPI.isCustomItem(armor)
					&& new CustomItemStack(armor).getCustomItem() instanceof CustomArmor
					&& new CustomItemStack(armor).getCustomItem()
							.getDurabilityMechanics() instanceof ArmorDurability) {
				CustomArmor cArmor = (CustomArmor) new CustomItemStack(armor).getCustomItem();
				Bukkit.getServer().getPluginManager().callEvent(new PlayerCustomArmorDamageEvent(player, armor,
						cArmor, cause, (float) event.getDamage(), armor.containsEnchantment(Enchantment.THORNS)));
			}
	}
}
 

@EventHandler
public void onEntityDamage(EntityDamageEvent event) {
    if (damageTypes.contains(event.getCause()) && (event.getCause() != DamageCause.BLOCK_EXPLOSION || event.getCause() != DamageCause.ENTITY_EXPLOSION)) {
        event.setCancelled(true);
    } else if (event.getCause() == DamageCause.BLOCK_EXPLOSION || event.getCause() == DamageCause.ENTITY_EXPLOSION) {
        if (event instanceof EntityDamageByEntityEvent) {
            if (event.getEntity() instanceof Player && TntTracker.getWhoPlaced(((EntityDamageByEntityEvent) event).getDamager()) != null) {
                Player player = (Player) event.getEntity();
                UUID source = TntTracker.getWhoPlaced(((EntityDamageByEntityEvent) event).getDamager());
                Match match = GameHandler.getGameHandler().getMatch();
                if (Bukkit.getOfflinePlayer(source).isOnline()) {
                    if (Bukkit.getPlayer(source).equals(player)) {
                        event.setCancelled(!blockExplosionSelf);
                    } else if (Teams.getTeamByPlayer(Bukkit.getPlayer(source)) == Teams.getTeamByPlayer(player)) {
                        event.setCancelled(!blockExplosionAlly);
                    } else if (Teams.getTeamByPlayer(Bukkit.getPlayer(source)) != Teams.getTeamByPlayer(player)) {
                        event.setCancelled(!blockExplosionEnemy);
                    } else {
                        event.setCancelled(!blockExplosionOther);
                    }
                }
            }
        } else if (damageTypes.contains(DamageCause.BLOCK_EXPLOSION)) event.setCancelled(true);
    }
}
 

@Override
public Relation compare(final DamageCause dc, final EntityData e) {
	switch (dc) {
		case ENTITY_ATTACK:
			return Relation.get(e.isSupertypeOf(EntityData.fromClass(Entity.class)));
		case PROJECTILE:
			return Relation.get(e.isSupertypeOf(EntityData.fromClass(Projectile.class)));
		case WITHER:
			return Relation.get(e.isSupertypeOf(EntityData.fromClass(Wither.class)));
		case FALLING_BLOCK:
			return Relation.get(e.isSupertypeOf(EntityData.fromClass(FallingBlock.class)));
			//$CASES-OMITTED$
		default:
			return Relation.NOT_EQUAL;
	}
}
 

@SuppressWarnings({"unchecked", "null"})
@Override
public boolean init(final Expression<?>[] vars, final int matchedPattern, final Kleenean isDelayed, final ParseResult parser) {
	damageables = vars[0];
	if (ItemStack.class.isAssignableFrom(damageables.getReturnType())) {
		if (!ChangerUtils.acceptsChange(damageables, ChangeMode.SET, ItemType.class)) {
			Skript.error(damageables + " cannot be changed, thus it cannot be damaged or repaired.");
			return false;
		}
	}
	damage = (Expression<Number>) vars[1];
	heal = (matchedPattern >= 1);
	
	if (vars.length >= 3) dmgCause = (Expression<DamageCause>) vars[2];
	return true;
}
 

@EventHandler(priority= EventPriority.NORMAL)
public void checkStrike(EntityDamageEvent event)
{
	if(event.getEntityType() == EntityType.PLAYER && event.getCause() == DamageCause.LIGHTNING)
	{
		AnniPlayer player = AnniPlayer.getPlayer(event.getEntity().getUniqueId());
		if(player != null && !player.getKit().equals(this))
		{
			Object obj = player.getData("LH");
			if(obj != null)
			{
				Long l = (Long)obj;
				if(System.currentTimeMillis()-l <= 30000)
				{
					event.setCancelled(true);
					player.setData("LH", null);
					return;
				}
			}
			event.setDamage(4);
			player.setData("LH", System.currentTimeMillis());
		}
	}
}
 

private static EntityDamageEvent callEntityDamageEvent(Entity damager, Entity damagee, DamageCause cause, Map<DamageModifier, Double> modifiers, Map<DamageModifier, Function<? super Double, Double>> modifierFunctions) {
    EntityDamageEvent event;
    if (damager != null) {
        event = new EntityDamageByEntityEvent(damager.getBukkitEntity(), damagee.getBukkitEntity(), cause, modifiers, modifierFunctions);
    } else {
        event = new EntityDamageEvent(damagee.getBukkitEntity(), cause, modifiers, modifierFunctions);
    }

    callEvent(event);

    if (!event.isCancelled()) {
        event.getEntity().setLastDamageCause(event);
    }

    return event;
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onEntityDamage(EntityDamageEvent event) {
	if (((event.getCause() == DamageCause.FIRE_TICK) || (event.getCause() == DamageCause.FIRE) || (event.getCause() == DamageCause.DROWNING))) {
		for (Player player : ServerPlatform.get().getMiscUtils().getNearbyPlayers(event.getEntity().getLocation(), 48, 128, 48)) {
			if (player != null) {
				Connection connection = ProtocolSupportAPI.getConnection(player);
				if (
					(connection != null) &&
					(connection.getVersion().getProtocolType() == ProtocolType.PC) &&
					connection.getVersion().isBefore(ProtocolVersion.MINECRAFT_1_12)
				) {
					connection.sendPacket(ServerPlatform.get().getPacketFactory().createEntityStatusPacket(event.getEntity(), 2));
				}
			}
		}
	}
}
 

@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onSpectatorDamaged(EntityDamageEvent e) {
	if (e.getEntity() instanceof Player) {
		final Player player = (Player) e.getEntity();
		final GameMap gameMap = MatchManager.get().getSpectatorMap(player);
		if (gameMap == null) {
			return;
		}
		e.setCancelled(true);
		if (e.getCause() == DamageCause.VOID) {
			World world = gameMap.getCurrentWorld();
			Location spectateSpawn = new Location(world, 0, 0, 0);
			player.teleport(spectateSpawn);
		}
	}
	
}
 

@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
  public void onDeath2(final PlayerDeathEvent v2) {
      final GameMap gameMap = MatchManager.get().getPlayerMap(v2.getEntity());

      if (gameMap == null) {
          return;
      }
       
      final Player player = v2.getEntity();
      v2.getEntity().getInventory().clear();
      v2.getEntity().getInventory().setArmorContents(null);
      
      DamageCause damageCause = DamageCause.CUSTOM;
if (v2.getEntity().getLastDamageCause() != null) {
	damageCause = v2.getEntity().getLastDamageCause().getCause();
} 
final DamageCause dCause = damageCause;
v2.setDeathMessage("");

      MatchManager.get().playerLeave(player, dCause, false, true, true);
  }
 

@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void playerDamaged(EntityDamageEvent event) {
	if (event.getEntity() instanceof Player) {
		Player player = (Player) event.getEntity();
		GameMap gameMap = MatchManager.get().getPlayerMap(player);
		if (gameMap != null) {
			if (gameMap.getMatchState() == MatchState.ENDING || gameMap.getMatchState() == MatchState.WAITINGSTART) {
				event.setCancelled(true);
				return;
			}
			if (!gameMap.allowFallDamage()) {
				if (event.getCause().equals(DamageCause.FALL)) {
					event.setCancelled(true);
				}
			}
		}
	}
}
 

public SlimefunBootsListener(SlimefunPlugin plugin) {
    plugin.getServer().getPluginManager().registerEvents(this, plugin);

    cancelledEvents.put("ENDER_BOOTS", e -> e instanceof EntityDamageByEntityEvent && ((EntityDamageByEntityEvent) e).getDamager() instanceof EnderPearl);

    cancelledEvents.put("BOOTS_OF_THE_STOMPER", e -> {
        if (e.getCause() == DamageCause.FALL) {
            stomp(e);
            return true;
        }

        return false;
    });

    cancelledEvents.put("SLIME_BOOTS", e -> e.getCause() == DamageCause.FALL);

    cancelledEvents.put("SLIME_STEEL_BOOTS", e -> e.getCause() == DamageCause.FALL);
}
 

private void stomp(EntityDamageEvent e) {
    Player p = (Player) e.getEntity();
    p.getWorld().playSound(p.getLocation(), Sound.ENTITY_ZOMBIE_BREAK_WOODEN_DOOR, 1F, 2F);
    p.setVelocity(new Vector(0.0, 0.7, 0.0));

    for (Entity n : p.getNearbyEntities(4, 4, 4)) {
        if (n instanceof LivingEntity && !n.getUniqueId().equals(p.getUniqueId())) {
            Vector velocity = n.getLocation().toVector().subtract(p.getLocation().toVector()).normalize().multiply(1.4);
            n.setVelocity(velocity);

            if (!(n instanceof Player) || (p.getWorld().getPVP() && SlimefunPlugin.getProtectionManager().hasPermission(p, n.getLocation(), ProtectableAction.PVP))) {
                EntityDamageByEntityEvent event = new EntityDamageByEntityEvent(p, n, DamageCause.ENTITY_ATTACK, e.getDamage() / 2);
                Bukkit.getPluginManager().callEvent(event);
                if (!event.isCancelled()) ((LivingEntity) n).damage(e.getDamage() / 2);
            }
        }
    }

    for (BlockFace face : BlockFace.values()) {
        Block b = p.getLocation().getBlock().getRelative(BlockFace.DOWN).getRelative(face);
        p.getWorld().playEffect(b.getLocation(), Effect.STEP_SOUND, b.getType());
    }
}
 

@EventHandler(priority = EventPriority.LOWEST)
public void onEntityDamage(EntityDamageByBlockEvent event) {
    if (event.getCause() == DamageCause.SUFFOCATION || event.getCause() == DamageCause.DROWNING) {
        return;
    }
    GDTimings.ENTITY_DAMAGE_EVENT.startTiming();
    if (protectEntity(event, event.getDamager() == null ? event.getCause() : event.getDamager(), event.getEntity())) {
        event.setCancelled(true);
    }
    GDTimings.ENTITY_DAMAGE_EVENT.stopTiming();
}
 

public DamageCause parseDamageCause(Element el) throws InvalidXMLException {
  DamageCause cause = DamageCause.valueOf(el.getTextNormalize().toUpperCase().replace(" ", "_"));

  if (cause == null) {
    throw new InvalidXMLException("Invalid damage cause '" + el.getValue() + "'.", el);
  }
  return cause;
}
 

@Override
public DisableDamageModule parse(MapFactory factory, Logger logger, Document doc)
    throws InvalidXMLException {
  SetMultimap<DamageCause, PlayerRelation> causes = HashMultimap.create();
  DamageParser parser = new DamageParser();

  for (Element damageCauseElement : doc.getRootElement().getChildren("disabledamage")) {
    for (Element damageEl : damageCauseElement.getChildren("damage")) {
      DamageCause cause = parser.parseDamageCause(damageEl);
      for (PlayerRelation damagerType : PlayerRelation.values()) {
        // Legacy syntax used "other" instead of "neutral"
        String attrName = damagerType.name().toLowerCase();
        Node attr =
            damagerType == PlayerRelation.NEUTRAL
                ? Node.fromAttr(damageEl, attrName, "other")
                : Node.fromAttr(damageEl, attrName);
        if (XMLUtils.parseBoolean(attr, true)) {
          causes.put(cause, damagerType);

          // Bukkit 1.7.10 changed TNT from BLOCK_EXPLOSION to ENTITY_EXPLOSION,
          // so we include them both to keep old maps working.
          if (cause == DamageCause.BLOCK_EXPLOSION) {
            causes.put(DamageCause.ENTITY_EXPLOSION, damagerType);
          }
        }
      }
    }
  }
  // Always load due to misc damage handling
  return new DisableDamageModule(causes);
}
 

private static DamageCause getBlockDamageCause(Block block) {
  switch (block.getType()) {
    case LAVA:
    case STATIONARY_LAVA:
      return DamageCause.LAVA;

    case FIRE:
      return DamageCause.FIRE;

    default:
      return DamageCause.CONTACT;
  }
}
 

@Override
public void load() {
    super.load();
    if(MutationMatchModule.check(match, Mutation.NO_FALL)) {
        this.causes.putAll(DamageCause.FALL, Sets.newHashSet(PlayerRelation.values()));
    }
}
 

private static DamageCause getBlockDamageCause(Block block) {
    switch(block.getType()) {
        case LAVA:
        case STATIONARY_LAVA:
            return DamageCause.LAVA;

        case FIRE:
            return DamageCause.FIRE;

        default:
            return DamageCause.CONTACT;
    }
}
 

@SuppressWarnings({"unchecked", "null"})
@Override
public boolean init(final Expression<?>[] exprs, final int matchedPattern, final Kleenean isDelayed, final ParseResult parseResult) {
	cause = new EventValueExpression<>(DamageCause.class);
	expected = (Expression<DamageCause>) exprs[0];
	setNegated(parseResult.mark == 1);
	cause.setParserInstance(pi);
	return ((EventValueExpression<DamageCause>) cause).init();
}
 

@EventHandler
public void onEntityHitByProjectile(EntityDamageByEntityEvent event) {
    if (event.isCancelled()) return;
    if (event.getCause().equals(DamageCause.PROJECTILE)) {
        ProjectileSource source = ((Projectile) event.getDamager()).getShooter();
        if (source instanceof Player) {
            ((Player) source).playSound(((Player) source).getLocation(), Sound.ENTITY_ARROW_HIT_PLAYER, 0.2F, 0.5F);
        }
        if (event.getDamager().getType().equals(projectile) && event.getDamager().hasMetadata("custom")) {
            Entity arrow = event.getEntity().getWorld().spawnEntity(event.getDamager().getLocation(), EntityType.ARROW);
            ((Projectile) arrow).setShooter(source);
            arrow.setVelocity(event.getDamager().getVelocity());
            event.getDamager().remove();
            if (event.getEntity() instanceof LivingEntity) {
                for (PotionEffect effect : potionEffects) {
                    ((LivingEntity) event.getEntity()).addPotionEffect(effect);
                }
                final Entity entity = event.getEntity();
                Bukkit.getServer().getScheduler().runTaskLater(GameHandler.getGameHandler().getPlugin(), new Runnable() {
                    @Override
                    public void run() {
                        ((LivingEntity) entity).setArrowsStuck(((LivingEntity) entity).getArrowsStuck() - 1);
                    }
                }, 0);
            }
        }
    }
}
 

/** Apply damage to an entity
 * @param e Entity to apply damage to
 * @param d Amount of hearts to damage
 */
public static void damage(final Damageable e, final double d) {
	if (d < 0) {
		heal(e, -d);
		return;
	}
	EntityDamageEvent event = new EntityDamageEvent(e, DamageCause.CUSTOM, d * 2);
	Bukkit.getPluginManager().callEvent(event);
	if (event.isCancelled()) return;
	e.damage(event.getDamage());
}
 

@Override
protected DamageCause[] get(final Event e, final LivingEntity[] source) {
	return get(source, new Getter<DamageCause, LivingEntity>() {
		@SuppressWarnings("null")
		@Override
		public DamageCause get(final LivingEntity entity) {
			EntityDamageEvent dmgEvt = entity.getLastDamageCause();
			if (dmgEvt == null) return DamageCause.CUSTOM;
			return dmgEvt.getCause();
		}
	});
}
 

@Override
@Nullable
public Class<?>[] acceptChange(final ChangeMode mode) {
	if (mode == ChangeMode.REMOVE_ALL)
		return null;
	return CollectionUtils.array(DamageCause.class);
}
 

@Override
public Relation compare(final DamageCause dc, final ItemType t) {
	switch (dc) {
		case FIRE:
			return Relation.get(t.isOfType(Material.LAVA));
		case LAVA:
			return Relation.get(t.equals(lava));
		case MAGIC:
			return Relation.get(t.isOfType(Material.POTION));
			//$CASES-OMITTED$
		default:
			return Relation.NOT_EQUAL;
	}
}