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

public static void finalizarMvP() {
    setAcontecendo(false);
    setIniciado(false);

    for(Player p : participantes) {
        teleportSaida(p);
    }

    for(Entity mob : mobsSpawnados) {
        ((Damageable) mob).setHealth(0);
    }

    participantes.clear();
    mobsSpawnados.clear();
    Bukkit.getScheduler().cancelTasks(Main.getInstance());
}

private void damagePlayer(Player target)
{   
    if (!target.isDead())
    {
        if (target.getGameMode() == GameMode.CREATIVE)
            return;

        double newHealth = ((Damageable) target).getHealth() - 1;

        if (newHealth < 0)
            newHealth = 0;

        target.setHealth(newHealth);
        target.setLastDamageCause(new EntityDamageEvent(target, DamageCause.CUSTOM, 1.0));
    }
}

private void damagePlayer(Player target)
{   
    if (!target.isDead())
    {
        if (target.getGameMode() == GameMode.CREATIVE)
            return;

        double newHealth = ((Damageable) target).getHealth() - 1;

        if (newHealth < 0)
            newHealth = 0;

        target.setHealth(newHealth);
        target.setLastDamageCause(new EntityDamageEvent(target, DamageCause.CUSTOM, 1.0));
    }
}

public void onEntityDamage(EntityDamageByEntityEvent event){
    if((OrangeTeam.hasPlayer((Player) event.getDamager()) &&  OrangeTeam.hasPlayer((Player) event.getEntity())) || (BlueTeam.hasPlayer((Player) event.getDamager()) &&  BlueTeam.hasPlayer((Player) event.getEntity()))){
        event.setCancelled(true);
    }
    else{
        Player death = (Player) event.getEntity();
        Damageable d = (Damageable) death;
        int health = (int) d.getHealth();
        double damage = event.getDamage();
        if(health - damage <= 0){
            stats.addDeaths((Player)event.getEntity(), 1);
            stats.addKill((Player)event.getDamager(), 1);
            s.flushAll();
        }
    }
}

public void onWeaponDamage(WeaponDamageEntityEvent event){
    if((OrangeTeam.hasPlayer((Player) event.getPlayer()) &&  OrangeTeam.hasPlayer((Player) event.getVictim())) || (BlueTeam.hasPlayer((Player) event.getPlayer()) &&  BlueTeam.hasPlayer((Player) event.getVictim()))){
        event.setCancelled(true);
    }
    else{
        Player death = (Player) event.getVictim();
        Damageable d = (Damageable) death;
        int health = (int) d.getHealth();
        double damage = event.getDamage();
        if(health - damage <= 0){
            stats.addDeaths((Player)event.getVictim(), 1);
            stats.addKill((Player)event.getPlayer(), 1);
            s.flushAll();
        }
    }
}

@EventHandler(ignoreCancelled = true)
protected void onHeal(EntityRegainHealthEvent e) {
    if (isEnabled()) {
        if (!plugin.fade) {
            if (e.getEntity() instanceof Player) {
                Player p = (Player) e.getEntity();
                if (plugin.functions.isTintEnabled(p)) {
                    Damageable d = (Damageable) p;
                    double heal = e.getAmount();
                    int health = (int) (d.getHealth() + heal);
                    plugin.functions.sendBorder(p, health);
                }
            }
        }
    }
}

public UserState(Player p, Game game) {
    this.game = game;
    this.player = p;
    this.maxhealth = ((Damageable) p).getMaxHealth();
    this.health = ((Damageable) p).getHealth();
    this.food = p.getFoodLevel();
    this.exp = p.getExp();
    this.level = p.getLevel();
    this.fireticks = p.getFireTicks();
    this.loc = p.getLocation();
    this.gamemode = p.getGameMode();
    this.allowFlying = p.getAllowFlight();
    this.flying = p.isFlying();
    this.ape = p.getActivePotionEffects();
    this.fall = p.getFallDistance();
    this.walk = p.getWalkSpeed();
    this.fly = p.getFlySpeed();
    this.heldslot = p.getInventory().getHeldItemSlot();

    ItemStack[][] store = new ItemStack[2][1];
    store[0] = p.getInventory().getContents();
    store[1] = p.getInventory().getArmorContents();
    this.inventory = store;

    StatisticLoader.load(this);
}

public PlayerData(Player p, Arena a) {
    this.player = p;
    this.a = a;

    inventory = p.getInventory().getContents();
    armor = p.getInventory().getArmorContents();
    gm = player.getGameMode();
    xp = p.getExp();
    level = p.getLevel();
    hunger = p.getExhaustion();
    maxhealth = ((Damageable) p).getMaxHealth();
    health = ((Damageable) p).getHealth();
    flying = p.getAllowFlight();

    player.setGameMode(GameMode.ADVENTURE);
    player.setAllowFlight(false);
    player.setFlying(false);
    player.setSleepingIgnored(true);
    player.setMaxHealth(20.0);
    player.setHealth(20.0);
    player.setExhaustion(20.0F);
    player.setExp(0F);
    player.setLevel(0);
    Utils.clearInventory(player);
    player.updateInventory();
}

@Override
public boolean effect(Event event, Player player) {
    EntityDamageByEntityEvent e = (EntityDamageByEntityEvent) event;
    if (e.getDamager() == player && e.getEntity() instanceof Player) {
        Player damaged = (Player) e.getEntity();
        e.setDamage(0);
        EffectManager.playSound(damaged.getLocation(), "ENTITY_GENERIC_DRINK", 0.5f, 1f);
        EffectManager.playSound(damaged.getLocation(), "BLOCK_ANVIL_LAND", 0.5f, 2f);
        short currentDur = player.getItemInHand().getDurability();

        if (((Damageable) damaged).getHealth() + Heal <= ((Damageable) damaged).getMaxHealth()) {
            damaged.setHealth(((Damageable) damaged).getHealth() + Heal);
        } else {
            damaged.setHealth(((Damageable) damaged).getMaxHealth());
        }

        if (currentDur + Heal < player.getItemInHand().getType().getMaxDurability()) {
            player.getItemInHand().setDurability((short) (currentDur + Heal));
        } else {
            player.setItemInHand(new ItemStack(Material.AIR, 1));
            EffectManager.playSound(player.getLocation(), "ENTITY_ITEM_BREAK", 0.1f, 0.3f);
        }
        return true;
    }
    return false;
}

private void heal(final Player p) {
    p.sendMessage(ChatColor.GREEN + "The bandage covers your wounds.");
    p.setMetadata("ce." + getOriginalName(), new FixedMetadataValue(main, ChatColor.RED + "You are already using a bandage!"));
    if(p.hasMetadata("ce.bleed")) 
        p.removeMetadata("ce.bleed", main);
    new BukkitRunnable() {
        int localCounter = TotalHealTime;
        @Override
        public void run() {
            if(!p.isDead() && localCounter != 0) {
                if(((Damageable) p).getHealth() == ((Damageable) p).getMaxHealth() && StopAtFullHealth) {
                    p.sendMessage(ChatColor.GREEN + "Your wounds have fully recovered.");
                    this.cancel();
                }
                if(((Damageable) p).getHealth() + healBursts <= ((Damageable) p).getMaxHealth())
                    p.setHealth(((Damageable) p).getHealth() + healBursts);
                else
                    p.setHealth(((Damageable) p).getMaxHealth());
            localCounter--;
            } else {
                p.sendMessage(ChatColor.GREEN + "The bandage has recovered some of your wounds.");
                this.cancel();
            }
        }
    }.runTaskTimer(main, 0l, 20l);
}

@Override
public void effect(Event e, ItemStack item, int level) {
    EntityDamageByEntityEvent event = (EntityDamageByEntityEvent) e;
    Player player = (Player) event.getDamager();
    Entity ent = event.getEntity();

    double trueDamage = strength + (level/10); 
    double currentHealth = ((Damageable) ent).getHealth();

    if(currentHealth > trueDamage) {
        ((Damageable) ent).setHealth(currentHealth-trueDamage);
        EffectManager.playSound(player.getLocation(), "ENTITY_ENDERDRAGON_GROWL", 0.1f, 0.1f);
    }


}

@Override
public void effect(Event e, ItemStack item, int level) {
    EntityDamageByEntityEvent event = (EntityDamageByEntityEvent) e;
    Player damager = null;

    if(event.getDamager() instanceof Player)
        damager = (Player) event.getDamager();
    else
        damager = (Player) ((Arrow) event.getDamager()).getShooter();

    if(damager.getGameMode().equals(GameMode.CREATIVE))
        return;

    double newHeal = ((Damageable) damager).getHealth() + heal + level;

    if(newHeal < ((Damageable) damager).getMaxHealth())
        damager.setHealth(newHeal);
    else
        damager.setHealth(((Damageable) damager).getMaxHealth());

    EffectManager.playSound(damager.getLocation(), "ENTITY_EXPERIENCE_ORB_PICKUP", 0.3f, 1f);


}

@Override
public void effect(Event e, ItemStack item, int level) {
    EntityDamageByEntityEvent event = (EntityDamageByEntityEvent) e;
    Player damager = (Player) event.getDamager();
    if (!getHasCooldown(damager)) { 
        double heal = (((Damageable) damager).getHealth() + (event.getDamage() / damageHealFraction));
        if ( heal < ((Damageable) damager).getMaxHealth()) 
            damager.setHealth(heal);
         else 
            damager.setHealth(((Damageable) damager).getMaxHealth());
        int food = (int) (damager.getFoodLevel() + (event.getDamage() / damageHealFraction));
        if ( food < 20) 
            damager.setFoodLevel(food);
         else 
            damager.setFoodLevel(20);
        EffectManager.playSound(damager.getLocation(), "ENTITY_PLAYER_BURP", 0.4f, 1f);
        generateCooldown(damager, cooldown);
    }
}

public static void applyBleed(final Player target, final int bleedDuration) {
    target.sendMessage(ChatColor.RED + "You are Bleeding!");
    target.setMetadata("ce.bleed", new FixedMetadataValue(Main.plugin, null));
    new BukkitRunnable() {

        int seconds = bleedDuration;

        @Override
        public void run() {
            if (seconds >= 0) {
                if (!target.isDead() && target.hasMetadata("ce.bleed")) {
                    target.damage(1 + (((Damageable) target).getHealth() / 15));
                    seconds--;
                } else {
                    target.removeMetadata("ce.bleed", Main.plugin);
                    this.cancel();
                }
            } else {
                target.removeMetadata("ce.bleed", Main.plugin);
                target.sendMessage(ChatColor.GREEN + "You have stopped Bleeding!");
                this.cancel();
            }
        }
    }.runTaskTimer(Main.plugin, 0l, 20l);

}

/**
 * Supports Bukkit earlier than 1.6. TODO: removable?
 */
public static double getMaxHealth(Damageable d) {
    Validate.notNull(d, "Damageable cannot be null");
    try {
        return d.getMaxHealth();
    } catch (NoSuchMethodError ignored) {
        Class<? extends Damageable> dClass = d.getClass();
        try {
            Method healthMethod = dClass.getMethod("getMaxHealth");
            Object obj = healthMethod.invoke(d);
            if (obj instanceof Number) {
                return ((Number) obj).doubleValue();
            } else {
                SkyStatic.getLogger().log(Level.WARNING, "LivingEntity.getHealth returned {0}, which is not a Number!", obj);
            }
        } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) {
            SkyStatic.getLogger().log(Level.WARNING, "Couldn't find / use .getMaxHealth method of LivingEntity!", ex);
        }
        return 10;
    }
}

@EventHandler
public void onProjectileHit(ProjectileHitEvent event) {
    if (event.getEntityType() != EntityType.FISHING_HOOK &&
        event.getEntityType() != EntityType.SNOWBALL &&
        event.getEntityType() != EntityType.EGG) return;
    ProjectileSource shooter = ((Projectile) event.getEntity()).getShooter();
    if (shooter != null && shooter instanceof Player && event.getHitEntity() instanceof Damageable) {
        ((Damageable) event.getHitEntity()).damage(0.01, (Player) shooter);
    }

}

public static int getMaxHealth(Player player) {
    try {
        Method maxHealthMethod = Damageable.class.getMethod("getMaxHealth");
        return ((Number) maxHealthMethod.invoke(player)).intValue();
    } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
        throw new IllegalStateException(e);
    }
}

public static void setHealth(Player player, int maxHealth) {
    Optional<Method> setMaxHealthMethod = Stream.of(Damageable.class.getDeclaredMethods())
            .filter(method -> method.getName().equals("setHealth"))
            .findFirst();
    setMaxHealthMethod.ifPresent(method -> {
        try {
            method.invoke(player, maxHealth);
        } catch (IllegalAccessException | InvocationTargetException e) {
            throw new IllegalStateException(e);
        }
    });
}

public void onMonsterDamaged(EntityDamageEvent event) {

    Monster monster = null;
    for (Monster m : _spawnedMonsters) {
        if (m.getEntityId() == event.getEntity().getEntityId()) {
            monster = m;
            break;
        }
    }



    if (monster != null) {

        if (event.getCause() == DamageCause.FIRE_TICK) {
            event.setCancelled(true);
            event.getEntity().setFireTicks(0);
            // lette, hack, shame on me
            return;
        }

        if (!_blockBroken) {
            Damageable mDamage = (Damageable)monster;

            monster.setHealth(mDamage.getMaxHealth());
            //_logger.info("" + monster.getHealth());   
        }
        else {
            monster.damage(event.getDamage());
            //_logger.info("" + monster.getHealth() + " got damaged!!!");
        }
    }
}

@EventHandler(priority = EventPriority.NORMAL)
public void onMonsterSpawn(CreatureSpawnEvent event) {

    if (event.getSpawnReason() != SpawnReason.CUSTOM && _activated && event.getEntity() instanceof Monster) {

        double modifier = calculateGlobalModifier(event.getLocation());

        if (modifier > 0.0) {

            // boost le health
            Damageable entityDamage = event.getEntity();
            double maxHealth = entityDamage.getMaxHealth() + (int)(modifier * entityDamage.getMaxHealth());
            try {
                EntityReflection.setEntityPropertyValue(event.getEntity(), EntityReflection.HEALTH, maxHealth);
                ScenarioService.getInstance().updateDamageModifier(event.getEntity(), modifier);
            }
            catch (Exception ex) {
                _logger.info("exception on Frontier!");
            }

            // ajuste les rare drops, rien en diamant dans le premier palier
            if (LocationUtil.getDistanceBetween(event.getLocation(), event.getLocation().getWorld().getSpawnLocation()) <= _divider) {
                RareDropsMultiplierData.getInstance().addEntityRareDropsMultiplier(event.getEntity().getEntityId(), new RareDropsMultipliers(0.25, 0.25, 0.00));
            }
            else {
                RareDropsMultiplierData.getInstance().addEntityRareDropsMultiplier(event.getEntity().getEntityId(), new RareDropsMultipliers(modifier, modifier, modifier));
            }
        }
    }
}

public Entity spawnCreature(World w, Location l, EntityType t, double modifier, boolean burn) {
    LivingEntity creature = (LivingEntity)this.spawnCreature(w, l, t);

    // refactoring for v1.6.2
    Damageable damageable = (Damageable)creature;
    int maxHealth = (int)damageable.getMaxHealth() + (int)(modifier * damageable.getMaxHealth());


    EntityReflection.setEntityPropertyValue(creature, EntityReflection.HEALTH, maxHealth);
    _customMonster.updateFireproofMonster(creature, burn);
    _customMonster.updateDamageModifierMonster(creature, modifier);
    return creature;
}

public void purify()
{
    Player player = getPlayer();

    clearInventory();
    player.setHealth(((Damageable) player).getMaxHealth());
    player.setFoodLevel(15);
    player.setSaturation(Float.MAX_VALUE);
    for (PotionEffect pe : player.getActivePotionEffects())
        player.removePotionEffect(pe.getType());
}

@EventHandler(priority = EventPriority.NORMAL,ignoreCancelled = true)  //这就是我说的那个监听器了，事件发生时会触发下面这个方法
public void onBedEnter(final PlayerBedEnterEvent e)  {
    /*new BukkitRunnable(){//保证晚上
            @Override
            public void run(){
                gameworld.setTime(111111);
            };
        }.runTaskTimer(Bukkit.getPluginManager().getPlugin("blockode"), 0L, 200L);*/

    final Damageable playerdg=(Damageable)e.getPlayer();
    if(isInList(e.getPlayer()) && playerdg.getHealth()<playerdg.getMaxHealth()){//回血
        new BukkitRunnable(){
            @Override
            public void run(){
                if(playerdg.getHealth()<playerdg.getMaxHealth()&&e.getPlayer().isSleeping()){
                    e.getPlayer().setHealth(playerdg.getHealth()+6);
                }
                else{
                    //e.getPlayer().teleport(e.getPlayer().getLocation());
                    ((CraftPlayer) e.getPlayer()).getHandle().a(true, false, false);
                    e.getBed().setType(Material.AIR);
                    cancel();
                        };
            }
        }.runTaskTimer(Bukkit.getPluginManager().getPlugin("blockode"), 20L, 20L);
    }
    else{
        return;
    }
}

@EventHandler(priority = EventPriority.NORMAL,ignoreCancelled = true)  //这就是我说的那个监听器了，事件发生时会触发下面这个方法
public void onBedEnter(final PlayerBedEnterEvent e)  {
    /*new BukkitRunnable(){//保证晚上
            @Override
            public void run(){
                gameworld.setTime(111111);
            };
        }.runTaskTimer(Bukkit.getPluginManager().getPlugin("blockode"), 0L, 200L);*/

    final Damageable playerdg=(Damageable)e.getPlayer();
    if(isInList(e.getPlayer()) && playerdg.getHealth()<playerdg.getMaxHealth()){//回血
        new BukkitRunnable(){
            @Override
            public void run(){
                if(playerdg.getHealth()<playerdg.getMaxHealth()&&e.getPlayer().isSleeping()){
                    e.getPlayer().setHealth(playerdg.getHealth()+6);
                }
                else{
                    //e.getPlayer().teleport(e.getPlayer().getLocation());
                    ((CraftPlayer) e.getPlayer()).getHandle().a(true, false, false);
                    e.getBed().setType(Material.AIR);
                    cancel();
                        };
            }
        }.runTaskTimer(Bukkit.getPluginManager().getPlugin("blockode"), 20L, 20L);
    }
    else{
        return;
    }
}

@Override
public LuaValue rawget(LuaValue key) {
    if (key.isstring()) {
        switch (key.checkjstring()) {
            case "health":
                if (entity.getEntity() instanceof Damageable) {
                    return LuaValue.valueOf(((Damageable) entity.getEntity()).getHealth());
                }
                break;
            case "maxHealth":
                if (entity.getEntity() instanceof Damageable) {
                    return LuaValue.valueOf(((Damageable) entity.getEntity()).getMaxHealth());
                }
                break;
            case "name":
                return LuaValue.valueOf(entity.getName());
            case "secondName":
                return LuaValue.valueOf(entity.getSecondName());
            case "invulnerable":
                return LuaValue.valueOf(!entity.isTakingDamage());
            case "nameVisible":
                return LuaValue.valueOf(entity.isNameVisible());
            case "location":
                return ScriptUtil.getLocation(entity.getNpc().getStoredLocation());
            case "worldName":
                return LuaValue.valueOf(entity.getEntity().getWorld().getName());
            case "target":
                return ScriptUtil.getTarget(entity);
            case "bukkitEntity":
                return CoerceJavaToLua.coerce(entity.getEntity());
            case "npc":
                return CoerceJavaToLua.coerce(entity.getNpc());
        }
    }
    return super.rawget(key);
}

@Override
public void rawset(LuaValue key, LuaValue value) {
    if (key.isstring()) {
        switch (key.checkjstring()) {
            case "health":
                if (entity.getEntity() instanceof Damageable) {
                    ((Damageable) entity.getEntity()).setHealth(value.checkdouble());
                }
                break;
            case "maxHealth":
                if (entity.getEntity() instanceof Damageable) {
                    ((Damageable) entity.getEntity()).setMaxHealth(value.checkdouble());
                }
                break;
            case "name":
                entity.setName(ChatColor.translateAlternateColorCodes('&', value.checkjstring()));
                break;
            case "secondName":
                entity.setSecondName(ChatColor.translateAlternateColorCodes('&', value.checkjstring()));
                break;
            case "invulnerable":
                entity.setTakingDamage(!value.checkboolean());
                break;
            case "nameVisible":
                entity.setNameVisible(value.checkboolean());
                break;
            case "target":
                getEntity().getNpc().getNavigator().getLocalParameters().stuckAction(new StuckAction() {

                    @Override
                    public boolean run(NPC npc, Navigator nav) {
                        return true;
                    }
                });
                entity.setTarget(value == LuaValue.NIL ? null : ScriptUtil.getPlayer(value));
                break;
        }
    }
    super.rawset(key, value);
}

private void mockDamagableEntity() {
    //create a mocked, minimal creeper
    entity = mock(Creeper.class);
    assumeTrue(entity instanceof Damageable);
    managedEntity = mock(RpgPlusEntity.class);
    when(managedEntity.getEntity()).thenReturn(entity);
}

@Test
public void testHealthField() {
    mockDamagableEntity();
    setLuaVariable("entity", new EntityWrapper(managedEntity, mock(EntityEventManager.class)));

    //test if getting health works
    when(((Damageable) entity).getHealth()).thenReturn(42.0);
    assertEquals(42, executeLua("return entity.health").checkdouble(), 0);

    //test if setting health works
    executeLua("entity.health = 21");
    verify((Damageable) entity).setHealth(21);
}

@Test
public void testMaximumHealthField() {
    mockDamagableEntity();
    setLuaVariable("entity", new EntityWrapper(managedEntity, mock(EntityEventManager.class)));

    //test if getting maximum health works
    when(((Damageable) entity).getMaxHealth()).thenReturn(42.0);
    assertEquals(42, executeLua("return entity.maxHealth").checkdouble(), 0);

    //test if setting maximum health works
    executeLua("entity.maxHealth = 21");
    verify((Damageable) entity).setMaxHealth(21);
}

public void purify()
{
    Player player = getPlayer();

    clearInventory();
    player.setHealth(((Damageable) player).getMaxHealth());
    player.setFoodLevel(15);
    player.setSaturation(Float.MAX_VALUE);
    for (PotionEffect pe : player.getActivePotionEffects())
        player.removePotionEffect(pe.getType());
}

@Override
protected void execute(Event evt) {
  NPCRegistry registry = CitizensAPI.getNPCRegistry();
  NPC npcH = registry.getById(id.getSingle(evt).intValue());
  Damageable npc = (Damageable) npcH.getEntity();
  npc.setMaxHealth(maxHealth.getSingle(evt).doubleValue());
}

public Knapsack(Player p) {

        this.hunger = p.getFoodLevel();
        this.health = ((Damageable) p).getHealth();
        this.xp = p.getExp();
        this.xpLevel = p.getLevel();
        this.potions = CardboardPotionEffect.boxPotions(p.getActivePotionEffects());
        this.inventory = new Crate(p.getInventory());
        this.armor = new Crate(p.getInventory().getArmorContents());

    }

public void disableDuty(Player p, String group) {

        permission.playerRemoveGroup(p, group + "_duty");
        p.setGameMode(GameMode.SURVIVAL);
        ((Damageable) p).setHealth(20F);
        p.getInventory().clear();
        p.getInventory().setArmorContents(null);
        restoreInv(p.getName());
        restoreLoc(p.getName());
        Database.deleteKey(p.getName());
        p.sendMessage(ChatColor.RED + "Dutymode disabled!");
    }

public Knapsack(Player p) {

        this.hunger = p.getFoodLevel();
        this.health = ((Damageable) p).getHealth();
        this.xp = p.getExp();
        this.xpLevel = p.getLevel();
        this.potions = CardboardPotionEffect.boxPotions(p.getActivePotionEffects());
        this.inventory = new Crate(p.getInventory());
        this.armor = new Crate(p.getInventory().getArmorContents());

    }

public Knapsack(Player p) {

        this.hunger = p.getFoodLevel();
        this.health = ((Damageable) p).getHealth();
        this.xp = p.getExp();
        this.xpLevel = p.getLevel();
        this.potions = CardboardPotionEffect.boxPotions(p.getActivePotionEffects());
        this.inventory = new Crate(p.getInventory());
        this.armor = new Crate(p.getInventory().getArmorContents());

    }

public boolean alter(Entity mob, CreatureType type)
{
    if (pg.config.diffmob != true)
        return true;
    if (type == null)
        return true;

    Damageable mob2 = (Damageable) mob;

    mob2.setMaxHealth(150);
    mob2.setHealth(150);
    return true;
}

@Override
public boolean effect(Event event, Player player) {
    if(event instanceof PlayerInteractEvent) {
            if(((Damageable) player).getHealth() != ((Damageable) player).getMaxHealth()) {
                heal(player);
                return true;
            } else
                player.sendMessage(ChatColor.RED + "You do not have any wounds to apply the bandage to!");
    } else if(event instanceof PlayerInteractEntityEvent || event instanceof EntityDamageByEntityEvent) {
        Player toHeal = null;

        if(event instanceof PlayerInteractEntityEvent) {
            toHeal = ((PlayerInteractEntityEvent) event).getPlayer();
        } else if(event instanceof EntityDamageByEntityEvent) {
            EntityDamageByEntityEvent e = (EntityDamageByEntityEvent) event;
            if(e.getDamager() == player && e.getEntity() instanceof Player) {
                e.setDamage(0);
                toHeal = (Player) e.getEntity();
            }
        }

        if(toHeal != null) {
          if(!toHeal.hasMetadata("ce." + getOriginalName()))
            if(((Damageable) toHeal).getHealth() != ((Damageable) toHeal).getMaxHealth()) {
                heal(toHeal);
                player.sendMessage(ChatColor.GREEN + "You have applied a bandage on " + toHeal.getName() + ".");
                toHeal.sendMessage(ChatColor.GREEN + player.getName() + " has applied a bandage on you.");
                return true;
            } else
                player.sendMessage(ChatColor.RED + "Your target does not have any wounds to apply the bandage to!");
          else
              player.sendMessage(ChatColor.RED + "Your target is already using a bandage!");
        }
    }
    return false;
}

@EventHandler
public void onEntityDamage(EntityDamageEvent event) {
    if (event.getEntityType() == EntityType.HORSE && ((LivingEntity) event.getEntity()).getCustomName() != null && ((LivingEntity) event.getEntity()).getCustomName().equalsIgnoreCase("[HM] Display")) {
        event.setCancelled(true);
    }
    if (event.getEntityType() == EntityType.PLAYER && event.getEntity().getVehicle() != null) {
        Damageable p = (Damageable) event.getEntity();
        if (event.getDamage() >= p.getHealth()) {
            Horse h = (Horse) event.getEntity().getVehicle();
            h.remove();
        }
    }
}

@EventHandler
public void onEntityDamageByEntityEvent(EntityDamageByEntityEvent event) {
    Player killer = null;
    Entity entity = event.getEntity();

    if (entity instanceof Player)
        return;

    if (event.getDamage() < ((Damageable)entity).getHealth())
        return;

    if (!plugin.isMobKillPunishable(entity))
        return;

    // track arrows back to the shooter
    if (event.getDamager() instanceof Projectile) {
        Projectile projectile = (Projectile) event.getDamager();
        ProjectileSource source = (ProjectileSource) projectile.getShooter();
        if (!(source instanceof Player))
            return;
        killer = (Player)source;
    }

    if (event.getDamager() instanceof Player)
        killer = (Player)event.getDamager();

    if (killer != null) {
        if (cancel && (!killer.isOp()))
            event.setCancelled(true);

        plugin.getLogger().info("player " + killer.getName() + " killed a " + entity.getType().name().toString());
        plugin.doTimeout(killer);
    }
}

/**
 * Supports Bukkit earlier than 1.6. TODO: removable?
 */
public static void setHealth(Damageable d, double health) {
    Validate.notNull(d, "Damageable cannot be null");
    try {
        d.setHealth(health);
    } catch (NoSuchMethodError ignored) {
        Class<? extends Damageable> dClass = d.getClass();
        try {
            Method healthMethod = dClass.getMethod("setHealth", Integer.TYPE);
            healthMethod.invoke(d, (int) health);
        } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) {
            SkyStatic.getLogger().log(Level.WARNING, "Couldn't find / use .setHealth method of LivingEntity!", ex);
        }
    }
}