Java 类org.bukkit.entity.Monster 实例源码

@EventHandler
public void onEntityDeath(EntityDeathEvent e) {
    if (e.getEntity() instanceof Monster && e.getEntity().getKiller() instanceof Player) {
        TOAUser u = TOA.getPlayer(e.getEntity().getKiller());
        String name = e.getEntity().getCustomName().split(" ")[1];
        int level = Utils.isInt(name) ? Integer.parseInt(name) : 0;

        new Experience(u).addExp(Mob.getXP(level));

        e.getDrops().clear();
        e.setDroppedExp(0);

        Drop.drop(MobType.parseMobType(e.getEntityType()), u.getUserData().getKit()).forEach(d -> {
            BagEvents.addItem(u, d);
            u.sendSound(Sounds.ITEM_PICKUP);
        });

        if (plugin.getSpawnTask().getCount() == 0) return;
        plugin.getSpawnTask().setCount(plugin.getSpawnTask().getCount() - 1);
    }
}

public void play(TOAUser u){
    if (!canUse(u)) return;
    if (isInCooldown(u, getName())) return;
    int lvl = u.getUserData().getLvl();

    for (int x = 0; x < r.nextInt(4) + 2; x++) {
        final Item d1 = u.getLoc().getWorld().dropItemNaturally(u.getLoc(), new ItemStack(Material.IRON_SWORD));

        d1.setVelocity(u.getPlayer().getVelocity().multiply(2));

        plugin.getServer().getScheduler().runTaskTimer(plugin, () -> {
            World w = d1.getLocation().getWorld();

            w.getNearbyEntities(d1.getLocation(), 1, 1, 1).stream()
                    .filter(en -> !en.getType().equals(EntityType.PLAYER)).forEach(en -> {
                if (en instanceof Monster) ((Monster) en).damage(40 + (lvl * 0.7));
                d1.remove();
            });
        }, 0, 20);
    }
    cool.setOnCooldown(getName());
}

public BreakBlockSession(Location l, Material m, double r, int qty, String monsters) {
    _locations = l;
    _material = m;
    _radius = r;
    _qty = qty;
    _monsters = monsters;
    _zone = new WorldZone(l, r);
    _world = l.getWorld();
    _spawnedMonsters = new ArrayList<Monster>();
    _blockBroken = true;
    _isCooldownActive = false;
    _coolDownTime = 0;
    _header = ChatColor.LIGHT_PURPLE + "[" + ChatColor.DARK_PURPLE + "Obsidian" + ChatColor.LIGHT_PURPLE + "] ";
    _resetWhenPlayerLeaving = false;
    _players = new ArrayList<Player>();
}

public void activateBreakingZone() {
    if (!_isCooldownActive && _blockBroken) {
        _logger.info("activting");
        for (int i = 0; i < _qty; i++) {
            Location loc = _locations.clone();
            loc.setY(loc.getY() + 2);
            EntityType t = EntityHelper.getRandomEntity(_monsters);
            Entity l = _world.spawnCreature(loc, t);
            if (l instanceof Monster) {
                _spawnedMonsters.add((Monster)l);
                _logger.info(l.getEntityId() + " spawned at " + l.getLocation());
            }
        }

        org.bukkit.block.Block b = _world.getBlockAt(_locations);
        b.setType(_material);       
        _blockBroken = false;
    }
    else {
        _logger.info("not activting");  
    }




}

@Override
public void timeHasCome(long time) {
    if (_monsterSpawned.size() < _maxMonster) {
        Location random = _spawningZone.getRandomLocation(_spawningLocation.getWorld());
        EntityType creature = EntityUtilities.getEntityType(_monsters[RandomUtil.getRandomInt(_monsters.length)]);
        Monster m = (Monster)ScenarioService.getInstance().spawnCreature(_spawningLocation.getWorld(), random, creature, _healthModifier, _burn);
        m.setTarget(_players.get(RandomUtil.getRandomInt(_players.size())));

        ScenarioPlugin.logger.fine("Spawner at: " + _spawningLocation.getX() + "," + _spawningLocation.getZ() + " high: " + _spawningLocation.getY() + " - " + creature.toString() + " -> " + m.getTarget().getEntityId());

        _monsterSpawned.add(m);
        TimeServer.getInstance().addListener(this, _delayBetweenMonster);
    }


}

@Override
public void spawnWave() {
    if (_scenario.isActive() && _locations != null && _locations.size() > 0 && 
        _arrayPossibleMonster.length > 0 && getNbOfEntities() < _maxMonster) {

        for (Location l : _locations) {

            if (getNbOfEntities() < _maxMonster) {
                EntityType c = EntityUtilities.getEntityType(_arrayPossibleMonster[RandomUtil.getRandomInt(_arrayPossibleMonster.length)]);
                Entity e = ScenarioService.getInstance().spawnCreature(l.getWorld(), l, c, _healthModifier, false);
                _monsters.add(e);
                if (e instanceof Monster) {
                    Monster m = (Monster)e;
                    m.setTarget(_scenario.pickRandomPlayer());
                }
            }
        }

        if (_timeBetweenSpawn > 50) {
            TimeServer.getInstance().addListener(this, _timeBetweenSpawn);
        }

    }

}

@Override
public void processEntityDeath(Entity e) {
    if (_scenario.isActive()) {
        if (e instanceof Monster) {
            _monsters.remove((LivingEntity)e);

            if (_scenario.getEventListener() != null) {
                _scenario.getEventListener().monsterDied(e, _monsters.size());
            }
        }

        if (_monsters.size() == 0) {
            TimeServer.getInstance().removeListener(this);
            _scenario.waveIsDone();
        }
    }


}

public void spawnWave() {
    if (_scenario.isActive()) {
        for (int i = 0; i < _nbMonsters; i++) {
            // creation de la location et du monstre
            Location loc = _scenario.getWorldZone().getRandomLocationOutsideThisZone(_scenario.getWorld(), _exclude);
            EntityType type = EntityUtilities.getEntityType(possibleMonsters[RandomUtil.getRandomInt(possibleMonsters.length)]);            
            Entity living = _scenario.getWorld().spawnEntity(loc, type);

            if (living instanceof Monster) {
                Monster m = (Monster)living;
                m.setTarget(_scenario.pickRandomPlayer());
            }

            // adding to the table
            _monstersTable.add(living);
        }
    }


}

@EventHandler(priority = EventPriority.NORMAL)
public void monsterDies(EntityDeathEvent event) {

    if (_apocalypseOn && event.getEntity().getLastDamageCause().getCause() != DamageCause.FIRE_TICK) {

        if (event.getEntity() instanceof Monster) {
            _monsterDead++;
        }

        if (_monsterDead >= _maxMonsters) {
            _completed = true;
            distributeLoot();
            resetEvent();
        }       

        try {
            _spawner.spawnMonsterCloseToPlayer(event.getEntity().getLocation());
        }
        catch (Exception ex) {
            _logger.info("exception raised in Mayhem.monsterDies(EntityDeathEvent event) while using the ApocalypseSpawner");
        }

    }
}

@EventHandler (priority = EventPriority.NORMAL)
public void playerDies(PlayerDeathEvent event) {
    Player p = event.getEntity();
    boolean playerRemoved = _players.remove(p);

    if (playerRemoved && _players.size() == 0 && _started) {
        EventActivator activator = new EventActivator(this);
        activator.run();

        if (_blockRestore != null) {
            _blockRestore.run();
        }
        for (Monster m : _monstersEntity) { 
            m.remove();
        }
        _monstersContainer.clear();
        _started = false;
    }
}

@Override
public void run() {

    Player p = Bukkit.getServer().getPlayer("punisher_malade");


    for (Monster e : _entities) {

        if (!e.isDead() && !_zone.isInside(e.getLocation())) {
            Location l = _zone.getRandomLocation(_zone.getWorld());
            _movement.moveEntityToLocation(e, l);
            if (p != null) {
                p.sendMessage(ChatColor.GRAY + "DEBUG: " + ChatColor.WHITE + e.getType() + " moving to " + l.getX() + ", " + l.getY() + ", " + l.getZ());
            }
        }
    }

}

@EventHandler(priority = EventPriority.NORMAL)
public void onMonsterDamage(EntityDamageEvent event) {      

    if (event instanceof EntityDamageByEntityEvent) {

        EntityDamageByEntityEvent damageEvent = (EntityDamageByEntityEvent)event;
        CustomMonster damager = _damageMonsters.get(damageEvent.getDamager().getEntityId());

        if (damager != null && damageEvent.getDamager() instanceof Monster && event.getEntity() instanceof Player) {
            int damageDone = (int)(event.getDamage() + (2 * (int)damager.DamageModifier));
            //logger.info("damage done is: " + damageDone + " modifier is: " + (int)damager.DamageModifier + " base damage is: " + event.getDamage());
            event.setDamage(damageDone);
        }
    }

    CustomMonster noBurn = _noBurnMonsters.get(event.getEntity().getEntityId());
    if (noBurn != null && event.getEntity() instanceof Monster && event.getCause() == DamageCause.FIRE_TICK) {
        event.setCancelled(true);
        event.getEntity().setFireTicks(0);
    }
}

@EventHandler
public void WitherBlockBreak(EntityChangeBlockEvent event) {
    RedProtect.get().logger.debug("RPEntityListener - Is EntityChangeBlockEvent");
    if (event.isCancelled()) {
        return;
    }
    Entity e = event.getEntity();       
    if (e instanceof Monster) {
        Region r = RedProtect.get().rm.getTopRegion(event.getBlock().getLocation());
        if (!cont.canWorldBreak(event.getBlock())){                             
            event.setCancelled(true);
            return;
        } 
        if (r != null && !r.canMobLoot()){
           event.setCancelled(true);
        }
    }
}

@EventHandler(priority = EventPriority.HIGHEST)
   public void onEntityDamage(EntityDamageEvent e) {
    Region r = RedProtect.get().rm.getTopRegion(e.getEntity().getLocation());
    if (r != null){
        return;
    }
    Entity ent = e.getEntity();
    if (ent instanceof LivingEntity && !(ent instanceof Monster)){
        if (RPConfig.getGlobalFlagBool(ent.getWorld().getName()+".invincible")){
            if (ent instanceof Animals){
                ((Animals)ent).setTarget(null);
            }
            e.setCancelled(true); 
        }
    }               
}

@EventHandler
 public void MonsterBlockBreak(EntityChangeBlockEvent event) {
    Entity e = event.getEntity();       
    Block b = event.getBlock();
    Region r = RedProtect.get().rm.getTopRegion(event.getBlock().getLocation());
    if (r != null){
       return;
     }

    if (b != null){
        RedProtect.get().logger.debug("RPGlobalListener - Is EntityChangeBlockEvent event. Block: "+b.getType().name());
    }

    if (e instanceof Monster) {
         if (!RPConfig.getGlobalFlagBool(e.getWorld().getName()+".entity-block-damage")){
            event.setCancelled(true);
         }
    }
    if (e instanceof Player){
        Player p = (Player) e;
        if (!bypassBuild(p, b, 2)){
            event.setCancelled(true);
}
    }
 }

@EventHandler
 public void onFrameBrake(HangingBreakByEntityEvent e) {
    RedProtect.get().logger.debug("Is BlockListener - HangingBreakByEntityEvent event");
    if (e.isCancelled()){
        return;
    }

    Entity remover = e.getRemover();
    Entity ent = e.getEntity();
    Location l = e.getEntity().getLocation();

    if ((ent instanceof ItemFrame || ent instanceof Painting) && remover instanceof Monster) {
        Region r = RedProtect.get().rm.getTopRegion(l);
        if (r != null && !r.canMobLoot()){
            e.setCancelled(true);
}
     }    
 }

@EventHandler
public void onHangingDamaged(HangingBreakByEntityEvent e) {
    if (e.isCancelled()) {
        return;
    }
    RedProtect.get().logger.debug("Is RPPlayerListener - HangingBreakByEntityEvent event");
    Entity ent = e.getRemover();
    Location loc = e.getEntity().getLocation();
    Region r = RedProtect.get().rm.getTopRegion(loc);

    if (ent instanceof Player) {
        Player player = (Player)ent; 
        if (r != null && !r.canBuild(player) && !r.canBreak(e.getEntity().getType())) {
            RPLang.sendMessage(player, "blocklistener.region.cantbuild");
            e.setCancelled(true);
        }
    } 
    if (ent instanceof Monster){
        if (r != null && !r.canMobLoot()) {
            e.setCancelled(true);
        }
    }
}

/**
    * Removes monsters around location l
    * 
    * @param l
    */
   public void removeMobs(final Location l) {
final int px = l.getBlockX();
final int py = l.getBlockY();
final int pz = l.getBlockZ();
for (int x = -1; x <= 1; x++) {
    for (int z = -1; z <= 1; z++) {
    final Chunk c = l.getWorld().getChunkAt(new Location(l.getWorld(), px + x * 16, py, pz + z * 16));
    if (c.isLoaded()) {
        for (final Entity e : c.getEntities()) {
        if (e instanceof Monster && !Settings.mobWhiteList.contains(e.getType())) {
            e.remove();
        }
        }
    }
    }
}
   }

public CreatureType getCreatureType(EntityType entityType) {
    if (Monster.class.isAssignableFrom(entityType.getEntityClass())
            || WaterMob.class.isAssignableFrom(entityType.getEntityClass())
            || Slime.class.isAssignableFrom(entityType.getEntityClass())
            || Ghast.class.isAssignableFrom(entityType.getEntityClass())
            ) {
        return CreatureType.MONSTER;
    } else if (Animals.class.isAssignableFrom(entityType.getEntityClass())) {
        return CreatureType.ANIMAL;
    } else if (Villager.class.isAssignableFrom(entityType.getEntityClass())) {
        return CreatureType.VILLAGER;
    } else if (Golem.class.isAssignableFrom(entityType.getEntityClass())) {
        return CreatureType.GOLEM;
    }
    return CreatureType.UNKNOWN;
}

public void removeCreatures(final Location l) {
    if (!Settings.island_removeCreaturesByTeleport || l == null) {
        return;
    }
    final int px = l.getBlockX();
    final int py = l.getBlockY();
    final int pz = l.getBlockZ();
    for (int x = -1; x <= 1; ++x) {
        for (int z = -1; z <= 1; ++z) {
            final Chunk c = l.getWorld().getChunkAt(new Location(l.getWorld(), (double) (px + x * 16), (double) py, (double) (pz + z * 16)));
            Entity[] entities;
            for (int length = (entities = c.getEntities()).length, i = 0; i < length; ++i) {
                final Entity e = entities[i];
                if (e instanceof Monster && e.getCustomName() == null) { // Remove all monsters that are not named
                    e.remove();
                }
            }
        }
    }
}

@EventHandler(priority = EventPriority.NORMAL)
public void onChunkLoad(ChunkLoadEvent event) {

    for (Entity e : event.getChunk().getEntities()) {
        if (e instanceof Monster) {
            e.remove();
            return;
        }

        if (e instanceof IronGolem) {
            e.remove();
            return;
        }
    }

}

@Override
public CastResult onCast(User user, int power, String[] args) {
    int radius = this.radius * power;
    List<Entity> entityList = user.getPlayer().getNearbyEntities(radius, radius, radius);
    List<Monster> monsterList = new ArrayList<Monster>();
    for (Entity entity : entityList) {
        if (entity instanceof Monster) {
            monsterList.add((Monster) entity);
        }
    }
    for (int i = 0; i < monsterList.size(); i++) {
        int targetIndex = i + 1;
        if (targetIndex >= monsterList.size()) {
            targetIndex = 0;
        }
        Monster monster = monsterList.get(i);
        Monster target = monsterList.get(targetIndex);
        monster.setTarget(target);
        Object monsterHandle = NMSUtils.getHandle(monster);
        Object targetHandle = NMSUtils.getHandle(target);
        ReflectionUtils.invokeMethod(monsterHandle, "setGoalTarget", targetHandle);
        ParticleEffects.sendParticle(Particle.ANGRY_VILLAGER, monster.getTarget().getLocation().add(0, 1, 0),
                0.25F, 0.25F, 0.25F, 5, 5);
    }
    return CastResult.SUCCESS;
}

public void clearEvil() {
        for (Player player : Bukkit.getOnlinePlayers()) {
//          if (peacefulPlayer.contains(player) && player.getWorld().getName().equals("GriefFree")) {
            if (player.getWorld().getName().equals("GriefFree")) {
                PlayerInventory pinv = player.getInventory();
                if (pinv.getHelmet() == null && pinv.getChestplate() == null && pinv.getLeggings() == null && pinv.getBoots() != null && pinv.getBoots().getType() == Material.GOLD_BOOTS) {
                    for (Entity e : player.getNearbyEntities(30, 30, 30)) {
                        if (e instanceof LivingEntity) {
                            if (e instanceof Monster) {
                                e.remove();
                            }
                        }
                    }
                }
            }
        }
    }

protected static String getKey(Object object) {
    if(object instanceof Entity) {
        Entity entity = (Entity)object;
        String category = "entity";
        if(object instanceof Player) {
            category = "players";
        } else if(object instanceof Monster) {
            category = "monster";
        } else if(object instanceof LivingEntity) {
            category = "mob";
        }
        return category + "/" + entity.getUniqueId();
    } else if(object instanceof Block) {
        Block block = (Block)object;
        return "block" + "/" + block.getX() + "," + block.getY() + "," + block.getZ();
    }
    throw new NotImplementedException("Only entities and blocks are supported");
}

@SuppressWarnings("deprecation")
public static Class<? extends net.minecraft.server.v1_7_R1.Entity> getNmsEntityClass(final Class<? extends LivingEntity> entityClass) throws IllegalArgumentException {
    if(entityClass==null) throw new IllegalArgumentException("entityClass must not be null");
    if(entityClass==HumanEntity.class || entityClass==Player.class) return net.minecraft.server.v1_7_R1.EntityHuman.class;
    if(entityClass==Monster.class) return net.minecraft.server.v1_7_R1.EntityMonster.class;
    if(entityClass==Creature.class) return net.minecraft.server.v1_7_R1.EntityCreature.class;
    if(entityClass==Animals.class) return net.minecraft.server.v1_7_R1.EntityAnimal.class;
    if(entityClass==LivingEntity.class) return net.minecraft.server.v1_7_R1.EntityLiving.class;

    for(EntityType entityType: EntityType.values()) {
        if(entityType.getEntityClass()==null || entityType.getTypeId()==-1) continue;
        if(entityClass.equals(entityType.getEntityClass())) {
            return getNmsEntityClass(entityType);
        }
    }

    throw new IllegalArgumentException("Class "+entityClass.getSimpleName()+" is not resolvable to an EntityType");
}

@EventHandler(priority = EventPriority.LOWEST)
public void onCreatureSpawnEventLowest(CreatureSpawnEvent event) {
  if (!(event.getEntity() instanceof Monster) || event.isCancelled()) {
    return;
  }
  if (!mythicDrops.getConfigSettings().getEnabledWorlds().contains(event.getEntity().getWorld()
      .getName())) {
    return;
  }
  if (mythicDrops.getConfigSettings().isGiveAllMobsNames()) {
    nameMobs(event.getEntity());
  }
  if (mythicDrops.getConfigSettings().isBlankMobSpawnEnabled()) {
    event.getEntity().getEquipment().clear();
    if (event.getEntity() instanceof Skeleton && !mythicDrops.getConfigSettings()
        .isSkeletonsSpawnWithoutBows()) {
      event.getEntity().getEquipment().setItemInMainHand(new ItemStack(Material.BOW, 1));
    }
  }
  event.getEntity()
      .setCanPickupItems(mythicDrops.getConfigSettings().isMobsPickupEquipment());
}

@EventHandler(ignoreCancelled = true)
void onEntityDamage(EntityDamageEvent event) {
    Entity entity = event.getEntity();
    // block damaging of shopkeepers
    if (plugin.isShopkeeper(entity)) {
        event.setCancelled(true);
        if (event instanceof EntityDamageByEntityEvent) {
            EntityDamageByEntityEvent evt = (EntityDamageByEntityEvent) event;
            if (evt.getDamager() instanceof Monster) {
                Monster monster = (Monster) evt.getDamager();
                // reset target, future targeting should get prevented somewhere else:
                if (entity.equals(monster.getTarget())) {
                    monster.setTarget(null);
                }
            }
        }
    }
}

@Override
public boolean run(Player player, String[] args, int power) {
    int r = getConfig().getInt(getName() + ".radius");
    r = r*power;
    Monster[] e = getNearbyEntities(player.getLocation(), r);
    for (int i = 0; i < e.length; i++) {
        int index = i + 1;
        if (index >= e.length) {
            index = 0;
        }
        e[i].setTarget(e[index]);
        Object m = NMSHandler.getHandle(e[i]);
        Object tar = NMSHandler.getHandle(e[index]);
        Method method = ReflectionUtils.getMethod(m.getClass(), "setGoalTarget");
        try {
            method.invoke(m, tar);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        Location loc = e[i].getLocation();
        loc.setY(loc.getY() + 1);
        Effects.playEffect(ParticleEffects.ANGRY_VILLAGER, loc, 0.25F, 0.25F, 0.25F, 5, 10);
    }
    return true;
}

private static Monster[] getNearbyEntities(Location l, int radius) {
    int chunkRadius = radius < 16 ? 1 : (radius - (radius % 16)) / 16;
    HashSet<Monster> radiusEntities = new HashSet<Monster>();
    for (int chX = 0 - chunkRadius; chX <= chunkRadius; chX++) {
        for (int chZ = 0 - chunkRadius; chZ <= chunkRadius; chZ++) {
            int x = (int) l.getX(), y = (int) l.getY(), z = (int) l.getZ();
            for (Entity e : new Location(l.getWorld(), x + (chX * 16), y, z + (chZ * 16)).getChunk().getEntities()) {
                if (e.getLocation().distance(l) <= radius && e.getLocation().getBlock() != l.getBlock()) {
                    if (e instanceof Monster) {
                        radiusEntities.add((Monster) e);
                    }
                }
            }
        }
    }
    return radiusEntities.toArray(new Monster[radiusEntities.size()]);
}

@Override
public boolean run(Player player, String[] args, int power) {
    int r = getConfig().getInt(getName() + ".radius");
    r = r*power;
    Monster[] e = getNearbyEntities(player.getLocation(), r);
    for (int i = 0; i < e.length; i++) {
        int index = i + 1;
        if (index >= e.length) {
            index = 0;
        }
        e[i].setTarget(e[index]);
        Object m = NMSHandler.getHandle(e[i]);
        Object tar = NMSHandler.getHandle(e[index]);
        Method method = ReflectionUtils.getMethod(m.getClass(), "setGoalTarget");
        try {
            method.invoke(m, tar);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        Location loc = e[i].getLocation();
        loc.setY(loc.getY() + 1);
        Effects.playEffect(ParticleEffects.ANGRY_VILLAGER, loc, 0.25F, 0.25F, 0.25F, 5, 5);
    }
    return true;
}

public static Monster[] getNearbyEntities(Location l, int radius) {
    int chunkRadius = radius < 16 ? 1 : (radius - (radius % 16)) / 16;
    HashSet<Monster> radiusEntities = new HashSet<Monster>();
    for (int chX = 0 - chunkRadius; chX <= chunkRadius; chX++) {
        for (int chZ = 0 - chunkRadius; chZ <= chunkRadius; chZ++) {
            int x = (int) l.getX(), y = (int) l.getY(), z = (int) l.getZ();
            for (Entity e : new Location(l.getWorld(), x + (chX * 16), y, z + (chZ * 16)).getChunk().getEntities()) {
                if (e.getLocation().distance(l) <= radius && e.getLocation().getBlock() != l.getBlock()) {
                    if (e instanceof Monster) {
                        radiusEntities.add((Monster) e);
                    }
                }
            }
        }
    }
    return radiusEntities.toArray(new Monster[radiusEntities.size()]);
}

/**
 * Prevents mobs spawning at spawn or in an island
 *
 * @param e
 */
@EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
public void onMobSpawn(final CreatureSpawnEvent e) {
    if (DEBUG2) {
        plugin.getLogger().info("on Mob spawn" + e.getEventName());
    }
    // if grid is not loaded yet, return.
    if (plugin.getIslands() == null) {
        return;
    }
    // If not in the right world, return
    if (!Util.inWorld(e.getEntity())) {
        return;
    }
    // Deal with natural spawning
    if (e.getEntity() instanceof Monster || e.getEntity() instanceof Slime) {
        if (!actionAllowed(e.getLocation(), SettingsFlag.MONSTER_SPAWN)) {
            if (DEBUG2)
                plugin.getLogger().info("Natural monster spawn cancelled.");
            // Mobs not allowed to spawn
            e.setCancelled(true);
            return;
        }
    }
    if (e.getEntity() instanceof Animals) {
        if (!actionAllowed(e.getLocation(), SettingsFlag.ANIMAL_SPAWN)) {
            // Animals are not allowed to spawn
            if (DEBUG2)
                plugin.getLogger().info("Natural animal spawn cancelled.");
            e.setCancelled(true);
        }
    }
}

private void exterminate(){
    world.getEntities().forEach(e -> {
        if (e instanceof Monster || e instanceof Animals){
            LivingEntity le = (LivingEntity)e;
            le.damage(le.getMaxHealth());
        }
        if (e instanceof Item){
            e.remove();
        }
    });
}

public void loadWorld() {
    new WorldCreator(worldName).createWorld();
    new WorldCreator(getCurrent().worldName).createWorld();
    getWorld().setAutoSave(false);
    setState(ArenaState.WAITING);

    for (Entity e : getWorld().getEntities())
        if (e instanceof Monster)
            e.remove();
}

public void loadWorld() {
    new WorldCreator(worldName).createWorld();
    new WorldCreator(getCurrent().worldName).createWorld();
    getWorld().setAutoSave(false);
    setState(ArenaState.WAITING);

    for (Entity e : getWorld().getEntities())
        if (e instanceof Monster)
            e.remove();
}

public WorldInfo(World world) {
    this.worldName = world.getName();
    this.totalOnline = world.getPlayers().size();
    for (Entity entity : world.getEntities()) {
        this.totalEntity++;
        if (entity instanceof Animals) {
            this.totalAnimals++;
        } else if (entity instanceof Monster) {
            this.totalMonsters++;
        } else if (entity instanceof Item) {
            this.totalDropItem++;
        }
    }
    for (Chunk loadedChunk : world.getLoadedChunks()) {
        this.totalChunk++;
        for (BlockState tiles : loadedChunk.getTileEntities()) {
            this.totalTiles++;
            if (tiles instanceof Hopper) {
                this.totalHopper++;
            } else if (tiles instanceof Chest) {
                this.totalChest++;
            } else if (tiles instanceof Dispenser) {
                this.totalDispenser++;
            } else if (tiles instanceof Dropper) {
                this.totalDropper++;
            } else if (tiles instanceof BrewingStand) {
                this.totalBrewingStand++;
            }
        }

    }
}

public void spell(TOAUser u) {
    u.getWorld().getNearbyEntities(u.getLoc(), 2, 2, 2).stream().filter(e -> e.getType() != EntityType.PLAYER).filter(e -> e instanceof Monster).forEach(e -> {
        Monster m = (Monster) e;
        m.damage(20 + (u.getUserData().getLvl() * 0.3));
        m.setVelocity(new Vector(0, 4, 0));
    });
}

public void play(TOAUser u) {
    if (!canUse(u)) return;
    if (isInCooldown(u, getName())) return;

    if (u.getUserData().getKit() == 2 && r.nextInt(10) + 1 <= 3) {
        u.sendMessage(PAData.TOA.getPrefix() + "&cTu habilidad ha fallado");
        return;
    }

    u.getWorld().getNearbyEntities(u.getLoc(), 5, 3, 5).stream().filter(e -> !e.getType().equals(EntityType.PLAYER)).forEach(e -> {
        if (e instanceof Monster) ((Monster) e).addPotionEffect(new PotionEffect(PotionEffectType.SLOW, 40, 2, true, false));
    });
    cool.setOnCooldown(getName());
}

public void RemoveMonster(World world){
    for(Entity e : world.getEntities()){
        if(e instanceof Monster)
        {
            e.remove();
        }
    }
}

private boolean isMonster(Entity entity)
{
    if(entity instanceof Monster) return true;

    EntityType type = entity.getType();
    if(type == EntityType.GHAST || type == EntityType.MAGMA_CUBE || type == EntityType.SHULKER) return true;

    if(type == EntityType.RABBIT)
    {
        Rabbit rabbit = (Rabbit)entity;
        if(rabbit.getRabbitType() == Rabbit.Type.THE_KILLER_BUNNY) return true;
    }

    return false;
}