net.minecraft.entity.EntityCreature Java Examples

public static BlockPos findRandomClearArea(EntityCreature entity, int searchRange, int minY, int maxY, int searchAttempts) {
  BlockPos ep = entity.getPosition();
  Vec3d pos = entity.getPositionVector();
  World worldObj = entity.getEntityWorld();
  for (int i = 0; i < searchAttempts; i++) {
    int x = ep.getX() + -searchRange + (worldObj.rand.nextInt(searchRange + 1) * 2);
    int y = minY + worldObj.rand.nextInt(maxY - minY + 1);
    int z = ep.getZ() + -searchRange + (worldObj.rand.nextInt(searchRange + 1) * 2);      
    entity.setPosition(x + 0.5, y, z + 0.5);
    boolean isSpace = SpawnUtil.isSpaceAvailableForSpawn(worldObj, entity, false);
    entity.setPosition(pos.x, pos.y, pos.z);
    if(isSpace) {
      return new BlockPos(x,y,z);
    } 
  }
  return null;
}
 

private static BlockPos moveAboveSolid(BlockPos pos, EntityCreature entity)
{
	if (!entity.world.getBlockState(pos).getMaterial().isSolid())
	{
		return pos;
	}
	else
	{
		BlockPos blockpos;

		for (blockpos = pos.up(); blockpos.getY() < entity.world.getHeight() && entity.world.getBlockState(blockpos).getMaterial().isSolid(); blockpos = blockpos.up())
		{
			;
		}

		return blockpos;
	}
}
 

private static BlockPos moveAboveSolid(BlockPos p_191378_0_, EntityCreature p_191378_1_)
{
	if (!p_191378_1_.world.getBlockState(p_191378_0_).getMaterial().isSolid())
	{
		return p_191378_0_;
	}
	else
	{
		BlockPos blockpos;

		for (blockpos = p_191378_0_.up(); blockpos.getY() < p_191378_1_.world.getHeight() && p_191378_1_.world.getBlockState(blockpos).getMaterial().isSolid(); blockpos = blockpos.up())
		{
			;
		}

		return blockpos;
	}
}
 

public EntityCreature getMastersEnemy(EntityPlayer entityplayer, double d)
{
    double d1 = -1D;
    EntityCreature entitycreature = null;
    List list = worldObj.getEntitiesWithinAABBExcludingEntity(entityplayer, boundingBox.expand(d, 4D, d));
    for (int i = 0; i < list.size(); i++)
    {
        Entity entity = (Entity) list.get(i);
        if (!(entity instanceof EntityCreature) || (entity == this))
        {
            continue;
        }
        EntityCreature entitycreature1 = (EntityCreature) entity;
        if ((entitycreature1 != null) && (entitycreature1.getAttackTarget() == entityplayer)) { return entitycreature1; }
    }

    return entitycreature;
}
 

@Override
  public boolean shouldExecute() {
    int chance = executionChance;
    if (isOnLeaves()) { // if we are already on leaves, don't look for a new perch so often
      chance *= 10;
    } 
//    chance = 5;
    if (entity.getRNG().nextInt(chance) != 0) {
      return false;
    }

    BlockPos targetPos = EntityUtil.findRandomLandingSurface(entity, searchRange, entity.getPosition().getY() + 1, 250, searchAttempts);
    if (targetPos != null) {
      List<EntityCreature> others = entity.getEntityWorld().getEntitiesWithinAABB(entity.getClass(), EntityUtil.getBoundsAround(targetPos, 4));
      if (others != null && others.size() > 1) {
        return false;
      }
      xPosition = targetPos.getX() + 0.5;
      yPosition = targetPos.getY();
      zPosition = targetPos.getZ() + 0.5;
      return true;
    }
    return false;

  }
 

@Override
public boolean attackEntityFrom(DamageSource damagesource, int i)
{

    Entity entity = damagesource.getEntity();
    if ((riddenByEntity != null) && (entity == riddenByEntity)) { return false; }
    if (entity instanceof EntityWolf)
    {
        EntityCreature entitycreature = (EntityCreature) entity;
        entitycreature.setAttackTarget(null);
        return false;
    }
    else
    {
        i = i - (getArmorType() + 2);
        if (i < 0)
        {
            i = 0;
        }
        return super.attackEntityFrom(damagesource, i);
    }
}
 

/**
 * Initializes an entities type on construction to specify what group this
 * entity is in for activation ranges.
 *
 * @param entity
 * @return group id
 */
public static byte initializeEntityActivationType(Entity entity)
{
    Chunk chunk = null;
    // Cauldron start - account for entities that dont extend EntityMob, EntityAmbientCreature, EntityCreature
    if ( entity instanceof EntityMob || entity instanceof EntitySlime || entity.isCreatureType(EnumCreatureType.monster, false)) // Cauldron - account for entities that dont extend EntityMob
    {
        return 1; // Monster
    } else if ( entity instanceof EntityCreature || entity instanceof EntityAmbientCreature || entity.isCreatureType(EnumCreatureType.creature, false) 
             || entity.isCreatureType(EnumCreatureType.waterCreature, false) || entity.isCreatureType(EnumCreatureType.ambient, false))
    {
        return 2; // Animal
    // Cauldron end
    } else
    {
        return 3; // Misc
    }
}
 

@Override
public void applyAttributesModifiersToEntity(EntityLivingBase entityLivingBaseIn, @Nonnull AbstractAttributeMap attributeMapIn, int amplifier) {
	super.applyAttributesModifiersToEntity(entityLivingBaseIn, attributeMapIn, amplifier);

	if (timeScale(entityLivingBaseIn) == 0 && entityLivingBaseIn instanceof EntityCreature) {
		((EntityLiving) entityLivingBaseIn).setNoAI(true);

		if(entityLivingBaseIn instanceof EntityCreeper) {
			((EntityCreeper)entityLivingBaseIn).setCreeperState(-1);
		}
	}

	entityLivingBaseIn.world.playSound(null, entityLivingBaseIn.getPosition(), ModSounds.SLOW_MOTION_IN, SoundCategory.NEUTRAL, 1f, 1);
}
 

public static boolean isSpaceAvailableForSpawn(World worldObj, EntityLiving entity, EntityCreature asCreature, boolean checkEntityCollisions, boolean canSpawnInLiquid) {
  if(asCreature != null && asCreature.getBlockPathWeight(entity.getPosition()) < 0) {
    return false;
  }
  if(checkEntityCollisions && !worldObj.checkNoEntityCollision(entity.getEntityBoundingBox())) {
    return false;
  }
  if(!worldObj.getCollisionBoxes(entity, entity.getEntityBoundingBox()).isEmpty()) {
    return false;
  }    
  if(!canSpawnInLiquid && worldObj.containsAnyLiquid(entity.getEntityBoundingBox())) {
    return false;
  }    
  return true;
}
 

public EntityAIMoveToBlock(EntityCreature creature, double speedIn, int length) {
	destinationBlock = BlockPos.ORIGIN;
	theEntity = creature;
	movementSpeed = speedIn;
	searchLength = length;
	setMutexBits(5);
}
 

public static void MoveCreatureToXYZ(EntityCreature movingEntity, int x, int y, int z, float f)
{
    //PathEntity pathentity = MoCreatures.mc.theWorld.getEntityPathToXYZ(movingEntity, x, y, z, f);
    //pathToEntity = worldObj.getEntityPathToXYZ(this, i, j, k, 10F, true, false, false, true);
    //TODO works?
    PathEntity pathentity = movingEntity.worldObj.getEntityPathToXYZ(movingEntity, x, y, z, f, true, false, false, true);

    if (pathentity != null)
    {
        movingEntity.setPathToEntity(pathentity);

    }

}
 

public void setTarget(LivingEntity target) {
    EntityCreature entity = getHandle();
    if (target == null) {
        entity.entityToAttack = null;
    } else if (target instanceof CraftLivingEntity) {
        entity.entityToAttack = ((CraftLivingEntity) target).getHandle();
        entity.pathToEntity = entity.worldObj.getPathEntityToEntity(entity, entity.entityToAttack, 16.0F, true, false, false, true);
    }
}
 

public static void MoveToWater(EntityCreature entity)
{

    int ai[] = MoCTools.ReturnNearestMaterialCoord(entity, Material.water, Double.valueOf(20D), 2D);
    if (ai[0] > -1000)
    {
        MoCTools.MoveCreatureToXYZ(entity, ai[0], ai[1], ai[2], 24F);

    }
}
 

public EntityAIMoveIntoArea(EntityCreature entity, double speedIn, int radius) {
	this.entity = entity;
	this.movementSpeed = speedIn;
	this.radiusSq = radius * radius;

	this.setMutexBits(1);
}
 

@Override
public void removeAttributesModifiersFromEntity(EntityLivingBase entityLivingBaseIn, @Nonnull AbstractAttributeMap attributeMapIn, int amplifier) {
	super.removeAttributesModifiersFromEntity(entityLivingBaseIn, attributeMapIn, amplifier);
	if (timeScale(entityLivingBaseIn) == 0 && entityLivingBaseIn instanceof EntityCreature) {
		((EntityLiving) entityLivingBaseIn).setNoAI(false);
	}

	entityLivingBaseIn.world.playSound(null, entityLivingBaseIn.getPosition(), ModSounds.SLOW_MOTION_OUT, SoundCategory.NEUTRAL, 1f, 1);
}
 

public EntityAIMountedAttackOnCollide(EntityCreature attacker, double speedTowardsTarget, double speedTowardsTargetMounted, boolean longMemory) {
  this.attacker = attacker;
  this.worldObj = attacker.world;
  this.speedTowardsTarget = speedTowardsTarget;
  this.speedTowardsTargetMounted = speedTowardsTargetMounted;
  this.longMemory = longMemory;
  this.setMutexBits(3);
}
 

@Override
public void handleClientSide(PacketSetMobTarget message, EntityPlayer player){
    Entity mob = player.worldObj.getEntityByID(message.mobId);
    Entity target = player.worldObj.getEntityByID(message.targetId);
    if(mob instanceof EntityCreature) {
        ((EntityCreature)mob).setAttackTarget(target instanceof EntityLivingBase ? (EntityLivingBase)target : null);
    }
}
 

/**
 * Used by PneumaticHelmet
 * @param event
 */
@SubscribeEvent
public void onMobTargetSet(LivingSetAttackTargetEvent event){
    if(event.entity instanceof EntityCreature) {
        if(!event.entity.worldObj.isRemote) {
            NetworkHandler.sendToAllAround(new PacketSetMobTarget((EntityCreature)event.entity, event.target), new NetworkRegistry.TargetPoint(event.entity.worldObj.provider.dimensionId, event.entity.posX, event.entity.posY, event.entity.posZ, TileEntityConstants.PACKET_UPDATE_DISTANCE));
        } else {
            warnPlayerIfNecessary(event);
        }
    }
}
 

public static BlockPos findRandomLandingSurface(EntityCreature entity, int searchRange, int minY, int maxY, int searchAttempts) {
  for (int i = 0; i < searchAttempts; i++) {
    BlockPos res = findRandomLandingSurface(entity, searchRange, minY, maxY);
    if (res != null) {
      return res;
    }
  }
  return null;
}
 

public EntityAINearestAttackableTargetFiltered(EntityCreature creature, Class<T> classTarget, int chance, boolean checkSight, boolean onlyNearby, @Nullable final Predicate<? super T> targetSelector) {
	super(creature, checkSight, onlyNearby);
	this.targetClass = classTarget;
	this.targetChance = chance;
	this.sorter = new EntityAINearestAttackableTarget.Sorter(creature);
	this.setMutexBits(1);

	UUID exclude = creature.getEntityData().getUniqueId("owner");

	this.targetEntitySelector = (Predicate<T>) entity -> (entity != null && !entity.getUniqueID().equals(exclude)) && (targetSelector == null || targetSelector.apply(entity) && (EntitySelectors.NOT_SPECTATING.apply(entity) && EntityAINearestAttackableTargetFiltered.this.isSuitableTarget(entity, false)));
}
 

public EntityAIAttackOnCollideAggressive(EntityCreature attacker, double attackSpeed, boolean longMemory) {
  this.attacker = attacker;
  worldObj = attacker.world;
  speedTowardsTarget = attackSpeed;
  this.longMemory = longMemory;
  setMutexBits(3);
}
 

public EntityAIWanderHex(EntityCreature creatureIn, double speedIn, int chance)
{
	this.entity = creatureIn;
	this.speed = speedIn;
	this.executionChance = chance;
	this.setMutexBits(1);
}
 

public void setTarget(LivingEntity target) {
    EntityCreature entity = getHandle();
    if (target == null) {
        entity.setAttackTarget(null, null, false);
    } else if (target instanceof CraftLivingEntity) {
        entity.setAttackTarget(((CraftLivingEntity) target).getHandle(), null, false);
    }
}
 

public static boolean isOnGround(EntityCreature entity) {
  List<AxisAlignedBB> collides = entity.getEntityWorld().getCollisionBoxes(entity, entity.getEntityBoundingBox().offset(0, -0.1, 0));
  if (collides == null || collides.isEmpty()) {
    return false;
  }
  BlockPos groundPos = entity.getPosition().down();
  IBlockState bs = entity.getEntityWorld().getBlockState(groundPos);
  if (bs.getMaterial().isLiquid()) {
    return false;
  }
  return true;
}
 

public EntityAIAttackOnCollideOwned(IOwnable<? extends EntityCreature, ? extends EntityLivingBase> ownable, Class<? extends Entity> p_i1635_2_, double p_i1635_3_,
    boolean p_i1635_5_, EntityAIFollowOwner followTask) {
  super(ownable.asEntity(), p_i1635_3_, p_i1635_5_);
  this.ownable = ownable;
  this.followTask = followTask;
}
 

public EntityAIFollowOwner(IOwnable<? extends EntityCreature, ? extends EntityLivingBase> owned, double minDist, double maxDist, double followSpeed) {
  this.owned = owned;
  minDistanceSq = minDist * minDist;
  maxDistanceSq = maxDist * maxDist;
  this.followSpeed = followSpeed;
}
 

public static boolean isSpaceAvailableForSpawn(World worldObj, EntityCreature entityCreature, boolean checkEntityCollisions, boolean canSpawnInLiquid) {
  return isSpaceAvailableForSpawn(worldObj, entityCreature, entityCreature, checkEntityCollisions, false);
}
 

public EntityAIFlyingPanic(EntityCreature creature, double speedIn) {
  theEntityCreature = creature;
  speed = speedIn;
  setMutexBits(1);
}
 

public EntityAIAttackOnCollideOwned(IOwnable<? extends EntityCreature, ? extends EntityLivingBase> ownable, double p_i1636_2_, boolean p_i1636_4_,
    EntityAIFollowOwner followTask) {
  super(ownable.asEntity(), p_i1636_2_, p_i1636_4_);
  this.ownable = ownable;
  this.followTask = followTask;
}
 

public EntityAINearestAttackableTargetBounded(EntityCreature creature, Class<T> classTarget, int chance, boolean checkSight, boolean onlyNearby,
    final Predicate<? super T> targetSelector) {
  super(creature, classTarget, chance, checkSight, onlyNearby, targetSelector);
  targetChance = chance;
}