org.bukkit.craftbukkit.entity.CraftLivingEntity Maven / Gradle / Ivy

Go to download
package org.bukkit.craftbukkit.entity;

import net.minecraft.server.*;
import org.apache.commons.lang.Validate;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.craftbukkit.CraftServer;
import org.bukkit.craftbukkit.CraftWorld;
import org.bukkit.craftbukkit.inventory.CraftEntityEquipment;
import org.bukkit.craftbukkit.inventory.CraftItemStack;
import org.bukkit.entity.Entity;
import org.bukkit.entity.*;
import org.bukkit.event.player.PlayerTeleportEvent;
import org.bukkit.inventory.EntityEquipment;
import org.bukkit.inventory.ItemStack;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
import org.bukkit.util.BlockIterator;
import org.bukkit.util.NumberConversions;
import org.bukkit.util.Vector;

import java.util.*;

public class CraftLivingEntity extends CraftEntity implements LivingEntity {
  private CraftEntityEquipment equipment;

  public CraftLivingEntity(final CraftServer server, final EntityLiving entity) {
    super(server, entity);

    if (entity instanceof EntityInsentient || entity instanceof EntityArmorStand) {
      equipment = new CraftEntityEquipment(this);
    }
  }

  public double getHealth() {
    return Math.min(Math.max(0, getHandle().getHealth()), getMaxHealth());
  }

  public void setHealth(double health) {
    if ((health < 0) || (health > getMaxHealth())) {
      throw new IllegalArgumentException("Health must be between 0 and " + getMaxHealth());
    }

    if (entity instanceof EntityPlayer && health == 0) {
      ((EntityPlayer) entity).onDeath(DamageSource.GENERIC);
    }

    getHandle().setHealth((float) health);
  }

  public double getMaxHealth() {
    return getHandle().getMaxHealth();
  }

  public void setMaxHealth(double amount) {
    Validate.isTrue(amount > 0, "Max health must be greater than 0");

    getHandle().getAttributeInstance(GenericAttributes.MAX_HEALTH).setValue(amount);

    if (getHealth() > amount) {
      setHealth(amount);
    }
  }

  public void resetMaxHealth() {
    setMaxHealth(getHandle().getMaxHealth());
  }

  public Egg throwEgg() {
    return launchProjectile(Egg.class);
  }

  public Snowball throwSnowball() {
    return launchProjectile(Snowball.class);
  }
  
  @Override
  public EnderPearl throwEnderPearl() {
    return launchProjectile(EnderPearl.class);
  }
  
  @Override
  public void showTo(Player player) {
    player.sendPacket(new PacketPlayOutSpawnEntityLiving(getHandle()));
  }
  
  @Override
  public boolean isSwingInProgress() {
    return getHandle().isSwingInProgress;
  }
  
  @Override
  public void setSwingInProgress(boolean inProgress) {
    getHandle().isSwingInProgress = inProgress;
  }
  
  @Override
  public float getSwingProgress() {
    return getHandle().swingProgress;
  }
  
  @Override
  public void setSwingProgress(float progress) {
    getHandle().swingProgress = progress;
  }
  
  @Override
  public float getLimbSwing() {
    return getHandle().limbSwing;
  }
  
  @Override
  public void setLimbSwing(float limbSwing) {
    getHandle().limbSwing = limbSwing;
  }
  
  @Override
  public net.minecraft.server.EntityLiving getHandler() {
    return (EntityLiving) super.getHandler();
  }
  
  @Override
  public float getLimbSwingAmount() {
    return getHandle().limbSwingAmount;
  }
  
  @Override
  public void setLimbSwingAmount(float amount) {
    getHandle().limbSwingAmount = amount;
  }
  
  @Override
  public float getAttackedAtYaw() {
    return getHandle().attackedAtYaw;
  }
  
  @Override
  public void setAttackedAtYaw(float yaw) {
    getHandle().attackedAtYaw = yaw;
  }
  
  @Override
  public int getArrowHitTicks() {
    return getHandle().arrowHitTimer;
  }
  
  @Override
  public void setArrowHitTicks(int ticks) {
    getHandle().arrowHitTimer = ticks;
  }
  
  @Override
  public int getHurtTicks() {
    return getHandle().hurtTicks;
  }
  
  @Override
  public void setHurtTicks(int ticks) {
    getHandle().hurtTicks = ticks;
  }
  
  @Override
  public int getMaxHurtTicks() {
    return getHandle().maxHurtTime;
  }
  
  @Override
  public void setMaxHurtTicks(int ticks) {
    getHandle().maxHurtTime = ticks;
  }
  
  @Override
  public int getDeathTicks() {
    return getHandle().deathTicks;
  }
  
  @Override
  public void setDeathTicks(int ticks) {
    getHandle().deathTicks = ticks;
  }
  
  @Override
  public float getCameraPitch() {
    return getHandle().cameraPitch;
  }
  
  @Override
  public void setCameraPitch(float pitch) {
    getHandle().cameraPitch = pitch;
  }
  
  @Override
  public float getRenderYawOffset() {
    return getHandle().renderYawOffset;
  }
  
  @Override
  public void setRenderYawOffset(float offset) {
    getHandle().renderYawOffset = offset;
  }
  
  @Override
  public float getRotationYawHead() {
    return getHandle().rotationYawHead;
  }
  
  @Override
  public void setRotationYawHead(float rotation) {
    getHandle().rotationYawHead = rotation;
  }
  
  @Override
  public float getJumpMovementFactor() {
    return getHandle().jumpMovementFactor;
  }
  
  @Override
  public void setJumpMovementFactor(float factor) {
    getHandle().jumpMovementFactor = factor;
  }
  
  @Override
  public boolean getPotionsNeedUpdate() {
    return getHandle().potionsNeedUpdate;
  }
  
  @Override
  public void setPotionsNeedUpdate(boolean needUpdate) {
    getHandle().potionsNeedUpdate = needUpdate;
  }
  
  @Override
  public LivingEntity getLastDamager() {
    return getHandle().lastDamager.getEntityBukkit();
  }
  
  @Override
  public void setLastDamager(LivingEntity damager) {
    getHandle().lastDamager = damager.getHandler();
  }
  
  @Override
  public LivingEntity getLastAttacker() {
    return getHandle().lastAttacker.getEntityBukkit();
  }
  
  @Override
  public void setLastAttacker(LivingEntity entity) {
    getHandle().lastAttacker = entity.getHandler();
  }
  
  @Override
  public int getLastAttackerTicks() {
    return getHandle().lastAttackerTime;
  }
  
  @Override
  public void setLastAttackerTicks(int ticks) {
    getHandle().lastAttackerTime = ticks;
  }
  
  @Override
  public int getHurtTimestamp() {
    return getHandle().getHurtTimestamp();
  }
  
  @Override
  public void setHurtTimestamp(int timestamp) {
    getHandle().hurtTimestamp = timestamp;
  }
  
  @Override
  public int getLastDamageByPlayerTime() {
    return getHandle().lastDamageByPlayerTime;
  }
  
  @Override
  public void getLastDamageByPlayerTime(int time) {
    getHandle().lastDamageByPlayerTime = time;
  }
  
  @Override
  public int getTicksFarFromPlayer() {
    return getHandle().ticksFarFromPlayer;
  }
  
  @Override
  public void setTicksFarFromPlayer(int ticks) {
    getHandle().ticksFarFromPlayer = ticks;
  }
  
  @Override
  public float getGroundSpeedFactor() {
    return getHandle().onGroundSpeedFactor;
  }
  
  @Override
  public void setGroundSpeedFactor(float factor) {
    getHandle().onGroundSpeedFactor = factor;
  }
  
  @Override
  public float getMovedDistance() {
    return getHandle().movedDistance;
  }
  
  @Override
  public void setMovedDistance(float distance) {
    getHandle().movedDistance = distance;
  }
  
  @Override
  public boolean isJumping() {
    return getHandle().isJumping;
  }
  
  @Override
  public float getLandMovementFactor() {
    return getHandle().landMovementFactor;
  }
  
  @Override
  public void setLandMovementFactor(float factor) {
    getHandle().landMovementFactor = factor;
  }
  
  @Override
  public double getSprintSpeed() {
    return getHandle().sprintSpeed;
  }
  
  @Override
  public void setSprintSpeed(double speed) {
    getHandle().setSprintSpeed(speed);
  }
  
  @Override
  public double getKnockbackResistance() {
    return getHandle().getKnockbackResistance();
  }
  
  @Override
  public void setKnockbackResistance(double resistance) {
    getHandle().setKnockbackResistance(resistance);
  }
  
  @Override
  public double getDamageModifier() {
    return getHandle().getDamageModifier();
  }
  
  @Override
  public void setDamageModifier(double modifier) {
    getHandle().setDamageModifier(modifier);
  }
  
  @Override
  public int getJumpTicks() {
    return getHandle().jumpTicks;
  }
  
  @Override
  public void setJumpTicks(int ticks) {
    getHandle().jumpTicks = ticks;
  }
  
  @Override
  public boolean isTickingEffects() {
    return getHandle().isTickingEffects;
  }
  
  @Override
  public void setTickingEffects(boolean tickingEffects) {
    getHandle().isTickingEffects = tickingEffects;
  }
  
  public double getEyeHeight() {
    return getHandle().getHeadHeight();
  }

  public double getEyeHeight(boolean ignoreSneaking) {
    return getEyeHeight();
  }

  private List getLineOfSight(HashSet transparent, int maxDistance, int maxLength) {
    if (maxDistance > 120) {
      maxDistance = 120;
    }
    ArrayList blocks = new ArrayList();
    Iterator itr = new BlockIterator(this, maxDistance);
    while (itr.hasNext()) {
      Block block = itr.next();
      blocks.add(block);
      if (maxLength != 0 && blocks.size() > maxLength) {
        blocks.remove(0);
      }
      int id = block.getTypeId();
      if (transparent == null) {
        if (id != 0) {
          break;
        }
      } else {
        if (!transparent.contains((byte) id)) {
          break;
        }
      }
    }
    return blocks;
  }

  private List getLineOfSight(Set transparent, int maxDistance, int maxLength) {
    if (maxDistance > 120) {
      maxDistance = 120;
    }
    ArrayList blocks = new ArrayList();
    Iterator itr = new BlockIterator(this, maxDistance);
    while (itr.hasNext()) {
      Block block = itr.next();
      blocks.add(block);
      if (maxLength != 0 && blocks.size() > maxLength) {
        blocks.remove(0);
      }
      Material material = block.getType();
      if (transparent == null) {
        if (!material.equals(Material.AIR)) {
          break;
        }
      } else {
        if (!transparent.contains(material)) {
          break;
        }
      }
    }
    return blocks;
  }

  public List getLineOfSight(HashSet transparent, int maxDistance) {
    return getLineOfSight(transparent, maxDistance, 0);
  }

  public List getLineOfSight(Set transparent, int maxDistance) {
    return getLineOfSight(transparent, maxDistance, 0);
  }

  public Block getTargetBlock(HashSet transparent, int maxDistance) {
    List blocks = getLineOfSight(transparent, maxDistance, 1);
    return blocks.get(0);
  }

  public Block getTargetBlock(Set transparent, int maxDistance) {
    List blocks = getLineOfSight(transparent, maxDistance, 1);
    return blocks.get(0);
  }

  public List getLastTwoTargetBlocks(HashSet transparent, int maxDistance) {
    return getLineOfSight(transparent, maxDistance, 2);
  }

  public List getLastTwoTargetBlocks(Set transparent, int maxDistance) {
    return getLineOfSight(transparent, maxDistance, 2);
  }

  @Deprecated
  public Arrow shootArrow() {
    return launchProjectile(Arrow.class);
  }

  public int getRemainingAir() {
    return getHandle().getAirTicks();
  }

  public void setRemainingAir(int ticks) {
    getHandle().setAirTicks(ticks);
  }

  public int getMaximumAir() {
    return getHandle().maxAirTicks;
  }

  public void setMaximumAir(int ticks) {
    getHandle().maxAirTicks = ticks;
  }

  public void damage(double amount) {
    damage(amount, null);
  }

  public void damage(double amount, Entity source) {
    DamageSource reason = DamageSource.GENERIC;

    if (source instanceof HumanEntity) {
      reason = DamageSource.playerAttack(((CraftHumanEntity) source).getHandle());
    } else if (source instanceof LivingEntity) {
      reason = DamageSource.mobAttack(((CraftLivingEntity) source).getHandle());
    }

    entity.damageEntity(reason, (float) amount);
  }

  public Location getEyeLocation() {
    Location loc = getLocation();
    loc.setY(loc.getY() + getEyeHeight());
    return loc;
  }

  public int getMaximumNoDamageTicks() {
    return getHandle().maxNoDamageTicks;
  }

  public void setMaximumNoDamageTicks(int ticks) {
    getHandle().maxNoDamageTicks = ticks;
  }

  public double getLastDamage() {
    return getHandle().lastDamage;
  }

  public void setLastDamage(double damage) {
    getHandle().lastDamage = (float) damage;
  }

  public int getNoDamageTicks() {
    return getHandle().noDamageTicks;
  }

  public void setNoDamageTicks(int ticks) {
    getHandle().noDamageTicks = ticks;
  }

  @Override
  public EntityLiving getHandle() {
    return (EntityLiving) entity;
  }

  public void setHandle(final EntityLiving entity) {
    super.setHandle(entity);
  }

  @Override
  public String toString() {
    return "CraftLivingEntity{" + "id=" + getEntityId() + '}';
  }

  public Player getKiller() {
    return getHandle().killer == null ? null : (Player) getHandle().killer.getBukkitEntity();
  }

  public boolean addPotionEffect(PotionEffect effect) {
    return addPotionEffect(effect, false);
  }

  public boolean addPotionEffect(PotionEffect effect, boolean force) {
    if (hasPotionEffect(effect.getType())) {
      if (!force) {
        return false;
      }
      removePotionEffect(effect.getType());
    }
    getHandle().addEffect(new MobEffect(effect.getType().getId(), effect.getDuration(), effect.getAmplifier(), effect.isAmbient(), effect.hasParticles()));
    return true;
  }

  public boolean addPotionEffects(Collection effects) {
    boolean success = true;
    for (PotionEffect effect : effects) {
      success &= addPotionEffect(effect);
    }
    return success;
  }

  public boolean hasPotionEffect(PotionEffectType type) {
    return getHandle().hasEffect(MobEffectList.byId[type.getId()]);
  }

  public void removePotionEffect(PotionEffectType type) {
    getHandle().removeEffect(type.getId());
  }

  public Collection getActivePotionEffects() {
    List effects = new ArrayList();
    for (Object raw : getHandle().effects.values()) {
      if (!(raw instanceof MobEffect))
        continue;
      MobEffect handle = (MobEffect) raw;
      effects.add(new PotionEffect(PotionEffectType.getById(handle.getEffectId()), handle.getDuration(), handle.getAmplifier(), handle.isAmbient(), handle.isShowParticles()));
    }
    return effects;
  }

  public  T launchProjectile(Class projectile) {
    return launchProjectile(projectile, null);
  }

  @SuppressWarnings("unchecked")
  public  T launchProjectile(Class projectile, Vector velocity) {
    World world = ((CraftWorld) getWorld()).getHandle();
    net.minecraft.server.Entity launch = null;

    if (Snowball.class.isAssignableFrom(projectile)) {
      launch = new EntitySnowball(world, getHandle());
    } else if (Egg.class.isAssignableFrom(projectile)) {
      launch = new EntityEgg(world, getHandle());
    } else if (EnderPearl.class.isAssignableFrom(projectile)) {
      launch = new EntityEnderPearl(world, getHandle());
    } else if (Arrow.class.isAssignableFrom(projectile)) {
      launch = new EntityArrow(world, getHandle(), 1);
    } else if (ThrownPotion.class.isAssignableFrom(projectile)) {
      launch = new EntityPotion(world, getHandle(), CraftItemStack.asNMSCopy(new ItemStack(Material.POTION, 1)));
    } else if (ThrownExpBottle.class.isAssignableFrom(projectile)) {
      launch = new EntityThrownExpBottle(world, getHandle());
    } else if (Fish.class.isAssignableFrom(projectile) && getHandle() instanceof EntityHuman) {
      launch = new EntityFishingHook(world, (EntityHuman) getHandle());
    } else if (Fireball.class.isAssignableFrom(projectile)) {
      Location location = getEyeLocation();
      Vector direction = location.getDirection().multiply(10);

      if (SmallFireball.class.isAssignableFrom(projectile)) {
        launch = new EntitySmallFireball(world, getHandle(), direction.getX(), direction.getY(), direction.getZ());
      } else if (WitherSkull.class.isAssignableFrom(projectile)) {
        launch = new EntityWitherSkull(world, getHandle(), direction.getX(), direction.getY(), direction.getZ());
      } else {
        launch = new EntityLargeFireball(world, getHandle(), direction.getX(), direction.getY(), direction.getZ());
      }

      launch.projectileSource = this;
      launch.setPositionRotation(location.getX(), location.getY(), location.getZ(), location.getYaw(), location.getPitch());
    }

    Validate.notNull(launch, "Projectile not supported");

    if (velocity != null) {
      ((T) launch.getBukkitEntity()).setVelocity(velocity);
    }

    world.addEntity(launch);
    return (T) launch.getBukkitEntity();
  }

  public EntityType getType() {
    return EntityType.UNKNOWN;
  }

  public boolean hasLineOfSight(Entity other) {
    return getHandle().hasLineOfSight(((CraftEntity) other).getHandle());
  }

  public boolean getRemoveWhenFarAway() {
    return getHandle() instanceof EntityInsentient && !((EntityInsentient) getHandle()).persistent;
  }

  public void setRemoveWhenFarAway(boolean remove) {
    if (getHandle() instanceof EntityInsentient) {
      ((EntityInsentient) getHandle()).persistent = !remove;
    }
  }

  public EntityEquipment getEquipment() {
    return equipment;
  }

  public boolean getCanPickupItems() {
    return getHandle() instanceof EntityInsentient && ((EntityInsentient) getHandle()).canPickUpLoot;
  }

  public void setCanPickupItems(boolean pickup) {
    if (getHandle() instanceof EntityInsentient) {
      ((EntityInsentient) getHandle()).canPickUpLoot = pickup;
    }
  }

  @Override
  public boolean teleport(Location location, PlayerTeleportEvent.TeleportCause cause) {
    if (getHealth() == 0) {
      return false;
    }

    return super.teleport(location, cause);
  }

  public boolean isLeashed() {
    if (!(getHandle() instanceof EntityInsentient)) {
      return false;
    }
    return ((EntityInsentient) getHandle()).getLeashHolder() != null;
  }

  public Entity getLeashHolder() throws IllegalStateException {
    if (!isLeashed()) {
      throw new IllegalStateException("Entity not leashed");
    }
    return ((EntityInsentient) getHandle()).getLeashHolder().getBukkitEntity();
  }

  private boolean unleash() {
    if (!isLeashed()) {
      return false;
    }
    ((EntityInsentient) getHandle()).unleash(true, false);
    return true;
  }

  public boolean setLeashHolder(Entity holder) {
    if ((getHandle() instanceof EntityWither) || !(getHandle() instanceof EntityInsentient)) {
      return false;
    }

    if (holder == null) {
      return unleash();
    }

    if (holder.isDead()) {
      return false;
    }

    unleash();
    ((EntityInsentient) getHandle()).setLeashHolder(((CraftEntity) holder).getHandle(), true);
    return true;
  }

  @Deprecated
  public int _INVALID_getLastDamage() {
    return NumberConversions.ceil(getLastDamage());
  }

  @Deprecated
  public void _INVALID_setLastDamage(int damage) {
    setLastDamage(damage);
  }

  @Deprecated
  public void _INVALID_damage(int amount) {
    damage(amount);
  }

  @Deprecated
  public void _INVALID_damage(int amount, Entity source) {
    damage(amount, source);
  }

  @Deprecated
  public int _INVALID_getHealth() {
    return NumberConversions.ceil(getHealth());
  }

  @Deprecated
  public void _INVALID_setHealth(int health) {
    setHealth(health);
  }

  @Deprecated
  public int _INVALID_getMaxHealth() {
    return NumberConversions.ceil(getMaxHealth());
  }

  @Deprecated
  public void _INVALID_setMaxHealth(int health) {
    setMaxHealth(health);
  }
}