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

public static void walkToPlayer(Entity e, Player p) {
    // Tamed animals already handle their own following
    if (e instanceof Tameable) {
        if (((Tameable) e).isTamed()) {
            return;
        }
    }
    if (e.getPassenger() instanceof Player) {
        return;
    }

    // Moving the dragon is too buggy
    if (e instanceof EnderDragon) {
        return;
    }
    // Once this is set we can't unset it.
    //((Creature)e).setTarget(p);

    // If the pet is too far just teleport instead of attempt navigation
    if (e.getLocation().distance(p.getLocation()) > 20) {
        e.teleport(p);
    } else {
        Navigation n = ((CraftLivingEntity) e).getHandle().getNavigation();
        n.a(p.getLocation().getX(), p.getLocation().getY(), p.getLocation().getZ(), 0.30f);
    }
}

@EventHandler(priority = EventPriority.LOWEST)
public void onWorldChanged(EntityPortalEnterEvent event) {
    if (!(event.getEntity() instanceof Tameable) || !(event.getEntity() instanceof LivingEntity)) {
        return;
    }

    OfflinePlayer player = (OfflinePlayer) ((Tameable) event.getEntity()).getOwner();
    if (!InventoryManager.playerIsLoaded(player)) {
        return;
    }

    PlayerWrapper playerWrapper = InventoryManager.get(player);
    if (event.getEntity() == playerWrapper.getPet()) {
        PetManager.respawnPet(player);
    }
}

@EventHandler
public void onInteractEvent(PlayerInteractEntityEvent e){
    RedProtect.get().logger.debug("RPEntityListener - Is PlayerInteractEntityEvent");
    if (e.isCancelled()) {
           return;
       }
    Player p = e.getPlayer();
    if (p == null){
        return;
    }
    Location l = e.getRightClicked().getLocation();
    Region r = RedProtect.get().rm.getTopRegion(l); 
    Entity et = e.getRightClicked();
    if (r != null && !r.canInteractPassives(p) && (et instanceof Animals || et instanceof Villager || et instanceof Golem)) {
        if (et instanceof Tameable){
            Tameable tam = (Tameable) et;
            if (tam.isTamed() && tam.getOwner() != null && tam.getOwner().getName().equals(p.getName())){
                return;
            }
        }
        e.setCancelled(true);
        RPLang.sendMessage(p, "entitylistener.region.cantinteract");
    }
}

/**
 * Checks if there is an owner confliction in this EggTrackerEntry.
 * @param entry - The EggTrackerEntry to test.
 * @return True if a confliction is present, false if not.
 */
public boolean ownerConfliction(EggTrackerEntry entry) {
    if (entry.getEntity() instanceof Tameable) {
        Tameable tameable = (Tameable) entry.getEntity();

        // Order in the below statements is important. Owner override must be first, otherwise it will never be hit.
        if (tameable.getOwner() != null) {
            if (entry.getPlayer().hasPermission("SimpleEgg.owner-override")) {
                if (entry.getPlayer().hasPermission("SimpleEgg.steal")) {
                    tameable.setOwner(entry.getPlayer());
                }

                return false;
            }
        } else if (entry.getPlayer().hasPermission("SimpleEgg.auto-tame")) {
            tameable.setOwner(entry.getPlayer());
        }

        if (tameable.getOwner() != null && tameable.getOwner() != entry.getPlayer()) {
            return true;
        }
    }

    return false;
}

/**
 * Change the owner of a pet.
 * 
 * @param event
 * @param oldOwner
 * @param newOwner
 */
private void changeOwner(PlayerInteractEntityEvent event, AnimalTamer oldOwner, Player newOwner) {
    if (chargePrice(event.getPlayer(), changeOwnerPrice)) {
        Tameable tameableAnimal = (Tameable) event.getRightClicked();
        // Change owner.
        tameableAnimal.setOwner(newOwner);
        event.getPlayer().sendMessage(plugin.getChatHeader()
                + plugin.getPluginLang().getString("owner-changed", "This pet was given to a new owner!"));
        newOwner.sendMessage(plugin.getChatHeader()
                + plugin.getPluginLang().getString("new-owner", "Player PLAYER gave you ownership of a pet!")
                        .replace("PLAYER", event.getPlayer().getName()));

        // Create new event to allow other plugins to be aware of the ownership change.
        PlayerChangeAnimalOwnershipEvent playerChangeAnimalOwnershipEvent = new PlayerChangeAnimalOwnershipEvent(
                oldOwner, newOwner, tameableAnimal);
        Bukkit.getServer().getPluginManager().callEvent(playerChangeAnimalOwnershipEvent);
    }
}

/**
 * Frees a pet; it will no longer be tamed.
 * 
 * @param event
 * @param oldOwner
 */
private void freePet(PlayerInteractEntityEvent event, AnimalTamer oldOwner) {
    if (chargePrice(event.getPlayer(), freePetPrice)) {
        Tameable tameableAnimal = (Tameable) event.getRightClicked();
        // Free pet.
        tameableAnimal.setTamed(false);
        // Make freed pet stand up.
        if (version >= 12 && tameableAnimal instanceof Sittable) {
            ((Sittable) tameableAnimal).setSitting(false);
        } else if (tameableAnimal instanceof Wolf) {
            ((Wolf) tameableAnimal).setSitting(false);
        } else if (tameableAnimal instanceof Ocelot) {
            ((Ocelot) tameableAnimal).setSitting(false);
        }

        event.getPlayer().sendMessage(plugin.getChatHeader()
                + plugin.getPluginLang().getString("pet-freed", "Say goodbye: this pet returned to the wild!"));

        // Create new event to allow other plugins to be aware of the freeing.
        PlayerChangeAnimalOwnershipEvent playerChangeAnimalOwnershipEvent = new PlayerChangeAnimalOwnershipEvent(
                oldOwner, null, tameableAnimal);
        Bukkit.getServer().getPluginManager().callEvent(playerChangeAnimalOwnershipEvent);
    }
}

@EventHandler(ignoreCancelled = true)
public void onEntityTame(EntityTameEvent event) {
    // Return if the damaged entity is not a tameable entity.
    if (!(event.getEntity() instanceof Tameable))
        return;

    Player player = (Player) event.getOwner();
    Animals animal = (Animals) event.getEntity();
    String name = animal.getType().name().toLowerCase();

    // Don't cancel if the player has the appropriate permission
    if (player.hasPermission("stablemaster.tame." + name))
        return;

    event.setCancelled(true);
    new LangString("error.cannot-tame", getAnimal(animal.getType())).send(player);
}

/**
 * Handle EntityTarget events.
 *
 * @param event The event to process
 */
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onEntityTarget(EntityTargetEvent event) {
    Entity entity = event.getEntity();
    Entity target = event.getTarget();

    if (!(entity instanceof Tameable) || !(target instanceof Player)) {
        return;
    }

    Player player = (Player) target;
    Tameable tameable = (Tameable) entity;

    if (!UserManager.hasPlayerDataKey(player) || !CombatUtils.isFriendlyPet(player, tameable)) {
        return;
    }

    // isFriendlyPet ensures that the Tameable is: Tamed, owned by a player, and the owner is in the same party
    // So we can make some assumptions here, about our casting and our check
    if (!(Permissions.friendlyFire(player) && Permissions.friendlyFire((Player) tameable.getOwner()))) {
        event.setCancelled(true);
    }
}

public static void disownPets(String animalTamer) {
    for (TameableModel wrapper : findByTamer(animalTamer)) {
        if (wrapper.getEntity() == null) continue;
        ((Tameable) wrapper.getEntity()).setOwner(new AnimalTamer() {
            @Override
            public String getName() {
                return "Disowned";
            }

            @Override
            public UUID getUniqueId() {
                return null;
            }
        });
    }
}

void handleEntityInteraction(final PlayerInteractEntityEvent event, final Menu menu) {
    if (!this.module.getState().isEnabled()) { return; }
    if (Utility.getItemInHand(event.getPlayer()).isPresent() || !event.getPlayer().isSneaking()) { return; }
    if (event.getRightClicked().getType().equals(EntityType.PLAYER)) { return; }

    if (!(event.getRightClicked() instanceof Tameable)) { return; }
    final Tameable entity = (Tameable) event.getRightClicked();
    final Player player = event.getPlayer();

    if (entity.getOwner() == null) { return; }
    if (!entity.getOwner().getUniqueId().equals(player.getUniqueId())) { return; }

    menu.addItem(this.ownershipItem.build(), clickEvent -> {
        clickEvent.getPlayer().closeInventory();
        player.playSound(player.getLocation(), Sound.UI_BUTTON_CLICK, 1.0f, 1.75f);
        this.openOwnerTransferWindow(player, entity);
    });
}

@Override
public boolean apply(Entity entity) {
    PreCon.notNull(entity);
    PreCon.isValid(entity instanceof Tameable, "entity meust be an instance of Tameable");

    Tameable tameable = (Tameable)entity;

    tameable.setTamed(_isTamed);

    if (_ownerId != null) {
        Player player = PlayerUtils.getPlayer(_ownerId);
        tameable.setOwner(player);
    }
    else {
        tameable.setOwner(null);
    }

    return true;
}

@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);
    }
}

private Player getLastDamager(LivingEntity entity) {
    if (entity.getLastDamageCause() instanceof EntityDamageByEntityEvent) {
        EntityDamageByEntityEvent edbee = (EntityDamageByEntityEvent) entity
                .getLastDamageCause();
        Entity damagerEntity = edbee.getDamager();
        if (damagerEntity instanceof Player) {
            return (Player) damagerEntity;
        }
        if (damagerEntity instanceof Projectile) {
            if (((Projectile) damagerEntity).getShooter() instanceof Player) {
                return (Player) ((Projectile) damagerEntity).getShooter();
            }
            return null;
        }
        if (damagerEntity instanceof Tameable) {
            if (((Tameable) damagerEntity).getOwner() instanceof Player) {
                return (Player) ((Tameable) damagerEntity).getOwner();
            }
            return null;
        }
    }
    return null;
}

public void update() {
    if (entity != null) {
        //((CraftEntity) entity).getHandle().setEquipment(4, new net.minecraft.server.v1_5_R2.ItemStack(Item.DIAMOND_HELMET));
        //Chat.server(((CraftEntity) entity).getHandle().getEquipment().toString());
        Player owner = Bukkit.getPlayerExact(this.owner);
        if (owner == null)
            return;
        entity.setCustomName(nameColor + name);
        entity.setCustomNameVisible(true);
        if (entity instanceof Tameable) {
            tamed = true;
            ((Tameable) entity).setTamed(true);
            ((Tameable) entity).setOwner(owner);
        }
        if (entity instanceof Ageable && age != null) {
            if (getAge() == Age.BABY)
                ((Ageable) entity).setBaby();
            ((Ageable) entity).setAgeLock(true);
        }
        if (entity instanceof Zombie && age != null) {
            if (getAge() == Age.BABY)
                ((Zombie) entity).setBaby(true);
        }
        if (entity instanceof Sheep && color != null) {
            ((Sheep) entity).setColor(getColor());
        }
    }
}

@Override
protected void onCommand(CommandSender sender, String[] args) {
    sender.sendMessage(ChatColor.GREEN + "Please click on the animal you'd like to rescue.");

    Callbacks.selectEntity((Player) sender, ent -> {
            if (!(ent instanceof Tameable)) {
                sender.sendMessage(ChatColor.RED + "This entity is not tameable.");
                return;
            }

            ((Tameable) ent).setOwner(null);
            sender.sendMessage(ChatColor.GREEN + "Entity has been disowned.");
    });
}

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

    Tameable petEntity = (Tameable) event.getEntity();
    final OfflinePlayer player;
    if (!petEntity.isTamed() || (player = (OfflinePlayer) petEntity.getOwner()) == null || !player.isOnline()) {
        return;
    }

    if (!InventoryManager.playerIsLoaded(player)) {
        return;
    }

    PlayerWrapper playerWrapper = InventoryManager.get(player);
    if (petEntity == playerWrapper.getPet()) {
        Inventory inventory = playerWrapper.getInventory();
        final ItemStack petItem = inventory.getItem(PetManager.getPetSlotId());
        PetType petType = PetManager.getPetFromItem(petItem);

        if (petType != null && petType.isRevival()) {
            PetManager.saveDeathTime(petItem);
            PetManager.saveHealth(petItem, 0);
            inventory.setItem(PetManager.getPetSlotId(), petItem);
            PetManager.startCooldownTimer(player.getPlayer(), petItem);
        } else {
            inventory.setItem(PetManager.getPetSlotId(), null);
        }

        event.getDrops().clear();
        playerWrapper.setPet(null);
    }
}

@EventHandler
public void onTarget(EntityTargetLivingEntityEvent event) {
    if (!(event.getEntity() instanceof Tameable) || !(event.getEntity() instanceof LivingEntity)
            || event.getTarget() == null || !InventoryManager.isAllowedWorld(event.getTarget().getWorld())) {
        return;
    }

    LivingEntity petEntity = (LivingEntity) event.getEntity();
    final OfflinePlayer player = (OfflinePlayer) ((Tameable) petEntity).getOwner();

    if (!InventoryManager.playerIsLoaded(player)) {
        return;
    }

    PlayerWrapper playerWrapper = InventoryManager.get(player);
    if (playerWrapper.hasPet() && petEntity == playerWrapper.getPet()) {
        PetType petType = PetManager.getPetFromEntity(petEntity, player);

        if (petType == null) {
            return;
        }

        if (event.getTarget() != null && event.getTarget().getType() == EntityType.PLAYER) {
            event.setCancelled(!petType.isAttackPlayers());
        } else {
            event.setCancelled(!petType.isAttackMobs());
        }
    }
}

@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onEntityDamage(EntityDamageEvent event)
{
    Entity entity = event.getEntity();
    if(!(entity instanceof Tameable)) return;

    Tameable tameable = (Tameable)entity;
    if(!tameable.isTamed() || tameable.getOwner() == null) return;

    Flag flag = this.GetFlagInstanceAtLocation(entity.getLocation(), null);
    if(flag != null)
    {
        event.setCancelled(true);
    }
}

@Override
public void alarm(Integer key) {
    // kill our summon
    Entity e = getEntity();

    if (e == null) {
        QuestManagerPlugin.logger.warning("Unable to locate and remove "
            + "summon!");
    } else {

        if (entity instanceof Tameable) {
            Tameable me = (Tameable) entity;
            AnimalTamer tamer = me.getOwner();

            if (tamer instanceof Player) {
                QuestPlayer qp = QuestManagerPlugin.questManagerPlugin.getPlayerManager().getPlayer(
                        (Player) tamer);
                if (qp.getOptions().getOption(PlayerOptions.Key.CHAT_PET_DISMISSAL)) {
                    ((Player) tamer).sendMessage(DEATH_MESSAGE);
                }
            }
        }

        e.getLocation().getChunk().load();
        e.remove();

        playDeathEffect(e.getLocation());
    }

    effect.stop();

    QuestManagerPlugin.questManagerPlugin.getSummonManager().unregisterSummon(this);
}

@EventHandler
public void onEntityDeath(EntityDeathEvent e) {
    if (e.getEntity().getUniqueId().equals(entityID)) {
        //is summon entity
        effect.stop();

        if (Alarm.getScheduler().unregister(this)) {
            QuestManagerPlugin.questManagerPlugin.getSummonManager().unregisterSummon(this);

            if (entity instanceof Tameable) {
                Tameable me = (Tameable) entity;
                AnimalTamer tamer = me.getOwner();

                if (tamer instanceof Player) {
                    QuestPlayer qp = QuestManagerPlugin.questManagerPlugin.getPlayerManager().getPlayer(
                            (Player) tamer);
                    if (qp.getOptions().getOption(PlayerOptions.Key.CHAT_PET_DISMISSAL)) {
                        ((Player) tamer).sendMessage(DEATH_MESSAGE);
                    }
                }
            }
        }

        return;
    }

}

@EventHandler(priority = EventPriority.NORMAL)
public void onChunkUnload(ChunkLoadEvent e) {
    if (!RPConfig.getGlobalFlagBool("remove-entities-not-allowed-to-spawn")){
        return;
    }
    Entity[] ents = e.getChunk().getEntities();
    for (Entity ent:ents){
        Region entr = RedProtect.get().rm.getTopRegion(ent.getLocation());
        if (entr != null){
            if (!entr.canSpawnMonsters() && ent instanceof Monster){
                ent.remove();
            }
        } else {
            if (ent instanceof Monster){
                if (!RPConfig.getGlobalFlagBool("spawn-monsters")){
                    ent.remove();
                }                               
            }
            else if (!RPConfig.getGlobalFlagBool("spawn-passives")){
                if (ent instanceof Tameable){
                    return;
                }
                ent.remove();
            } 
        }

    }
}

private void restoreTameable(final Tameable entity) {
    if (this.tamed.tamed) {
        if (this.tamed.owner != null) {
            entity.setTamed(true);
            entity.setOwner(this.tamed.owner);
        }
    }
}

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerInteractEntityEvent(PlayerInteractEntityEvent event) {
    // On Minecraft versions from 1.9 onwards, this event is fired twice, one for each hand. Need additional check.
    if (version >= 9 && event.getHand() != EquipmentSlot.HAND) {
        return;
    }

    if (!(event.getRightClicked() instanceof Tameable) || ((Tameable) event.getRightClicked()).getOwner() == null
            || !plugin.getEnableDisableCommand().isEnabled()) {
        return;
    }

    AnimalTamer currentOwner = ((Tameable) event.getRightClicked()).getOwner();
    // Has the player clicked on one of his own pets?
    boolean isOwner = event.getPlayer().getName().equals(currentOwner.getName());
    // Retrieve new owner from the map and delete corresponding entry.
    Player newOwner = plugin.getSetOwnerCommand().collectPendingSetOwnershipRequest(event.getPlayer());
    // Has the player requested to free one of his pets?
    boolean freePet = plugin.getFreeCommand().collectPendingFreeRequest(event.getPlayer());

    // Cannot change ownership or free pet if not owner and no bypass permission.
    if ((newOwner != null || freePet) && !isOwner && !event.getPlayer().hasPermission("petmaster.admin")) {
        event.getPlayer().sendMessage(plugin.getChatHeader() + plugin.getPluginLang()
                .getString("not-owner", "You do not own this pet!").replace("PLAYER", event.getPlayer().getName()));
        return;
    }

    if (newOwner != null) {
        changeOwner(event, currentOwner, newOwner);
    } else if (freePet) {
        freePet(event, currentOwner);
    } else if ((displayToOwner || !isOwner) && event.getPlayer().hasPermission("petmaster.showowner")) {
        displayHologramAndMessage(event, currentOwner);
    }
}

/**
 * Gets player's tamed wolves
 * @return
 */
public List<Wolf> getWolves() {
    List<Wolf> entities = new ArrayList<Wolf>();
    for (Entity e : player.getNearbyEntities(ATTACK_RANGE, ATTACK_RANGE, ATTACK_RANGE)) {
        if (e instanceof Wolf && e instanceof Tameable) {
            Tameable t = (Tameable) e;
            if (t.isTamed() && t.getOwner() == this.player) {
                entities.add((Wolf) e);
            }
        }
    }
    return entities;
}

public void handleInteract(Stable stable, Player player, Tameable animal) {
    final Animals a = (Animals) animal;
    // Storing location
    new LangString("command.teleport.location-saved").send(player);
    StableMaster.teleportChunk.add(a.getLocation().getChunk());
    StableMaster.commandQueue.put(player, this);
    teleportQueue.put(player, a);
}

public void handleInteract(Stable stable, Player player, Tameable animal) {
    OfflinePlayer newOwner = giveQueue.get(player);
    removeFromQueue(player);

    if (animal instanceof AbstractHorse) {
        AbstractHorse horse = (AbstractHorse) animal;
        Stable newStable = StableMaster.getStable(newOwner);
        stable.removeHorse(horse);
        newStable.addHorse(horse);
    }

    animal.setOwner(newOwner);
    new LangString("command.give.given", getAnimal(((Animals) animal).getType()), newOwner.getName()).send(player);
}

public void handleInteract(Stable stable, Player player, Tameable animal) {
    final AbstractHorse horse = (AbstractHorse) animal;
    StabledHorse stabledHorse = stable.getHorse(horse);
    OfflinePlayer rider = addRiderQueue.get(player);
    removeFromQueue(player);

    if (stabledHorse.isRider(rider)) {
        new LangString("command.addrider.is-rider", rider.getName()).send(player);
    }
    else {
        stabledHorse.addRider(rider);
        new LangString("command.addrider.added", rider.getName(), getAnimal(horse.getType())).send(player);
    }
}

public void handleInteract(Stable stable, Player player, Tameable animal) {
    final AbstractHorse horse = (AbstractHorse) animal;
    StabledHorse stabledHorse = stable.getHorse(horse);
    OfflinePlayer rider = delRiderQueue.get(player);
    removeFromQueue(player);

    if (!stabledHorse.isRider(rider)) {
        new LangString("command.delrider.not-rider", rider.getName()).send(player);
    }
    else {
        stabledHorse.delRider(rider);
        new LangString("command.delrider.removed", rider.getName(), getAnimal(horse.getType())).send(player);
    }
}

public void handleInteract(Stable stable, Player player, Tameable animal) {
    final Animals a = (Animals) animal;
    final ConfigurationSection config = StableMaster.getPlugin().getConfig().getConfigurationSection("command.rename");
    String name = renameQueue.get(player);
    removeFromQueue(player);

    a.setCustomName(name);
    a.setCustomNameVisible(config.getBoolean("name-always-visible"));
    new LangString("command.rename.renamed", getAnimal(a.getType()), name).send(player);
}

public static boolean isTamed(LivingEntity ent) {
    if (ent instanceof Tameable) {
        Tameable t = (Tameable) ent;
        if (t.isTamed()) return true;
    }
    return false;
}

private void restoreTameable(Tameable entity) {
    if (this.tamed.tamed) {
        if (this.tamed.owner != null) {
            entity.setTamed(true);
            entity.setOwner(this.tamed.owner);
        }
    }
}

/**
 * Handle the Beast Lore ability.
 *
 * @param target The entity to examine
 */
public void beastLore(LivingEntity target) {
    Player player = getPlayer();
    Tameable beast = (Tameable) target;

    String message = LocaleLoader.getString("Combat.BeastLore") + " ";

    if (beast.isTamed() && beast.getOwner() != null) {
        message = message.concat(LocaleLoader.getString("Combat.BeastLoreOwner", beast.getOwner().getName()) + " ");
    }

    message = message.concat(LocaleLoader.getString("Combat.BeastLoreHealth", target.getHealth(), target.getMaxHealth()));
    player.sendMessage(message);
}

/**
 * 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"));
}

/**
 * Check to see if the given LivingEntity should be affected by a combat ability.
 *
 * @param player The attacking Player
 * @param entity The defending Entity
 * @return true if the Entity should be damaged, false otherwise.
 */
private static boolean shouldBeAffected(Player player, Entity entity) {
    if (entity instanceof Player) {
        Player defender = (Player) entity;

        if (!defender.getWorld().getPVP() || defender == player || UserManager.getPlayer(defender).getGodMode()) {
            return false;
        }

        if ((PartyManager.inSameParty(player, defender) || PartyManager.areAllies(player, defender)) && !(Permissions.friendlyFire(player) && Permissions.friendlyFire(defender))) {
            return false;
        }

        // Vanished players should not be able to get hit by AoE effects
        if (!player.canSee(defender)) {
            return false;
        }

        // It may seem a bit redundant but we need a check here to prevent bleed from being applied in applyAbilityAoE()
        if (callFakeDamageEvent(player, entity, 1.0) == 0) {
            return false;
        }
    }
    else if (entity instanceof Tameable) {
        if (isFriendlyPet(player, (Tameable) entity)) {
            // isFriendlyPet ensures that the Tameable is: Tamed, owned by a player, and the owner is in the same party
            // So we can make some assumptions here, about our casting and our check
            Player owner = (Player) ((Tameable) entity).getOwner();
            if (!(Permissions.friendlyFire(player) && Permissions.friendlyFire(owner))) {
                return false;
            }
        }
    }

    return true;
}

/**
 * Checks to see if an entity is currently friendly toward a given player.
 *
 * @param attacker The player to check.
 * @param pet The entity to check.
 * @return true if the entity is friendly, false otherwise
 */
public static boolean isFriendlyPet(Player attacker, Tameable pet) {
    if (pet.isTamed()) {
        AnimalTamer tamer = pet.getOwner();

        if (tamer instanceof Player) {
            Player owner = (Player) tamer;

            return (owner == attacker || PartyManager.inSameParty(attacker, owner) || PartyManager.areAllies(attacker, owner));
        }
    }

    return false;
}

public static boolean canParticipate(Entity entity) {
    if (entity instanceof Player) {
        CharacterModel character = CharacterUtil.currentFromPlayer((Player) entity);
        return character != null && !character.getDeity().getFlags().contains(Deity.Flag.NO_BATTLE);
    }
    return entity instanceof Tameable && TameableUtil.fromEntity((LivingEntity) entity) != null && isInBattle(TameableUtil.fromEntity((LivingEntity) entity).getCharacter());
}

@Override
public void setKilled(Entity entity)
{
    super.setKilled(entity);
    Tamer owner = ((Tameable)entity).getOwner();
    if (owner instanceof Player)
    {
        this.owner = new PlayerSection((Player)owner);
    }
}

@EventHandler
public void onEntityDeath(EntityDeathEvent event) {
    LivingEntity entity = event.getEntity();
    Player killer = entity.getKiller();

    // Capitalize first letter of mob type and replace underscores with spaces.
    String entityType = entity.getType().toString().substring(0, 1).toUpperCase() + entity.getType().toString().substring(1).toLowerCase();
    entityType = entityType.replace('_', ' ');

    if (entity instanceof Player || killer == null) {
        return;
    }

    if (entity instanceof Tameable) {
        Tameable tameable = (Tameable) entity;

        if (tameable.getOwner() != null) {
            String owner = tameable.getOwner().getName();

            if (entity.getCustomName() == null) {
                getServer().broadcastMessage(killer.getDisplayName() + " killed " + owner + "'s " + entityType + ".");
            } else {
                getServer().broadcastMessage(killer.getDisplayName() + " killed " + entity.getCustomName() + ", " + owner + "'s " + entityType + ".");
            }

            return;
        }
    }

    if (entity.getCustomName() != null) {
        String message = killer.getDisplayName() + " killed " + entity.getCustomName() + " the " + entityType + ".";

        getServer().broadcastMessage(message);
    }
}

void openOwnerTransferWindow(final Player player, final Tameable entity) {
    try {
        final Menu menu = this.createTransferMenu(player, entity);
        menu.show(player);
    }
    catch (final Exception e) {
        CraftoMessenger.report(this, "Failed to create owner transfer menu for player " + player.getName(), e);
    }
}

Menu createTransferMenu(final Player player, final Tameable entity) {
    final Menu menu = new Menu("Besitzrechte �bertragen");

    final Collection<Player> players = Utility.getOnlinePlayers();
    final Iterator<Player> iterator = players.iterator();

    for (int i = 0; i < 36 && iterator.hasNext(); i++) {
        final Player onlinePlayer = iterator.next();
        if (onlinePlayer.getUniqueId().equals(player.getUniqueId())) { continue; }

        final Optional<CraftoPlayer> onlineCraftoPlayer = CraftoPlayer.getPlayer(onlinePlayer.getUniqueId());
        if (!onlineCraftoPlayer.isPresent()) { continue; }

        final Optional<ItemStack> playerItem = Utility.getPlayerHead(onlinePlayer.getName());
        if (!playerItem.isPresent()) { continue; } // Prob warn staff if this happens?

        Utility.setItemName(playerItem.get(), onlinePlayer.getName());
        Utility.setItemLore(playerItem.get(), "Klicke hier um diesem Spieler",
                "die Besitzrechte deines Tieres zu �bertragen.");

        menu.addItem(playerItem.get(), clickEvent -> {
            player.closeInventory();
            player.playSound(player.getLocation(), Sound.UI_BUTTON_CLICK, 1.0f, 1.75f);
            entity.setOwner(onlinePlayer);

            CraftoMessenger.sendSuccess(player, "Du hast " + onlinePlayer.getName() + " die Besitzrechte deines Tieres �bertragen!");
        });
    }

    return menu;
}