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

public static Horse createHorse(Player p, PlayerDataRPG pd) {
    Horse horse = (Horse) REntities.createLivingEntity(CustomHorse.class, p.getLocation());
    horse.setTamed(true);
    setHorseSpeed(horse, getSpeed(pd.horseSpeed));
    horse.setJumpStrength(getJump(pd.horseJump));
    horse.setColor(getColor(pd));
    horse.setStyle(getStyle(pd));
    horse.setVariant(getVariant(pd));
    horse.getInventory().setSaddle(new ItemStack(Material.SADDLE));
    if (pd.horseArmor != null)
        horse.getInventory().setArmor(new ItemStack(pd.horseArmor));
    if (pd.horseBaby) {
        horse.setBaby();
        horse.setAgeLock(true);
    }
    horse.setCustomName(p.getName() + "'s Horse");
    horse.setCustomNameVisible(true);
    pd.riding = true;
    horse.setPassenger(p);
    horseUUIDs.add(horse.getUniqueId());
    return horse;
}

private void createHorse(Player player, Location spawn) {
    player.teleport(spawn);
    Horse horse = spawn.getWorld().spawn(spawn, Horse.class);
    horse.setJumpStrength(0);

    double speed = this.getAPI().getGameManager().getGameState() == GameState.STARTING ? 0D : 0.7D;

    // TODO Fix this for 1.8
    horse.getAttribute(Attribute.GENERIC_MOVEMENT_SPEED).setBaseValue(speed);

    Bukkit.getScheduler().runTaskLater(getAPI().getPlugin(), () -> {
        horse.addPassenger(player);
        horse.setTamed(true);
        horse.getInventory().setSaddle(new ItemStack(Material.SADDLE));
        horse.setAdult();
        horse.setOwner(player);
    }, 1L);
}

@EventHandler
public void onMountPet(VehicleEnterEvent event) {
    if (event.getEntered().getType() != EntityType.PLAYER || event.getVehicle().getType() != EntityType.HORSE) {
        return;
    }

    Player player = (Player) event.getEntered();
    if (!InventoryManager.playerIsLoaded(player)) {
        return;
    }

    Horse vehicle = (Horse) event.getVehicle();
    if (PetManager.getPetFromEntity(vehicle, player) != null && player != vehicle.getOwner()) {
        PlayerUtils.sendMessage(player, RPGInventory.getLanguage().getMessage("error.mount.owner", vehicle.getOwner().getName()));
        event.setCancelled(true);
    }
}

@EventHandler(priority = EventPriority.LOWEST)
public void onPetInventoryOpened(InventoryOpenEvent event) {
    Player player = (Player) event.getPlayer();
    if (!InventoryManager.playerIsLoaded(player)) {
        return;
    }

    final PlayerWrapper playerWrapper = InventoryManager.get(player);
    if (playerWrapper.hasPet() && event.getInventory().getHolder() == playerWrapper.getPet()) {
        playerWrapper.openInventory();
        event.setCancelled(true);

        new BukkitRunnable() {
            @Override
            public void run() {
                HorseInventory horseInv = ((Horse) playerWrapper.getPet()).getInventory();
                horseInv.setSaddle(new ItemStack(Material.SADDLE));
            }
        }.runTaskLater(RPGInventory.getInstance(), 1);
    }
}

@Override
public void rawset(LuaValue key, LuaValue value) {
    if (key.isstring()) {
        switch (key.checkjstring()) {
            case "style":
                getHorseTrait().setStyle(ScriptUtil.enumValue(value, Horse.Style.class));
                break;
            case "variant":
                getHorseTrait().setVariant(ScriptUtil.enumValue(value, Horse.Variant.class));
                break;
            case "color":
                getHorseTrait().setColor(ScriptUtil.enumValue(value, Horse.Color.class));
                break;
            case "jumpStrength":
                getHorseTrait().setJumpStrength(value.checkdouble());
                break;
            case "domestication":
                getHorseTrait().setDomestication(value.checkint());
                break;
            case "maxDomestication":
                getHorseTrait().setMaxDomestication(value.checkint());
                break;
        }
    }
    super.rawset(key, value);
}

/**
 * Examine an EntityMetadata packet and if it is for a dead horse, modify it to reflect the actual
 * value of the horse's armor.
 * 
 * @param event PacketEvent to examine and potentially modify.
 */
private void handleMetadataPacket(PacketEvent event) {
  Entity entity = event.getPacket().getEntityModifier(event).read(ENTITY_INDEX);
  if (entity != null && entity.getType() == EntityType.HORSE) {
    switch (((Horse) entity).getVariant()) {
      default:
        return;
      case SKELETON_HORSE:
      case UNDEAD_HORSE:
        List<WrappedWatchableObject> watchables =
            event.getPacket().getWatchableCollectionModifier().read(WATCHABLE_INDEX);
        for (WrappedWatchableObject watchable : watchables) {
          if (watchable.getIndex() == ARMOR_INDEX) {
            int armor = getArmorMetadataValue((Horse) entity);
            // if (!watchable.getValue().equals(armor)) {
            watchable.setValue(armor, true);
            // }
            return;
          }
        }
    }
  }
}

@Override
public boolean apply(Entity entity) {
    PreCon.notNull(entity);
    PreCon.isValid(entity instanceof Horse, "org.bukkit.entity.Horse expected.");

    Horse horse = (Horse) entity;

    horse.setColor(_color);
    horse.setVariant(_variant);
    horse.setStyle(_style);
    horse.setMaxDomestication(_maxDomestication);
    horse.setDomestication(_domestication);
    horse.setCarryingChest(_hasChest);
    horse.setJumpStrength(_jumpStrength);
    return true;
}

private boolean racetrackNearby(Horse h)
{

    int range = plugin.getConfig().getInt("RaceLine.NoJumpRange");
    for (int x = -range; x < range; x++)
    {
        for (int y = -range; y < range; y++)
        {
            for (int z = -range; z < range; z++)
            {
                if (EquestrianDash.LapCuboid.contains(h.getLocation().add(x, y, z).getBlock()))
                {
                    return true;
                }
            }
        }
    }

    return false;
}

public static void killallHorses(World w) // RIP in peace D:
{
    List<Horse> toremove = new ArrayList<>();

    for (Entity e : w.getEntities())
    {
        if (e instanceof Horse)
        {
            toremove.add((Horse) e);
        }
    }

    for (Horse h : toremove)
    {
        h.remove();
    }

    EquestrianDash.plugin.getLogger().info("Removed " + toremove.size() + " horse(s).");
}

@Override
public void run()
{
    for(Map.Entry<UUID, Location> entry : players.entrySet())
    {
        Player p = Bukkit.getPlayer(entry.getKey());
        Entity v = p.getVehicle();

        if(v == null || !(v instanceof Horse))
        {
            continue;
        }

        Location loc = entry.getValue();
        Horse h = (Horse) p.getVehicle();
        h.teleport(loc);
        p.teleport(loc);
    }
}

public void disableMovement(final Player p, Horse h)
{
    new BukkitRunnable()
    {
        @Override
        public void run()
        {
            FileConfiguration data = plugin.getGameHandler().getCurrentTrack().getTrackData();

            if (data.getBoolean("NMS.Enabled"))
            {
                setNMSHorseSpeed(h, 0);
            }
            else
            {
                p.addPotionEffect(new PotionEffect(PotionEffectType.SLOW, 999999999, 999999999));
                h.addPotionEffect(new PotionEffect(PotionEffectType.SLOW, 999999999, 999999999));
            }
        }
    }.runTaskLater(plugin, 1);
}

public void respawnPlayer(final Player p)
{
    if (p.getVehicle() != null && p.getVehicle() instanceof Horse)
    {
        Horse h = (Horse) p.getVehicle();
        h.setPassenger(null);
        h.setOwner(null);
        h.remove();
    }

    p.getWorld().playSound(p.getLocation(), Sound.WITHER_SPAWN, 3, 1);
    p.setHealth(p.getMaxHealth());
    Location loc = lastLocation.get(p.getUniqueId());
    p.teleport(loc);

    p.getInventory().clear();
    p.setFireTicks(0);
    plugin.getPropertyHandler().generateHorse(p, loc);
}

public void destroyGarbage()
{
    int i = 0;
    for (Location loc : DespawningIce)
    {
        loc.getBlock().setType(Material.AIR);
        i++;
    }

    plugin.getLogger().info("Destroying " + i + " undeleted Ice Powerup blocks.");

    List<Track> tracks = plugin.getTrackRegistry().getTracks();
    for (Track track : tracks)
    {
        track.getItemBoxes().forEach(ItemBox::despawn);

        Collection<Marker> markers = track.getMarkerHandler().getMarkers().values();

        for (Marker marker : markers)
        {
            marker.setVisualized(false);
        }

        track.getWorld().getEntities().stream().filter(e -> e instanceof EnderCrystal || e instanceof Horse || e.hasMetadata("MarkerLocation") || e.getName().startsWith("§9Marker")).forEach(Entity::remove);
    }
}

@EventHandler
public void onPlayerInteractEntity(PlayerInteractEntityEvent event) {
    if (event.getRightClicked() instanceof Horse) {
        Horse horse = (Horse) event.getRightClicked();
        if (horse.isTamed()) {
            if (horse.getOwner() != event.getPlayer()) {
                event.setCancelled(true);
            }
        }
    }
    if (plugin.isUntaming(event.getPlayer())) {
        if (event.getRightClicked() instanceof Tameable) {
            Tameable tameable = (Tameable) event.getRightClicked();
            if (tameable.getOwner() == event.getPlayer() || event.getPlayer().hasPermission("wayward.travel.untame.any")) {
                tameable.setTamed(false);
                event.getPlayer().sendMessage(plugin.getPrefix() + ChatColor.GREEN + "Your tameable creature was untamed.");
            } else {
                event.getPlayer().sendMessage(plugin.getPrefix() + ChatColor.RED + "That tameable creature is not yours!");
            }
        } else {
            event.getPlayer().sendMessage(plugin.getPrefix() + ChatColor.RED + "That entity is not tameable!");
        }
        plugin.setUntaming(event.getPlayer(), false);
    }
}

@Override
public void applyMountData(Entity npc) {
    super.applyMountData(npc);

    if (!(npc instanceof Horse)) {
        return;
    }

    Horse horse = (Horse) npc;

    if (colour != null) {
        horse.setColor(colour);
    }

    if (style != null) {
        horse.setStyle(style);
    }

    if (variant != null) {
        horse.setVariant(variant);
    }
}

public RainbowHorse(final String deity) {
    super(NAME, deity, REPEAT, DETAILS, null, new Runnable() {
        @Override
        public void run() {
            for (DemigodsTameable horse : DemigodsTameable.findByType(EntityType.HORSE)) {
                if (horse.getCurrentLocation() == null || Zones.inNoDemigodsZone(horse.getCurrentLocation()))
                    return;
                if (horse.getDeity().getName().equals(deity) && horse.getEntity() != null && !horse.getEntity().isDead())
                    ((Horse) horse.getEntity()).setColor(getRandomHorseColor());
            }
        }

        private Horse.Color getRandomHorseColor() {
            return Lists.newArrayList(Horse.Color.values()).get(Randoms.generateIntRange(0, 5));
        }
    });
}

@EventHandler
public void protectHorseInventory(InventoryOpenEvent event){
    if(event.getInventory().getHolder() instanceof Horse){
        Horse h = (Horse)event.getInventory().getHolder();
        Player p = (Player) event.getPlayer();
        String playername = event.getPlayer().getName();
        if(p.isOp() || p.hasPermission("echorse.override")){ //Op & permission check
            return;
        }
        if(!(h.getOwner().getName() == playername)){ //Not the horse owner, cancel event

            event.setCancelled(true);
            p.sendMessage(ChatColor.AQUA + "[ECHorses]" + ChatColor.RED + " You dont have permission to open " + h.getOwner().getName() + "'s horse inventory!");
            return;
        }
        return;
    }
    return; 
}

@EventHandler
public void onDismount(VehicleExitEvent event) {
    if (event.getExited() instanceof Player) {
        Player p = (Player) event.getExited();
        if (plugin.getPD(p) != null)
            plugin.getPD(p).riding = false;
    }
    if (horseUUIDs.contains(event.getVehicle().getUniqueId())) {
        Vehicle v = event.getVehicle();
        RScheduler.schedule(plugin, new Runnable() {
            public void run() {
                if (v != null && v.isValid()) {
                    if (v instanceof Horse) {
                        if (((CraftHorse) v).getHandle() instanceof CustomHorse) {
                            ((CustomHorse) ((CraftHorse) v).getHandle()).rearUp();
                        }
                    }
                }
            }
        }, 10);
        RScheduler.schedule(plugin, new Runnable() {
            public void run() {
                if (v != null && v.isValid()) {
                    RParticles.show(ParticleEffect.CLOUD, v.getLocation().add(0, 1, 0), 10);
                    v.remove();
                }
            }
        }, 35);
    }
}

@Override
public void onGameStart() {
    startLine.iterator().forEachRemaining(block -> {
        block.setType(Material.AIR);
    });
    for(Player player : Bukkit.getOnlinePlayers()) {
        if(!this.getAPI().getGameManager().isAlive(player)) continue;
        if(player.getVehicle() != null) {
            ((Horse) player.getVehicle()).getAttribute(Attribute.GENERIC_MOVEMENT_SPEED).setBaseValue(0.7D);
        }
    }
}

@Override
public void onLoad() {
    add(Horse.Style.NONE, "None", "NO", "N", "X", "Default", "Def", "Blank", "BL");
    add(Horse.Style.WHITE, "White", "WH", "W");
    add(Horse.Style.WHITEFIELD, "White Field", "WF", "F", "WField", "Field");
    add(Horse.Style.WHITE_DOTS, "White Dots", "WD", "WDots");
    add(Horse.Style.BLACK_DOTS, "Black Dots", "BD", "BlackD", "BDots");
}

@Override
public void onLoad() {
    add(Horse.Variant.HORSE, "Horse", "HO", "H", "Default", "Def");
    add(Horse.Variant.DONKEY, "Donkey", "DO", "D");
    add(Horse.Variant.MULE, "Mule", "MU", "M");
    add(Horse.Variant.UNDEAD_HORSE, "Undead Horse", "UH", "U", "Undead", "Zombie", "UHorse");
    add(Horse.Variant.SKELETON_HORSE, "Skeleton Horse", "SH", "S", "Skeleton", "Skeli", "SHorse");
}

@Override
public void onLoad() {
    add(Horse.Color.WHITE, "White", "WH");
    add(Horse.Color.CREAMY, "Creamy", "CR", "Cream", "Buckskin");
    add(Horse.Color.CHESTNUT, "Chestnut", "CH", "CNut", "ChestN", "Roan");
    add(Horse.Color.BROWN, "Brown", "BR", "LBrown", "Bay");
    add(Horse.Color.BLACK, "Black", "BL");
    add(Horse.Color.GRAY, "Gray", "GR");
    add(Horse.Color.DARK_BROWN, "Dark Brown", "DB", "DBrown");
}

@Override
protected boolean init(final @Nullable Class<? extends Horse> c, final @Nullable Horse e) {
    if (e != null) {
        variant = e.getVariant();
        color = e.getColor();
        style = e.getStyle();
    }
    return true;
}

@Override
public void set(final Horse entity) {
    if (variant != null)
        entity.setVariant(variant);
    if (color != null)
        entity.setColor(color);
    if (style != null)
        entity.setStyle(style);
}

@Override
public void onSpawn() {
    Horse horse = (Horse) getNPC().getEntity();
    if (color != null) horse.setColor(color);
    if (variant != null) horse.setVariant(variant);
    if (style != null) horse.setStyle(style);
    if (jumpStrength != null) horse.setJumpStrength(jumpStrength);
    if (domestication != null) horse.setDomestication(domestication);
    if (maxDomestication != null) horse.setMaxDomestication(maxDomestication);
}

@Override
public void load(DataKey key) throws NPCLoadException {
    if (key.keyExists("color")) color = Horse.Color.valueOf(key.getString("color"));
    if (key.keyExists("variant")) variant = Horse.Variant.valueOf(key.getString("variant"));
    if (key.keyExists("style")) style = Horse.Style.valueOf(key.getString("style"));
    if (key.keyExists("jumpStrength")) jumpStrength = key.getDouble("jumpStrength");
    if (key.keyExists("domestication")) domestication = key.getInt("domestication");
    if (key.keyExists("maxDomestication")) maxDomestication = key.getInt("maxDomestication");
}

/**
 * {@inheritDoc}
 */
public HorseMenu(Plot plot, Horse horse) {
    super(plot, horse);

    //color
    ItemStack color = new ItemStack(Material.CONCRETE_POWDER, 1, (short) 1);
    ItemMeta colorMeta = color.getItemMeta();
    colorMeta.setDisplayName(ChatColor.GREEN + "Change the color");
    color.setItemMeta(colorMeta);

    insertItem(color, event -> {
        new HorseColorSelectionMenu(horse).open((Player) event.getWhoClicked());

        event.setCancelled(true);
    }, 0);

    //style
    ItemStack style = new ItemStack(Material.SNOW_BALL);
    ItemMeta styleMeta = style.getItemMeta();
    styleMeta.setDisplayName(ChatColor.GREEN + "Change the style");
    style.setItemMeta(styleMeta);

    insertItem(style, event -> {
        new HorseStyleSelectionMenu(horse).open((Player) event.getWhoClicked());

        event.setCancelled(true);
    }, 1);
}

@Override
public LivingEntity spawnHorse(Location loc, HorseType type, Color color, Style style, boolean tame, boolean chest)
{
    Horse horse = (Horse) loc.getWorld().spawnEntity(loc, type.getEntity());
    horse.setColor(color);
    horse.setStyle(style);
    horse.setTamed(tame);

    if (chest && horse instanceof ChestedHorse)
        ((ChestedHorse) horse).setCarryingChest(true);

    return horse;
}

@Override
public LivingEntity spawnHorse(Location loc, HorseType type, Color color, Style style, boolean tame, boolean chest)
{
    Horse horse = (Horse) loc.getWorld().spawnEntity(loc, EntityType.HORSE);
    horse.setVariant(type.getVariant());
    horse.setColor(color);
    horse.setStyle(style);
    horse.setTamed(tame);
    horse.setCarryingChest(chest);
    return horse;
}

public EntityHorseData(Horse horse) {
    color = horse.getColor();
    variant = horse.getVariant();
    style = horse.getStyle();
    saddle = horse.getInventory().getSaddle();
    armor = horse.getInventory().getArmor();
    domestication = horse.getDomestication();
    maxDomestication = horse.getMaxDomestication();
    jumpStrength = horse.getJumpStrength();
}

@Override
public void apply(Entity entity) {
    if (!(entity instanceof Horse)) return;
    Horse horse = (Horse)entity;

    horse.setColor(color);
    horse.setVariant(variant);
    horse.setStyle(style);
    horse.getInventory().setSaddle(saddle);
    horse.getInventory().setArmor(armor);
    horse.setDomestication(domestication);
    horse.setMaxDomestication(maxDomestication);
    horse.setJumpStrength(jumpStrength);
}

public CommandGetIdentifier(HorseKeep plugin, CommandSender sender, String[] args)
{
    super(plugin, sender, args);

    if (!(sender instanceof Player)) { sender.sendMessage(plugin.lang.get("canOnlyExecByPlayer")); return; }

    Player player = (Player) sender;

    if (!plugin.manager.isOnHorse(player))
    {
        player.sendMessage(this.getPrefix() + ChatColor.GOLD + plugin.lang.get("mustRidingHorse"));
        return;
    }

    Horse horse = (Horse) player.getVehicle();

    if (!plugin.manager.isOwned(horse.getUniqueId()))
    {
        player.sendMessage(this.getPrefix() + ChatColor.GOLD + plugin.lang.get("horseNotProtected"));
        return;
    }

    if (!plugin.manager.isHorseOwner(player.getUniqueId(), horse) && !plugin.perm.has(sender, "horsekeep.admin"))
    {
        player.sendMessage(this.getPrefix() + ChatColor.GOLD + plugin.lang.get("dontOwnThisHorse"));
        return;
    }

    player.sendMessage(this.getPrefix() + plugin.lang.get("getHorseIdentifier").replace("%id", plugin.manager.getHorseIdentifier(horse.getUniqueId())));
}

@EventHandler
public void onEntityClick(PlayerInteractEntityEvent e){
    if(e.getRightClicked() instanceof Horse){

            if(e.getRightClicked().equals(mount.get(e.getPlayer()))){
                RemoteEntity entity = re.get(e.getPlayer());
                entity.setSpeed(0.3d);
                }else{
                    e.getPlayer().sendMessage(prefix + ChatColor.GRAY + "This is not your mount!");
                    e.setCancelled(true);
                }
        }
    }

@EventHandler
public void onDismount(VehicleExitEvent e){
    if(e.getVehicle() instanceof Horse){
        RemoteEntity ent1 = re.get(e.getExited());      
        ent1.setSpeed(0.7d);
    }
}

/**
 * Handle the Call of the Wild ability.
 *
 * @param type The type of entity to summon.
 * @param summonAmount The amount of material needed to summon the entity
 */
private void callOfTheWild(EntityType type, int summonAmount) {
    Player player = getPlayer();

    ItemStack heldItem = player.getItemInHand();
    int heldItemAmount = heldItem.getAmount();

    if (heldItemAmount < summonAmount) {
        player.sendMessage(LocaleLoader.getString("Skills.NeedMore", StringUtils.getPrettyItemString(heldItem.getType())));
        return;
    }

    if (!rangeCheck(type)) {
        return;
    }

    int amount = Config.getInstance().getTamingCOTWAmount(type);

    for (int i = 0; i < amount; i++) {
        LivingEntity entity = (LivingEntity) player.getWorld().spawnEntity(player.getLocation(), type);

        FakeEntityTameEvent event = new FakeEntityTameEvent(entity, player);
        mcMMO.p.getServer().getPluginManager().callEvent(event);

        if (event.isCancelled()) {
            continue;
        }

        entity.setMetadata(mcMMO.entityMetadataKey, mcMMO.metadataValue);
        ((Tameable) entity).setOwner(player);
        entity.setRemoveWhenFarAway(false);

        switch (type) {
            case OCELOT:
                ((Ocelot) entity).setCatType(Ocelot.Type.values()[1 + Misc.getRandom().nextInt(3)]);
                break;

            case WOLF:
                entity.setMaxHealth(20.0);
                entity.setHealth(entity.getMaxHealth());
                break;

            case HORSE:
                Horse horse = (Horse) entity;

                entity.setMaxHealth(15.0 + (Misc.getRandom().nextDouble() * 15));
                entity.setHealth(entity.getMaxHealth());
                horse.setColor(Horse.Color.values()[Misc.getRandom().nextInt(Horse.Color.values().length)]);
                horse.setStyle(Horse.Style.values()[Misc.getRandom().nextInt(Horse.Style.values().length)]);
                horse.setJumpStrength(Math.max(AdvancedConfig.getInstance().getMinHorseJumpStrength(), Math.min(Math.min(Misc.getRandom().nextDouble(), Misc.getRandom().nextDouble()) * 2, AdvancedConfig.getInstance().getMaxHorseJumpStrength())));
                //TODO: setSpeed, once available
                break;

            default:
                break;
        }

        if (Permissions.renamePets(player)) {
            entity.setCustomName(LocaleLoader.getString("Taming.Summon.Name.Format", player.getName(), StringUtils.getPrettyEntityTypeString(type)));
            entity.setCustomNameVisible(true);
        }
    }

    player.setItemInHand(heldItemAmount == summonAmount ? null : new ItemStack(heldItem.getType(), heldItemAmount - summonAmount));
    player.sendMessage(LocaleLoader.getString("Taming.Summon.Complete"));
}

/**
 * Examine an itemstack and determine the probability that a given horse variant will become tamed
 * upon consuming one item.
 * 
 * @param variant The type of Horse
 * @param item The ItemStack that may be edible
 * @return The chance of becoming tamed
 */
public double getFoodChance(Horse.Variant variant, ItemStack item) {
  String node = variant.name().toLowerCase() + "." + item.getType().name().toLowerCase();
  /* Check to see if the food is defined without a data value */
  if (plugin.getConfig().contains(node)) {
    return plugin.getConfig().getDouble(node, 0.0);
  }
  /* Check to see if the food is defined with a data value */
  if (plugin.getConfig().contains(node + ":" + item.getDurability())) {
    return plugin.getConfig().getDouble(node + ":" + item.getDurability(), 0.0);
  }
  return 0.0;
}

/**
 * Examine an itemstack and determine if a specific horse Variant can eat it
 * 
 * @param variant The type of Horse
 * @param item The ItemStack that may be edible
 * @return Whether the Horse can eat the item or not
 */
public boolean isFood(Horse.Variant variant, ItemStack item) {
  String node = variant.name().toLowerCase() + "." + item.getType().name().toLowerCase();
  /* Check to see if the food is defined without a data value */
  if (plugin.getConfig().contains(node) && plugin.getConfig().getDouble(node, 0.0) > 0.0) {
    return true;
  }
  /* Check to see if the food is defined with a data value */
  if (plugin.getConfig().contains(node + ":" + item.getDurability())
      && plugin.getConfig().getDouble(node + ":" + item.getDurability(), 0.0) > 0.0) {
    return true;
  }
  return false;
}

/**
 * Get the metadata integer value for a horse's armor.
 * 
 * @param horse The horse
 * @return The armor value
 */
private int getArmorMetadataValue(Horse horse) {
  if (horse != null && horse.getInventory().getArmor() != null) {
    switch (horse.getInventory().getArmor().getType()) {
      case DIAMOND_BARDING:
        return DIAMOND_BARDING_VALUE;
      case GOLD_BARDING:
        return GOLD_BARDING_VALUE;
      case IRON_BARDING:
        return IRON_BARDING_VALUE;
      default:
    }
  }
  return 0;
}

/**
 * 
 */
public void sendMetadataUpdatePacket(Horse horse) {
  if (hookedProtocolLib) {
    ProtocolManager manager = ProtocolLibrary.getProtocolManager();
    PacketContainer packet = manager.createPacket(PacketType.Play.Server.ENTITY_METADATA);
    packet.getIntegers().write(0, horse.getEntityId());
    List<WrappedWatchableObject> watchables = new ArrayList<WrappedWatchableObject>();
    watchables.add(new WrappedWatchableObject(ARMOR_INDEX, getArmorMetadataValue(horse)));
    packet.getWatchableCollectionModifier().write(WATCHABLE_INDEX, watchables);
    manager.broadcastServerPacket(packet, horse, true);
  }
}

/**
 * Monitor entity damage events for horses taking damage. Modify the damage based on barding.
 * 
 * @param event The damage event
 */
@EventHandler(ignoreCancelled = true)
public void onDeadHorseDamage(EntityDamageEvent event) {
  if (isDeadHorse(event.getEntity())
      && isBarding(((Horse) event.getEntity()).getInventory().getArmor())) {
    Horse horse = (Horse) event.getEntity();
    event.setDamage(event.getDamage() * getBardingModifier(horse.getInventory().getArmor()));
  }
}