public virtual void getEntitiesOfTypeWithinAAAB(Class class1, AxisAlignedBB axisalignedbb, List list)
{
int i = MathHelper.floor_double((axisalignedbb.minY - 2D) / 16D);
int j = MathHelper.floor_double((axisalignedbb.maxY + 2D) / 16D);
if (i < 0)
{
i = 0;
}
if (j >= entities.Length)
{
j = entities.Length - 1;
}
for (int k = i; k <= j; k++)
{
List list1 = entities[k];
for (int l = 0; l < list1.size(); l++)
{
var entity = (Entity)list1.get(l);
if (class1.isAssignableFrom(entity.GetType()) && entity.boundingBox.intersectsWith(axisalignedbb))
{
list.add(entity);
}
}
}
}
public double calculateZOffset(AxisAlignedBB axisalignedbb, double d)
{
if (axisalignedbb.maxX <= minX || axisalignedbb.minX >= maxX)
{
return(d);
}
if (axisalignedbb.maxY <= minY || axisalignedbb.minY >= maxY)
{
return(d);
}
if (d > 0.0D && axisalignedbb.maxZ <= minZ)
{
double d1 = minZ - axisalignedbb.maxZ;
if (d1 < d)
{
d = d1;
}
}
if (d < 0.0D && axisalignedbb.minZ >= maxZ)
{
double d2 = maxZ - axisalignedbb.minZ;
if (d2 > d)
{
d = d2;
}
}
return(d);
}
public virtual void getEntitiesWithinAABBForEntity(Entity entity, AxisAlignedBB axisalignedbb, List list)
{
int i = MathHelper.floor_double((axisalignedbb.minY - 2D) / 16D);
int j = MathHelper.floor_double((axisalignedbb.maxY + 2D) / 16D);
if (i < 0)
{
i = 0;
}
if (j >= entities.Length)
{
j = entities.Length - 1;
}
for (int k = i; k <= j; k++)
{
List list1 = entities[k];
for (int l = 0; l < list1.size(); l++)
{
var entity1 = (Entity)list1.get(l);
if (entity1 != entity && entity1.boundingBox.intersectsWith(axisalignedbb))
{
list.add(entity1);
}
}
}
}
public override AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int i, int j, int k)
{
float f = 0.0625F;
return(AxisAlignedBB.getBoundingBoxFromPool(i + f, j, k + f, (i + 1) - f,
(j + 1) - f, (k + 1) - f));
}
public override void getCollidingBoundingBoxes(World world, int i, int j, int k, AxisAlignedBB axisalignedbb,
ArrayList arraylist)
{
int l = world.getBlockMetadata(i, j, k);
if (l == 0)
{
setBlockBounds(0.0F, 0.0F, 0.0F, 0.5F, 0.5F, 1.0F);
base.getCollidingBoundingBoxes(world, i, j, k, axisalignedbb, arraylist);
setBlockBounds(0.5F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
base.getCollidingBoundingBoxes(world, i, j, k, axisalignedbb, arraylist);
}
else if (l == 1)
{
setBlockBounds(0.0F, 0.0F, 0.0F, 0.5F, 1.0F, 1.0F);
base.getCollidingBoundingBoxes(world, i, j, k, axisalignedbb, arraylist);
setBlockBounds(0.5F, 0.0F, 0.0F, 1.0F, 0.5F, 1.0F);
base.getCollidingBoundingBoxes(world, i, j, k, axisalignedbb, arraylist);
}
else if (l == 2)
{
setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.5F, 0.5F);
base.getCollidingBoundingBoxes(world, i, j, k, axisalignedbb, arraylist);
setBlockBounds(0.0F, 0.0F, 0.5F, 1.0F, 1.0F, 1.0F);
base.getCollidingBoundingBoxes(world, i, j, k, axisalignedbb, arraylist);
}
else if (l == 3)
{
setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 0.5F);
base.getCollidingBoundingBoxes(world, i, j, k, axisalignedbb, arraylist);
setBlockBounds(0.0F, 0.0F, 0.5F, 1.0F, 0.5F, 1.0F);
base.getCollidingBoundingBoxes(world, i, j, k, axisalignedbb, arraylist);
}
setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
}
public void setBB(AxisAlignedBB axisalignedbb)
{
minX = axisalignedbb.minX;
minY = axisalignedbb.minY;
minZ = axisalignedbb.minZ;
maxX = axisalignedbb.maxX;
maxY = axisalignedbb.maxY;
maxZ = axisalignedbb.maxZ;
}
public virtual void getCollidingBoundingBoxes(World world, int i, int j, int k, AxisAlignedBB axisalignedbb,
ArrayList arraylist)
{
AxisAlignedBB axisalignedbb1 = getCollisionBoundingBoxFromPool(world, i, j, k);
if (axisalignedbb1 != null && axisalignedbb.intersectsWith(axisalignedbb1))
{
arraylist.add(axisalignedbb1);
}
}
public override AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int i, int j, int k)
{
int l = world.getBlockMetadata(i, j, k);
float f = 0.0625F;
float f1 = (1 + l * 2) / 16F;
float f2 = 0.5F;
return(AxisAlignedBB.getBoundingBoxFromPool(i + f1, j, k + f, (i + 1) - f,
(j + f2) - f, (k + 1) - f));
}
public bool isOffsetPositionInLiquid(double d, double d1, double d2)
{
AxisAlignedBB axisalignedbb = boundingBox.getOffsetBoundingBox(d, d1, d2);
List list = worldObj.getCollidingBoundingBoxes(this, axisalignedbb);
if (list.size() > 0)
{
return(false);
}
return(!worldObj.getIsAnyLiquid(axisalignedbb));
}
public bool intersectsWith(AxisAlignedBB axisalignedbb)
{
if (axisalignedbb.maxX <= minX || axisalignedbb.minX >= maxX)
{
return(false);
}
if (axisalignedbb.maxY <= minY || axisalignedbb.minY >= maxY)
{
return(false);
}
return(axisalignedbb.maxZ > minZ && axisalignedbb.minZ < maxZ);
}
private bool isCourseTraversable(double d, double d1, double d2, double d3)
{
double d4 = (waypointX - posX) / d3;
double d5 = (waypointY - posY) / d3;
double d6 = (waypointZ - posZ) / d3;
AxisAlignedBB axisalignedbb = boundingBox.copy();
for (int i = 1; i < d3; i++)
{
axisalignedbb.offset(d4, d5, d6);
if (worldObj.getCollidingBoundingBoxes(this, axisalignedbb).size() > 0)
{
return(false);
}
}
return(true);
}
public override void onUpdate()
{
lastTickPosX = posX;
lastTickPosY = posY;
lastTickPosZ = posZ;
base.onUpdate();
if (shake > 0)
{
shake--;
}
if (inGround)
{
int i = worldObj.getBlockId(xTile, yTile, zTile);
if (i != inTile)
{
inGround = false;
motionX *= rand.nextFloat() * 0.2F;
motionY *= rand.nextFloat() * 0.2F;
motionZ *= rand.nextFloat() * 0.2F;
field_20081_ak = 0;
field_20079_al = 0;
}
else
{
field_20081_ak++;
if (field_20081_ak == 1200)
{
setEntityDead();
}
return;
}
}
else
{
field_20079_al++;
}
Vec3D vec3d = Vec3D.createVector(posX, posY, posZ);
Vec3D vec3d1 = Vec3D.createVector(posX + motionX, posY + motionY, posZ + motionZ);
MovingObjectPosition movingobjectposition = worldObj.rayTraceBlocks(vec3d, vec3d1);
vec3d = Vec3D.createVector(posX, posY, posZ);
vec3d1 = Vec3D.createVector(posX + motionX, posY + motionY, posZ + motionZ);
if (movingobjectposition != null)
{
vec3d1 = Vec3D.createVector(movingobjectposition.hitVec.xCoord, movingobjectposition.hitVec.yCoord,
movingobjectposition.hitVec.zCoord);
}
if (!worldObj.singleplayerWorld)
{
Entity entity = null;
List list = worldObj.getEntitiesWithinAABBExcludingEntity(this,
boundingBox.addCoord(motionX, motionY, motionZ)
.expand(1.0D, 1.0D, 1.0D));
double d = 0.0D;
for (int i1 = 0; i1 < list.size(); i1++)
{
var entity1 = (Entity)list.get(i1);
if (!entity1.canBeCollidedWith() || entity1 == field_20083_aj && field_20079_al < 5)
{
continue;
}
float f4 = 0.3F;
AxisAlignedBB axisalignedbb = entity1.boundingBox.expand(f4, f4, f4);
MovingObjectPosition movingobjectposition1 = axisalignedbb.func_706_a(vec3d, vec3d1);
if (movingobjectposition1 == null)
{
continue;
}
double d1 = vec3d.distanceTo(movingobjectposition1.hitVec);
if (d1 < d || d == 0.0D)
{
entity = entity1;
d = d1;
}
}
if (entity != null)
{
movingobjectposition = new MovingObjectPosition(entity);
}
}
if (movingobjectposition != null)
{
if (movingobjectposition.entityHit != null)
{
if (!movingobjectposition.entityHit.attackEntityFrom(field_20083_aj, 0))
{
;
}
}
if (!worldObj.singleplayerWorld && rand.nextInt(8) == 0)
{
byte byte0 = 1;
if (rand.nextInt(32) == 0)
{
byte0 = 4;
}
for (int k = 0; k < byte0; k++)
{
var entitychicken = new EntityChicken(worldObj);
entitychicken.setLocationAndAngles(posX, posY, posZ, rotationYaw, 0.0F);
worldObj.entityJoinedWorld(entitychicken);
}
}
for (int j = 0; j < 8; j++)
{
worldObj.spawnParticle("snowballpoof", posX, posY, posZ, 0.0D, 0.0D, 0.0D);
}
setEntityDead();
}
posX += motionX;
posY += motionY;
posZ += motionZ;
float f = MathHelper.sqrt_double(motionX * motionX + motionZ * motionZ);
rotationYaw = (float)((Math.atan2(motionX, motionZ) * 180D) / 3.1415927410125732D);
for (rotationPitch = (float)((Math.atan2(motionY, f) * 180D) / 3.1415927410125732D);
rotationPitch - prevRotationPitch < -180F;
prevRotationPitch -= 360F)
{
}
for (; rotationPitch - prevRotationPitch >= 180F; prevRotationPitch += 360F)
{
}
for (; rotationYaw - prevRotationYaw < -180F; prevRotationYaw -= 360F)
{
}
for (; rotationYaw - prevRotationYaw >= 180F; prevRotationYaw += 360F)
{
}
rotationPitch = prevRotationPitch + (rotationPitch - prevRotationPitch) * 0.2F;
rotationYaw = prevRotationYaw + (rotationYaw - prevRotationYaw) * 0.2F;
float f1 = 0.99F;
float f2 = 0.03F;
if (handleWaterMovement())
{
for (int l = 0; l < 4; l++)
{
float f3 = 0.25F;
worldObj.spawnParticle("bubble", posX - motionX * f3, posY - motionY * f3,
posZ - motionZ * f3, motionX, motionY, motionZ);
}
f1 = 0.8F;
}
motionX *= f1;
motionY *= f1;
motionZ *= f1;
motionY -= f2;
setPosition(posX, posY, posZ);
}
public override void getCollidingBoundingBoxes(World world, int i, int j, int k, AxisAlignedBB axisalignedbb,
ArrayList arraylist)
{
int l = world.getBlockMetadata(i, j, k);
if (l == 0)
{
setBlockBounds(0.0F, 0.0F, 0.0F, 0.5F, 0.5F, 1.0F);
base.getCollidingBoundingBoxes(world, i, j, k, axisalignedbb, arraylist);
setBlockBounds(0.5F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
base.getCollidingBoundingBoxes(world, i, j, k, axisalignedbb, arraylist);
}
else if (l == 1)
{
setBlockBounds(0.0F, 0.0F, 0.0F, 0.5F, 1.0F, 1.0F);
base.getCollidingBoundingBoxes(world, i, j, k, axisalignedbb, arraylist);
setBlockBounds(0.5F, 0.0F, 0.0F, 1.0F, 0.5F, 1.0F);
base.getCollidingBoundingBoxes(world, i, j, k, axisalignedbb, arraylist);
}
else if (l == 2)
{
setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.5F, 0.5F);
base.getCollidingBoundingBoxes(world, i, j, k, axisalignedbb, arraylist);
setBlockBounds(0.0F, 0.0F, 0.5F, 1.0F, 1.0F, 1.0F);
base.getCollidingBoundingBoxes(world, i, j, k, axisalignedbb, arraylist);
}
else if (l == 3)
{
setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 0.5F);
base.getCollidingBoundingBoxes(world, i, j, k, axisalignedbb, arraylist);
setBlockBounds(0.0F, 0.0F, 0.5F, 1.0F, 0.5F, 1.0F);
base.getCollidingBoundingBoxes(world, i, j, k, axisalignedbb, arraylist);
}
setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
}
public virtual bool handleMaterialAcceleration(AxisAlignedBB axisalignedbb, Material material, Entity entity)
{
int i = MathHelper.floor_double(axisalignedbb.minX);
int j = MathHelper.floor_double(axisalignedbb.maxX + 1.0D);
int k = MathHelper.floor_double(axisalignedbb.minY);
int l = MathHelper.floor_double(axisalignedbb.maxY + 1.0D);
int i1 = MathHelper.floor_double(axisalignedbb.minZ);
int j1 = MathHelper.floor_double(axisalignedbb.maxZ + 1.0D);
if (!checkChunksExist(i, k, i1, j, l, j1))
{
return false;
}
bool flag = false;
Vec3D vec3d = Vec3D.createVector(0.0D, 0.0D, 0.0D);
for (int k1 = i; k1 < j; k1++)
{
for (int l1 = k; l1 < l; l1++)
{
for (int i2 = i1; i2 < j1; i2++)
{
Block block = Block.blocksList[getBlockId(k1, l1, i2)];
if (block == null || block.blockMaterial != material)
{
continue;
}
double d1 = (l1 + 1) - BlockFluids.setFluidHeight(getBlockMetadata(k1, l1, i2));
if (l >= d1)
{
flag = true;
block.velocityToAddToEntity(this, k1, l1, i2, entity, vec3d);
}
}
}
}
if (vec3d.lengthVector() > 0.0D)
{
vec3d = vec3d.normalize();
double d = 0.0040000000000000001D;
entity.motionX += vec3d.xCoord*d;
entity.motionY += vec3d.yCoord*d;
entity.motionZ += vec3d.zCoord*d;
}
return flag;
}
public override void onUpdate()
{
base.onUpdate();
if (field_9177_b > 0)
{
field_9177_b--;
}
if (damageTaken > 0)
{
damageTaken--;
}
prevPosX = posX;
prevPosY = posY;
prevPosZ = posZ;
int i = 5;
double d = 0.0D;
for (int j = 0; j < i; j++)
{
double d4 = (boundingBox.minY + ((boundingBox.maxY - boundingBox.minY) * (j + 0)) / i) -
0.125D;
double d8 = (boundingBox.minY + ((boundingBox.maxY - boundingBox.minY) * (j + 1)) / i) -
0.125D;
AxisAlignedBB axisalignedbb = AxisAlignedBB.getBoundingBoxFromPool(boundingBox.minX, d4,
boundingBox.minZ, boundingBox.maxX,
d8, boundingBox.maxZ);
if (worldObj.isAABBInMaterial(axisalignedbb, Material.water))
{
d += 1.0D / i;
}
}
if (worldObj.singleplayerWorld)
{
if (field_9176_d > 0)
{
double d1 = posX + (field_9174_e - posX) / field_9176_d;
double d5 = posY + (field_9172_f - posY) / field_9176_d;
double d9 = posZ + (field_9175_aj - posZ) / field_9176_d;
double d12;
for (d12 = field_9173_ak - rotationYaw; d12 < -180D; d12 += 360D)
{
}
for (; d12 >= 180D; d12 -= 360D)
{
}
rotationYaw += (float)(d12 / field_9176_d);
rotationPitch += (float)((field_9171_al - rotationPitch) / field_9176_d);
field_9176_d--;
setPosition(d1, d5, d9);
setRotation(rotationYaw, rotationPitch);
}
else
{
double d2 = posX + motionX;
double d6 = posY + motionY;
double d10 = posZ + motionZ;
setPosition(d2, d6, d10);
if (onGround)
{
motionX *= 0.5D;
motionY *= 0.5D;
motionZ *= 0.5D;
}
motionX *= 0.99000000953674316D;
motionY *= 0.94999998807907104D;
motionZ *= 0.99000000953674316D;
}
return;
}
double d3 = d * 2D - 1.0D;
motionY += 0.039999999105930328D * d3;
if (riddenByEntity != null)
{
motionX += riddenByEntity.motionX * 0.20000000000000001D;
motionZ += riddenByEntity.motionZ * 0.20000000000000001D;
}
double d7 = 0.40000000000000002D;
if (motionX < -d7)
{
motionX = -d7;
}
if (motionX > d7)
{
motionX = d7;
}
if (motionZ < -d7)
{
motionZ = -d7;
}
if (motionZ > d7)
{
motionZ = d7;
}
if (onGround)
{
motionX *= 0.5D;
motionY *= 0.5D;
motionZ *= 0.5D;
}
moveEntity(motionX, motionY, motionZ);
double d11 = Math.sqrt(motionX * motionX + motionZ * motionZ);
if (d11 > 0.14999999999999999D)
{
double d13 = Math.cos((rotationYaw * 3.1415926535897931D) / 180D);
double d15 = Math.sin((rotationYaw * 3.1415926535897931D) / 180D);
for (int i1 = 0; i1 < 1.0D + d11 * 60D; i1++)
{
double d18 = rand.nextFloat() * 2.0F - 1.0F;
double d20 = (rand.nextInt(2) * 2 - 1) * 0.69999999999999996D;
if (rand.nextBoolean())
{
double d21 = (posX - d13 * d18 * 0.80000000000000004D) + d15 * d20;
double d23 = posZ - d15 * d18 * 0.80000000000000004D - d13 * d20;
worldObj.spawnParticle("splash", d21, posY - 0.125D, d23, motionX, motionY, motionZ);
}
else
{
double d22 = posX + d13 + d15 * d18 * 0.69999999999999996D;
double d24 = (posZ + d15) - d13 * d18 * 0.69999999999999996D;
worldObj.spawnParticle("splash", d22, posY - 0.125D, d24, motionX, motionY, motionZ);
}
}
}
if (isCollidedHorizontally && d11 > 0.14999999999999999D)
{
if (!worldObj.singleplayerWorld)
{
setEntityDead();
for (int k = 0; k < 3; k++)
{
dropItemWithOffset(Block.planks.blockID, 1, 0.0F);
}
for (int l = 0; l < 2; l++)
{
dropItemWithOffset(Item.stick.shiftedIndex, 1, 0.0F);
}
}
}
else
{
motionX *= 0.99000000953674316D;
motionY *= 0.94999998807907104D;
motionZ *= 0.99000000953674316D;
}
rotationPitch = 0.0F;
double d14 = rotationYaw;
double d16 = prevPosX - posX;
double d17 = prevPosZ - posZ;
if (d16 * d16 + d17 * d17 > 0.001D)
{
d14 = (float)((Math.atan2(d17, d16) * 180D) / 3.1415926535897931D);
}
double d19;
for (d19 = d14 - rotationYaw; d19 >= 180D; d19 -= 360D)
{
}
for (; d19 < -180D; d19 += 360D)
{
}
if (d19 > 20D)
{
d19 = 20D;
}
if (d19 < -20D)
{
d19 = -20D;
}
rotationYaw += (float)(d19);
setRotation(rotationYaw, rotationPitch);
List list = worldObj.getEntitiesWithinAABBExcludingEntity(this,
boundingBox.expand(0.20000000298023224D, 0.0D,
0.20000000298023224D));
if (list != null && list.size() > 0)
{
for (int j1 = 0; j1 < list.size(); j1++)
{
var entity = (Entity)list.get(j1);
if (entity != riddenByEntity && entity.canBePushed() && (entity is EntityBoat))
{
entity.applyEntityCollision(this);
}
}
}
if (riddenByEntity != null && riddenByEntity.isDead)
{
riddenByEntity = null;
}
}
public void setBB(AxisAlignedBB axisalignedbb)
{
minX = axisalignedbb.minX;
minY = axisalignedbb.minY;
minZ = axisalignedbb.minZ;
maxX = axisalignedbb.maxX;
maxY = axisalignedbb.maxY;
maxZ = axisalignedbb.maxZ;
}
public override void getEntitiesOfTypeWithinAAAB(Class class1, AxisAlignedBB axisalignedbb, List list)
{
}
public virtual void getEntitiesOfTypeWithinAAAB(Class class1, AxisAlignedBB axisalignedbb, List list)
{
int i = MathHelper.floor_double((axisalignedbb.minY - 2D)/16D);
int j = MathHelper.floor_double((axisalignedbb.maxY + 2D)/16D);
if (i < 0)
{
i = 0;
}
if (j >= entities.Length)
{
j = entities.Length - 1;
}
for (int k = i; k <= j; k++)
{
List list1 = entities[k];
for (int l = 0; l < list1.size(); l++)
{
var entity = (Entity) list1.get(l);
if (class1.isAssignableFrom(entity.GetType()) && entity.boundingBox.intersectsWith(axisalignedbb))
{
list.add(entity);
}
}
}
}
public virtual bool isBoundingBoxBurning(AxisAlignedBB axisalignedbb)
{
int i = MathHelper.floor_double(axisalignedbb.minX);
int j = MathHelper.floor_double(axisalignedbb.maxX + 1.0D);
int k = MathHelper.floor_double(axisalignedbb.minY);
int l = MathHelper.floor_double(axisalignedbb.maxY + 1.0D);
int i1 = MathHelper.floor_double(axisalignedbb.minZ);
int j1 = MathHelper.floor_double(axisalignedbb.maxZ + 1.0D);
if (checkChunksExist(i, k, i1, j, l, j1))
{
for (int k1 = i; k1 < j; k1++)
{
for (int l1 = k; l1 < l; l1++)
{
for (int i2 = i1; i2 < j1; i2++)
{
int j2 = getBlockId(k1, l1, i2);
if (j2 == Block.fire.blockID || j2 == Block.lavaStill.blockID ||
j2 == Block.lavaMoving.blockID)
{
return true;
}
}
}
}
}
return false;
}
public virtual List getCollidingBoundingBoxes(Entity entity, AxisAlignedBB axisalignedbb)
{
field_9207_I.clear();
int i = MathHelper.floor_double(axisalignedbb.minX);
int j = MathHelper.floor_double(axisalignedbb.maxX + 1.0D);
int k = MathHelper.floor_double(axisalignedbb.minY);
int l = MathHelper.floor_double(axisalignedbb.maxY + 1.0D);
int i1 = MathHelper.floor_double(axisalignedbb.minZ);
int j1 = MathHelper.floor_double(axisalignedbb.maxZ + 1.0D);
for (int k1 = i; k1 < j; k1++)
{
for (int l1 = i1; l1 < j1; l1++)
{
if (!blockExists(k1, 64, l1))
{
continue;
}
for (int i2 = k - 1; i2 < l; i2++)
{
Block block = Block.blocksList[getBlockId(k1, i2, l1)];
if (block != null)
{
block.getCollidingBoundingBoxes(this, k1, i2, l1, axisalignedbb, field_9207_I);
}
}
}
}
double d = 0.25D;
List list = getEntitiesWithinAABBExcludingEntity(entity, axisalignedbb.expand(d, d, d));
for (int j2 = 0; j2 < list.size(); j2++)
{
AxisAlignedBB axisalignedbb1 = ((Entity) list.get(j2)).getBoundingBox();
if (axisalignedbb1 != null && axisalignedbb1.intersectsWith(axisalignedbb))
{
field_9207_I.add(axisalignedbb1);
}
axisalignedbb1 = entity.func_89_d((Entity) list.get(j2));
if (axisalignedbb1 != null && axisalignedbb1.intersectsWith(axisalignedbb))
{
field_9207_I.add(axisalignedbb1);
}
}
return field_9207_I;
}
public virtual List getEntitiesWithinAABBExcludingEntity(Entity entity, AxisAlignedBB axisalignedbb)
{
field_778_L.clear();
int i = MathHelper.floor_double((axisalignedbb.minX - 2D)/16D);
int j = MathHelper.floor_double((axisalignedbb.maxX + 2D)/16D);
int k = MathHelper.floor_double((axisalignedbb.minZ - 2D)/16D);
int l = MathHelper.floor_double((axisalignedbb.maxZ + 2D)/16D);
for (int i1 = i; i1 <= j; i1++)
{
for (int j1 = k; j1 <= l; j1++)
{
if (chunkExists(i1, j1))
{
getChunkFromChunkCoords(i1, j1).getEntitiesWithinAABBForEntity(entity, axisalignedbb,
field_778_L);
}
}
}
return field_778_L;
}
public virtual float func_494_a(Vec3D vec3d, AxisAlignedBB axisalignedbb)
{
double d = 1.0D/((axisalignedbb.maxX - axisalignedbb.minX)*2D + 1.0D);
double d1 = 1.0D/((axisalignedbb.maxY - axisalignedbb.minY)*2D + 1.0D);
double d2 = 1.0D/((axisalignedbb.maxZ - axisalignedbb.minZ)*2D + 1.0D);
int i = 0;
int j = 0;
for (float f = 0.0F; f <= 1.0F; f = (float) (f + d))
{
for (float f1 = 0.0F; f1 <= 1.0F; f1 = (float) (f1 + d1))
{
for (float f2 = 0.0F; f2 <= 1.0F; f2 = (float) (f2 + d2))
{
double d3 = axisalignedbb.minX + (axisalignedbb.maxX - axisalignedbb.minX)*f;
double d4 = axisalignedbb.minY + (axisalignedbb.maxY - axisalignedbb.minY)*f1;
double d5 = axisalignedbb.minZ + (axisalignedbb.maxZ - axisalignedbb.minZ)*f2;
if (rayTraceBlocks(Vec3D.createVector(d3, d4, d5), vec3d) == null)
{
i++;
}
j++;
}
}
}
return i/(float) j;
}
public bool checkIfAABBIsClear(AxisAlignedBB axisalignedbb)
{
List list = getEntitiesWithinAABBExcludingEntity(null, axisalignedbb);
for (int i = 0; i < list.size(); i++)
{
var entity = (Entity) list.get(i);
if (!entity.isDead && entity.preventEntitySpawning)
{
return false;
}
}
return true;
}
public virtual bool isMaterialInBB(AxisAlignedBB axisalignedbb, Material material)
{
int i = MathHelper.floor_double(axisalignedbb.minX);
int j = MathHelper.floor_double(axisalignedbb.maxX + 1.0D);
int k = MathHelper.floor_double(axisalignedbb.minY);
int l = MathHelper.floor_double(axisalignedbb.maxY + 1.0D);
int i1 = MathHelper.floor_double(axisalignedbb.minZ);
int j1 = MathHelper.floor_double(axisalignedbb.maxZ + 1.0D);
for (int k1 = i; k1 < j; k1++)
{
for (int l1 = k; l1 < l; l1++)
{
for (int i2 = i1; i2 < j1; i2++)
{
Block block = Block.blocksList[getBlockId(k1, l1, i2)];
if (block != null && block.blockMaterial == material)
{
return true;
}
}
}
}
return false;
}
public virtual void getEntitiesWithinAABBForEntity(Entity entity, AxisAlignedBB axisalignedbb, List list)
{
int i = MathHelper.floor_double((axisalignedbb.minY - 2D)/16D);
int j = MathHelper.floor_double((axisalignedbb.maxY + 2D)/16D);
if (i < 0)
{
i = 0;
}
if (j >= entities.Length)
{
j = entities.Length - 1;
}
for (int k = i; k <= j; k++)
{
List list1 = entities[k];
for (int l = 0; l < list1.size(); l++)
{
var entity1 = (Entity) list1.get(l);
if (entity1 != entity && entity1.boundingBox.intersectsWith(axisalignedbb))
{
list.add(entity1);
}
}
}
}
private void setStateIfMobInteractsWithPlate(World world, int i, int j, int k)
{
bool flag = world.getBlockMetadata(i, j, k) == 1;
bool flag1 = false;
float f = 0.125F;
List list = null;
if (triggerMobType == EnumMobType.everything)
{
list = world.getEntitiesWithinAABBExcludingEntity(null,
AxisAlignedBB.getBoundingBoxFromPool(i + f, j,
k + f,
(i + 1) -
f,
j +
0.25D,
(k + 1) -
f));
}
if (triggerMobType == EnumMobType.mobs)
{
list = world.getEntitiesWithinAABB(typeof(EntityLiving),
AxisAlignedBB.getBoundingBoxFromPool(i + f, j, k + f,
(i + 1) - f,
j + 0.25D,
(k + 1) - f));
}
if (triggerMobType == EnumMobType.players)
{
list = world.getEntitiesWithinAABB(typeof(EntityPlayer),
AxisAlignedBB.getBoundingBoxFromPool(i + f, j, k + f,
(i + 1) - f,
j + 0.25D,
(k + 1) - f));
}
if (list.size() > 0)
{
flag1 = true;
}
if (flag1 && !flag)
{
world.setBlockMetadataWithNotify(i, j, k, 1);
world.notifyBlocksOfNeighborChange(i, j, k, blockID);
world.notifyBlocksOfNeighborChange(i, j - 1, k, blockID);
world.markBlocksDirty(i, j, k, i, j, k);
world.playSoundEffect(i + 0.5D, j + 0.10000000000000001D, k + 0.5D,
"random.click", 0.3F, 0.6F);
}
if (!flag1 && flag)
{
world.setBlockMetadataWithNotify(i, j, k, 0);
world.notifyBlocksOfNeighborChange(i, j, k, blockID);
world.notifyBlocksOfNeighborChange(i, j - 1, k, blockID);
world.markBlocksDirty(i, j, k, i, j, k);
world.playSoundEffect(i + 0.5D, j + 0.10000000000000001D, k + 0.5D,
"random.click", 0.3F, 0.5F);
}
if (flag1)
{
world.func_22074_c(i, j, k, blockID, tickRate());
}
}
public override void onUpdate()
{
base.onUpdate();
if (field_6149_an > 0)
{
double d = posX + (field_6148_ao - posX) / field_6149_an;
double d1 = posY + (field_6147_ap - posY) / field_6149_an;
double d2 = posZ + (field_6146_aq - posZ) / field_6149_an;
double d4;
for (d4 = field_6145_ar - rotationYaw; d4 < -180D; d4 += 360D)
{
}
for (; d4 >= 180D; d4 -= 360D)
{
}
rotationYaw += (float)(d4 / field_6149_an);
rotationPitch += (float)((field_6144_as - rotationPitch) / field_6149_an);
field_6149_an--;
setPosition(d, d1, d2);
setRotation(rotationYaw, rotationPitch);
return;
}
if (!worldObj.singleplayerWorld)
{
ItemStack itemstack = angler.getCurrentEquippedItem();
if (angler.isDead || !angler.isEntityAlive() || itemstack == null ||
itemstack.getItem() != Item.fishingRod || getDistanceSqToEntity(angler) > 1024D)
{
setEntityDead();
angler.fishEntity = null;
return;
}
if (bobber != null)
{
if (bobber.isDead)
{
bobber = null;
}
else
{
posX = bobber.posX;
posY = bobber.boundingBox.minY + bobber.height * 0.80000000000000004D;
posZ = bobber.posZ;
return;
}
}
}
if (shake > 0)
{
shake--;
}
if (inGround)
{
int i = worldObj.getBlockId(xTile, yTile, zTile);
if (i != inTile)
{
inGround = false;
motionX *= rand.nextFloat() * 0.2F;
motionY *= rand.nextFloat() * 0.2F;
motionZ *= rand.nextFloat() * 0.2F;
ticksInGround = 0;
ticksInAir = 0;
}
else
{
ticksInGround++;
if (ticksInGround == 1200)
{
setEntityDead();
}
return;
}
}
else
{
ticksInAir++;
}
Vec3D vec3d = Vec3D.createVector(posX, posY, posZ);
Vec3D vec3d1 = Vec3D.createVector(posX + motionX, posY + motionY, posZ + motionZ);
MovingObjectPosition movingobjectposition = worldObj.rayTraceBlocks(vec3d, vec3d1);
vec3d = Vec3D.createVector(posX, posY, posZ);
vec3d1 = Vec3D.createVector(posX + motionX, posY + motionY, posZ + motionZ);
if (movingobjectposition != null)
{
vec3d1 = Vec3D.createVector(movingobjectposition.hitVec.xCoord, movingobjectposition.hitVec.yCoord,
movingobjectposition.hitVec.zCoord);
}
Entity entity = null;
List list = worldObj.getEntitiesWithinAABBExcludingEntity(this,
boundingBox.addCoord(motionX, motionY, motionZ).
expand(1.0D, 1.0D, 1.0D));
double d3 = 0.0D;
for (int j = 0; j < list.size(); j++)
{
var entity1 = (Entity)list.get(j);
if (!entity1.canBeCollidedWith() || entity1 == angler && ticksInAir < 5)
{
continue;
}
float f2 = 0.3F;
AxisAlignedBB axisalignedbb = entity1.boundingBox.expand(f2, f2, f2);
MovingObjectPosition movingobjectposition1 = axisalignedbb.func_706_a(vec3d, vec3d1);
if (movingobjectposition1 == null)
{
continue;
}
double d6 = vec3d.distanceTo(movingobjectposition1.hitVec);
if (d6 < d3 || d3 == 0.0D)
{
entity = entity1;
d3 = d6;
}
}
if (entity != null)
{
movingobjectposition = new MovingObjectPosition(entity);
}
if (movingobjectposition != null)
{
if (movingobjectposition.entityHit != null)
{
if (movingobjectposition.entityHit.attackEntityFrom(angler, 0))
{
bobber = movingobjectposition.entityHit;
}
}
else
{
inGround = true;
}
}
if (inGround)
{
return;
}
moveEntity(motionX, motionY, motionZ);
float f = MathHelper.sqrt_double(motionX * motionX + motionZ * motionZ);
rotationYaw = (float)((Math.atan2(motionX, motionZ) * 180D) / 3.1415927410125732D);
for (rotationPitch = (float)((Math.atan2(motionY, f) * 180D) / 3.1415927410125732D);
rotationPitch - prevRotationPitch < -180F;
prevRotationPitch -= 360F)
{
}
for (; rotationPitch - prevRotationPitch >= 180F; prevRotationPitch += 360F)
{
}
for (; rotationYaw - prevRotationYaw < -180F; prevRotationYaw -= 360F)
{
}
for (; rotationYaw - prevRotationYaw >= 180F; prevRotationYaw += 360F)
{
}
rotationPitch = prevRotationPitch + (rotationPitch - prevRotationPitch) * 0.2F;
rotationYaw = prevRotationYaw + (rotationYaw - prevRotationYaw) * 0.2F;
float f1 = 0.92F;
if (onGround || isCollidedHorizontally)
{
f1 = 0.5F;
}
int k = 5;
double d5 = 0.0D;
for (int l = 0; l < k; l++)
{
double d8 = ((boundingBox.minY + ((boundingBox.maxY - boundingBox.minY) * (l + 0)) / k) -
0.125D) + 0.125D;
double d9 = ((boundingBox.minY + ((boundingBox.maxY - boundingBox.minY) * (l + 1)) / k) -
0.125D) + 0.125D;
AxisAlignedBB axisalignedbb1 = AxisAlignedBB.getBoundingBoxFromPool(boundingBox.minX, d8,
boundingBox.minZ, boundingBox.maxX,
d9, boundingBox.maxZ);
if (worldObj.isAABBInMaterial(axisalignedbb1, Material.water))
{
d5 += 1.0D / k;
}
}
if (d5 > 0.0D)
{
if (ticksCatchable > 0)
{
ticksCatchable--;
}
else if (rand.nextInt(500) == 0)
{
ticksCatchable = rand.nextInt(30) + 10;
motionY -= 0.20000000298023224D;
worldObj.playSoundAtEntity(this, "random.splash", 0.25F,
1.0F + (rand.nextFloat() - rand.nextFloat()) * 0.4F);
float f3 = MathHelper.floor_double(boundingBox.minY);
for (int i1 = 0; i1 < 1.0F + width * 20F; i1++)
{
float f4 = (rand.nextFloat() * 2.0F - 1.0F) * width;
float f6 = (rand.nextFloat() * 2.0F - 1.0F) * width;
worldObj.spawnParticle("bubble", posX + f4, f3 + 1.0F, posZ + f6, motionX,
motionY - (rand.nextFloat() * 0.2F), motionZ);
}
for (int j1 = 0; j1 < 1.0F + width * 20F; j1++)
{
float f5 = (rand.nextFloat() * 2.0F - 1.0F) * width;
float f7 = (rand.nextFloat() * 2.0F - 1.0F) * width;
worldObj.spawnParticle("splash", posX + f5, f3 + 1.0F, posZ + f7, motionX,
motionY, motionZ);
}
}
}
if (ticksCatchable > 0)
{
motionY -= (rand.nextFloat() * rand.nextFloat() * rand.nextFloat()) * 0.20000000000000001D;
}
double d7 = d5 * 2D - 1.0D;
motionY += 0.039999999105930328D * d7;
if (d5 > 0.0D)
{
f1 = (float)(f1 * 0.90000000000000002D);
motionY *= 0.80000000000000004D;
}
motionX *= f1;
motionY *= f1;
motionZ *= f1;
setPosition(posX, posY, posZ);
}
public virtual bool isAABBInMaterial(AxisAlignedBB axisalignedbb, Material material)
{
int i = MathHelper.floor_double(axisalignedbb.minX);
int j = MathHelper.floor_double(axisalignedbb.maxX + 1.0D);
int k = MathHelper.floor_double(axisalignedbb.minY);
int l = MathHelper.floor_double(axisalignedbb.maxY + 1.0D);
int i1 = MathHelper.floor_double(axisalignedbb.minZ);
int j1 = MathHelper.floor_double(axisalignedbb.maxZ + 1.0D);
for (int k1 = i; k1 < j; k1++)
{
for (int l1 = k; l1 < l; l1++)
{
for (int i2 = i1; i2 < j1; i2++)
{
Block block = Block.blocksList[getBlockId(k1, l1, i2)];
if (block == null || block.blockMaterial != material)
{
continue;
}
int j2 = getBlockMetadata(k1, l1, i2);
double d = l1 + 1;
if (j2 < 8)
{
d = (l1 + 1) - j2/8D;
}
if (d >= axisalignedbb.minY)
{
return true;
}
}
}
}
return false;
}
public virtual AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int i, int j, int k)
{
return(AxisAlignedBB.getBoundingBoxFromPool(i + minX, j + minY, k + minZ,
i + maxX, j + maxY, k + maxZ));
}
public void moveEntity(double d, double d1, double d2)
{
if (noClip)
{
boundingBox.offset(d, d1, d2);
posX = (boundingBox.minX + boundingBox.maxX) / 2D;
posY = (boundingBox.minY + yOffset) - ySize;
posZ = (boundingBox.minZ + boundingBox.maxZ) / 2D;
return;
}
double d3 = posX;
double d4 = posZ;
double d5 = d;
double d6 = d1;
double d7 = d2;
AxisAlignedBB axisalignedbb = boundingBox.copy();
bool flag = onGround && isSneaking();
if (flag)
{
double d8 = 0.050000000000000003D;
for (;
d != 0.0D &&
worldObj.getCollidingBoundingBoxes(this, boundingBox.getOffsetBoundingBox(d, -1D, 0.0D)).size() == 0;
d5 = d)
{
if (d < d8 && d >= -d8)
{
d = 0.0D;
continue;
}
if (d > 0.0D)
{
d -= d8;
}
else
{
d += d8;
}
}
for (;
d2 != 0.0D &&
worldObj.getCollidingBoundingBoxes(this, boundingBox.getOffsetBoundingBox(0.0D, -1D, d2)).size() ==
0;
d7 = d2)
{
if (d2 < d8 && d2 >= -d8)
{
d2 = 0.0D;
continue;
}
if (d2 > 0.0D)
{
d2 -= d8;
}
else
{
d2 += d8;
}
}
}
List list = worldObj.getCollidingBoundingBoxes(this, boundingBox.addCoord(d, d1, d2));
for (int i = 0; i < list.size(); i++)
{
d1 = ((AxisAlignedBB)list.get(i)).calculateYOffset(boundingBox, d1);
}
boundingBox.offset(0.0D, d1, 0.0D);
if (!field_9077_F && d6 != d1)
{
d = d1 = d2 = 0.0D;
}
bool flag1 = onGround || d6 != d1 && d6 < 0.0D;
for (int j = 0; j < list.size(); j++)
{
d = ((AxisAlignedBB)list.get(j)).calculateXOffset(boundingBox, d);
}
boundingBox.offset(d, 0.0D, 0.0D);
if (!field_9077_F && d5 != d)
{
d = d1 = d2 = 0.0D;
}
for (int k = 0; k < list.size(); k++)
{
d2 = ((AxisAlignedBB)list.get(k)).calculateZOffset(boundingBox, d2);
}
boundingBox.offset(0.0D, 0.0D, d2);
if (!field_9077_F && d7 != d2)
{
d = d1 = d2 = 0.0D;
}
if (stepHeight > 0.0F && flag1 && ySize < 0.05F && (d5 != d || d7 != d2))
{
double d9 = d;
double d11 = d1;
double d13 = d2;
d = d5;
d1 = stepHeight;
d2 = d7;
AxisAlignedBB axisalignedbb1 = boundingBox.copy();
boundingBox.setBB(axisalignedbb);
List list1 = worldObj.getCollidingBoundingBoxes(this, boundingBox.addCoord(d, d1, d2));
for (int j2 = 0; j2 < list1.size(); j2++)
{
d1 = ((AxisAlignedBB)list1.get(j2)).calculateYOffset(boundingBox, d1);
}
boundingBox.offset(0.0D, d1, 0.0D);
if (!field_9077_F && d6 != d1)
{
d = d1 = d2 = 0.0D;
}
for (int k2 = 0; k2 < list1.size(); k2++)
{
d = ((AxisAlignedBB)list1.get(k2)).calculateXOffset(boundingBox, d);
}
boundingBox.offset(d, 0.0D, 0.0D);
if (!field_9077_F && d5 != d)
{
d = d1 = d2 = 0.0D;
}
for (int l2 = 0; l2 < list1.size(); l2++)
{
d2 = ((AxisAlignedBB)list1.get(l2)).calculateZOffset(boundingBox, d2);
}
boundingBox.offset(0.0D, 0.0D, d2);
if (!field_9077_F && d7 != d2)
{
d = d1 = d2 = 0.0D;
}
if (d9 * d9 + d13 * d13 >= d * d + d2 * d2)
{
d = d9;
d1 = d11;
d2 = d13;
boundingBox.setBB(axisalignedbb1);
}
else
{
ySize += (float)0.5D;
}
}
posX = (boundingBox.minX + boundingBox.maxX) / 2D;
posY = (boundingBox.minY + yOffset) - ySize;
posZ = (boundingBox.minZ + boundingBox.maxZ) / 2D;
isCollidedHorizontally = d5 != d || d7 != d2;
isCollidedVertically = d6 != d1;
onGround = d6 != d1 && d6 < 0.0D;
isCollided = isCollidedHorizontally || isCollidedVertically;
updateFallState(d1, onGround);
if (d5 != d)
{
motionX = 0.0D;
}
if (d6 != d1)
{
motionY = 0.0D;
}
if (d7 != d2)
{
motionZ = 0.0D;
}
double d10 = posX - d3;
double d12 = posZ - d4;
if (entityWalks && !flag)
{
distanceWalkedModified +=
(float)(MathHelper.sqrt_double(d10 * d10 + d12 * d12) * 0.59999999999999998D);
int l = MathHelper.floor_double(posX);
int j1 = MathHelper.floor_double(posY - 0.20000000298023224D - yOffset);
int l1 = MathHelper.floor_double(posZ);
int i3 = worldObj.getBlockId(l, j1, l1);
if (distanceWalkedModified > nextStepDistance && i3 > 0)
{
nextStepDistance++;
StepSound stepsound = Block.blocksList[i3].stepSound;
if (worldObj.getBlockId(l, j1 + 1, l1) == Block.snow.blockID)
{
stepsound = Block.snow.stepSound;
worldObj.playSoundAtEntity(this, stepsound.func_737_c(), stepsound.func_738_a() * 0.15F,
stepsound.func_739_b());
}
else if (!Block.blocksList[i3].blockMaterial.getIsLiquid())
{
worldObj.playSoundAtEntity(this, stepsound.func_737_c(), stepsound.func_738_a() * 0.15F,
stepsound.func_739_b());
}
Block.blocksList[i3].onEntityWalking(worldObj, l, j1, l1, this);
}
}
int i1 = MathHelper.floor_double(boundingBox.minX);
int k1 = MathHelper.floor_double(boundingBox.minY);
int i2 = MathHelper.floor_double(boundingBox.minZ);
int j3 = MathHelper.floor_double(boundingBox.maxX);
int k3 = MathHelper.floor_double(boundingBox.maxY);
int l3 = MathHelper.floor_double(boundingBox.maxZ);
if (worldObj.checkChunksExist(i1, k1, i2, j3, k3, l3))
{
for (int i4 = i1; i4 <= j3; i4++)
{
for (int j4 = k1; j4 <= k3; j4++)
{
for (int k4 = i2; k4 <= l3; k4++)
{
int l4 = worldObj.getBlockId(i4, j4, k4);
if (l4 > 0)
{
Block.blocksList[l4].onEntityCollidedWithBlock(worldObj, i4, j4, k4, this);
}
}
}
}
}
ySize *= 0.4F;
bool flag2 = handleWaterMovement();
if (worldObj.isBoundingBoxBurning(boundingBox))
{
dealFireDamage(1);
if (!flag2)
{
fire++;
if (fire == 0)
{
fire = 300;
}
}
}
else if (fire <= 0)
{
fire = -fireResistance;
}
if (flag2 && fire > 0)
{
worldObj.playSoundAtEntity(this, "random.fizz", 0.7F, 1.6F + (rand.nextFloat() - rand.nextFloat()) * 0.4F);
fire = -fireResistance;
}
}
public bool intersectsWith(AxisAlignedBB axisalignedbb)
{
if (axisalignedbb.maxX <= minX || axisalignedbb.minX >= maxX)
{
return false;
}
if (axisalignedbb.maxY <= minY || axisalignedbb.minY >= maxY)
{
return false;
}
return axisalignedbb.maxZ > minZ && axisalignedbb.minZ < maxZ;
}
public virtual List getEntitiesWithinAABB(Class class1, AxisAlignedBB axisalignedbb)
{
int i = MathHelper.floor_double((axisalignedbb.minX - 2D)/16D);
int j = MathHelper.floor_double((axisalignedbb.maxX + 2D)/16D);
int k = MathHelper.floor_double((axisalignedbb.minZ - 2D)/16D);
int l = MathHelper.floor_double((axisalignedbb.maxZ + 2D)/16D);
var arraylist = new ArrayList();
for (int i1 = i; i1 <= j; i1++)
{
for (int j1 = k; j1 <= l; j1++)
{
if (chunkExists(i1, j1))
{
getChunkFromChunkCoords(i1, j1).getEntitiesOfTypeWithinAAAB(class1, axisalignedbb, arraylist);
}
}
}
return arraylist;
}
public double calculateXOffset(AxisAlignedBB axisalignedbb, double d)
{
if (axisalignedbb.maxY <= minY || axisalignedbb.minY >= maxY)
{
return d;
}
if (axisalignedbb.maxZ <= minZ || axisalignedbb.minZ >= maxZ)
{
return d;
}
if (d > 0.0D && axisalignedbb.maxX <= minX)
{
double d1 = minX - axisalignedbb.maxX;
if (d1 < d)
{
d = d1;
}
}
if (d < 0.0D && axisalignedbb.minX >= maxX)
{
double d2 = maxX - axisalignedbb.minX;
if (d2 > d)
{
d = d2;
}
}
return d;
}
public override void getEntitiesOfTypeWithinAAAB(Class class1, AxisAlignedBB axisalignedbb, List list)
{
}
public override void getEntitiesWithinAABBForEntity(Entity entity, AxisAlignedBB axisalignedbb, List list)
{
}
public virtual bool getIsAnyLiquid(AxisAlignedBB axisalignedbb)
{
int i = MathHelper.floor_double(axisalignedbb.minX);
int j = MathHelper.floor_double(axisalignedbb.maxX + 1.0D);
int k = MathHelper.floor_double(axisalignedbb.minY);
int l = MathHelper.floor_double(axisalignedbb.maxY + 1.0D);
int i1 = MathHelper.floor_double(axisalignedbb.minZ);
int j1 = MathHelper.floor_double(axisalignedbb.maxZ + 1.0D);
if (axisalignedbb.minX < 0.0D)
{
i--;
}
if (axisalignedbb.minY < 0.0D)
{
k--;
}
if (axisalignedbb.minZ < 0.0D)
{
i1--;
}
for (int k1 = i; k1 < j; k1++)
{
for (int l1 = k; l1 < l; l1++)
{
for (int i2 = i1; i2 < j1; i2++)
{
Block block = Block.blocksList[getBlockId(k1, l1, i2)];
if (block != null && block.blockMaterial.getIsLiquid())
{
return true;
}
}
}
}
return false;
}
public override void onUpdate()
{
base.onUpdate();
if (prevRotationPitch == 0.0F && prevRotationYaw == 0.0F)
{
float f = MathHelper.sqrt_double(motionX * motionX + motionZ * motionZ);
prevRotationYaw = rotationYaw = (float)((Math.atan2(motionX, motionZ) * 180D) / 3.1415927410125732D);
prevRotationPitch = rotationPitch = (float)((Math.atan2(motionY, f) * 180D) / 3.1415927410125732D);
}
if (arrowShake > 0)
{
arrowShake--;
}
if (inGround)
{
int i = worldObj.getBlockId(xTile, yTile, zTile);
if (i != inTile)
{
inGround = false;
motionX *= rand.nextFloat() * 0.2F;
motionY *= rand.nextFloat() * 0.2F;
motionZ *= rand.nextFloat() * 0.2F;
ticksInGround = 0;
ticksInAir = 0;
}
else
{
ticksInGround++;
if (ticksInGround == 1200)
{
setEntityDead();
}
return;
}
}
else
{
ticksInAir++;
}
Vec3D vec3d = Vec3D.createVector(posX, posY, posZ);
Vec3D vec3d1 = Vec3D.createVector(posX + motionX, posY + motionY, posZ + motionZ);
MovingObjectPosition movingobjectposition = worldObj.rayTraceBlocks(vec3d, vec3d1);
vec3d = Vec3D.createVector(posX, posY, posZ);
vec3d1 = Vec3D.createVector(posX + motionX, posY + motionY, posZ + motionZ);
if (movingobjectposition != null)
{
vec3d1 = Vec3D.createVector(movingobjectposition.hitVec.xCoord, movingobjectposition.hitVec.yCoord,
movingobjectposition.hitVec.zCoord);
}
Entity entity = null;
List list = worldObj.getEntitiesWithinAABBExcludingEntity(this,
boundingBox.addCoord(motionX, motionY, motionZ).
expand(1.0D, 1.0D, 1.0D));
double d = 0.0D;
for (int j = 0; j < list.size(); j++)
{
var entity1 = (Entity)list.get(j);
if (!entity1.canBeCollidedWith() || entity1 == owner && ticksInAir < 5)
{
continue;
}
float f4 = 0.3F;
AxisAlignedBB axisalignedbb = entity1.boundingBox.expand(f4, f4, f4);
MovingObjectPosition movingobjectposition1 = axisalignedbb.func_706_a(vec3d, vec3d1);
if (movingobjectposition1 == null)
{
continue;
}
double d1 = vec3d.distanceTo(movingobjectposition1.hitVec);
if (d1 < d || d == 0.0D)
{
entity = entity1;
d = d1;
}
}
if (entity != null)
{
movingobjectposition = new MovingObjectPosition(entity);
}
if (movingobjectposition != null)
{
if (movingobjectposition.entityHit != null)
{
if (movingobjectposition.entityHit.attackEntityFrom(owner, 4))
{
worldObj.playSoundAtEntity(this, "random.drr", 1.0F, 1.2F / (rand.nextFloat() * 0.2F + 0.9F));
setEntityDead();
}
else
{
motionX *= -0.10000000149011612D;
motionY *= -0.10000000149011612D;
motionZ *= -0.10000000149011612D;
rotationYaw += 180F;
prevRotationYaw += 180F;
ticksInAir = 0;
}
}
else
{
xTile = movingobjectposition.blockX;
yTile = movingobjectposition.blockY;
zTile = movingobjectposition.blockZ;
inTile = worldObj.getBlockId(xTile, yTile, zTile);
motionX = (float)(movingobjectposition.hitVec.xCoord - posX);
motionY = (float)(movingobjectposition.hitVec.yCoord - posY);
motionZ = (float)(movingobjectposition.hitVec.zCoord - posZ);
float f1 = MathHelper.sqrt_double(motionX * motionX + motionY * motionY + motionZ * motionZ);
posX -= (motionX / f1) * 0.05000000074505806D;
posY -= (motionY / f1) * 0.05000000074505806D;
posZ -= (motionZ / f1) * 0.05000000074505806D;
worldObj.playSoundAtEntity(this, "random.drr", 1.0F, 1.2F / (rand.nextFloat() * 0.2F + 0.9F));
inGround = true;
arrowShake = 7;
}
}
posX += motionX;
posY += motionY;
posZ += motionZ;
float f2 = MathHelper.sqrt_double(motionX * motionX + motionZ * motionZ);
rotationYaw = (float)((Math.atan2(motionX, motionZ) * 180D) / 3.1415927410125732D);
for (rotationPitch = (float)((Math.atan2(motionY, f2) * 180D) / 3.1415927410125732D);
rotationPitch - prevRotationPitch < -180F;
prevRotationPitch -= 360F)
{
}
for (; rotationPitch - prevRotationPitch >= 180F; prevRotationPitch += 360F)
{
}
for (; rotationYaw - prevRotationYaw < -180F; prevRotationYaw -= 360F)
{
}
for (; rotationYaw - prevRotationYaw >= 180F; prevRotationYaw += 360F)
{
}
rotationPitch = prevRotationPitch + (rotationPitch - prevRotationPitch) * 0.2F;
rotationYaw = prevRotationYaw + (rotationYaw - prevRotationYaw) * 0.2F;
float f3 = 0.99F;
float f5 = 0.03F;
if (handleWaterMovement())
{
for (int k = 0; k < 4; k++)
{
float f6 = 0.25F;
worldObj.spawnParticle("bubble", posX - motionX * f6, posY - motionY * f6,
posZ - motionZ * f6, motionX, motionY, motionZ);
}
f3 = 0.8F;
}
motionX *= f3;
motionY *= f3;
motionZ *= f3;
motionY -= f5;
setPosition(posX, posY, posZ);
}
public void doExplosion()
{
float f = explosionSize;
int i = 16;
for (int j = 0; j < i; j++)
{
for (int l = 0; l < i; l++)
{
for (int j1 = 0; j1 < i; j1++)
{
if (j != 0 && j != i - 1 && l != 0 && l != i - 1 && j1 != 0 && j1 != i - 1)
{
continue;
}
double d = (j / (i - 1.0F)) * 2.0F - 1.0F;
double d1 = (l / (i - 1.0F)) * 2.0F - 1.0F;
double d2 = (j1 / (i - 1.0F)) * 2.0F - 1.0F;
double d3 = Math.sqrt(d * d + d1 * d1 + d2 * d2);
d /= d3;
d1 /= d3;
d2 /= d3;
float f1 = explosionSize * (0.7F + worldObj.rand.nextFloat() * 0.6F);
double d5 = explosionX;
double d7 = explosionY;
double d9 = explosionZ;
float f2 = 0.3F;
do
{
if (f1 <= 0.0F)
{
goto label0;
}
int j4 = MathHelper.floor_double(d5);
int k4 = MathHelper.floor_double(d7);
int l4 = MathHelper.floor_double(d9);
int i5 = worldObj.getBlockId(j4, k4, l4);
if (i5 > 0)
{
f1 -= (Block.blocksList[i5].getExplosionResistance(exploder) + 0.3F) * f2;
}
if (f1 > 0.0F)
{
destroyedBlockPositions.add(new ChunkPosition(j4, k4, l4));
}
d5 += d * f2;
d7 += d1 * f2;
d9 += d2 * f2;
f1 -= f2 * 0.75F;
} while (true);
label0:
;
}
}
}
explosionSize *= 2.0F;
int k = MathHelper.floor_double(explosionX - explosionSize - 1.0D);
int i1 = MathHelper.floor_double(explosionX + explosionSize + 1.0D);
int k1 = MathHelper.floor_double(explosionY - explosionSize - 1.0D);
int l1 = MathHelper.floor_double(explosionY + explosionSize + 1.0D);
int i2 = MathHelper.floor_double(explosionZ - explosionSize - 1.0D);
int j2 = MathHelper.floor_double(explosionZ + explosionSize + 1.0D);
List list = worldObj.getEntitiesWithinAABBExcludingEntity(exploder,
AxisAlignedBB.getBoundingBoxFromPool(k, k1, i2, i1,
l1, j2));
Vec3D vec3d = Vec3D.createVector(explosionX, explosionY, explosionZ);
for (int k2 = 0; k2 < list.size(); k2++)
{
var entity = (Entity)list.get(k2);
double d4 = entity.getDistance(explosionX, explosionY, explosionZ) / explosionSize;
if (d4 <= 1.0D)
{
double d6 = entity.posX - explosionX;
double d8 = entity.posY - explosionY;
double d10 = entity.posZ - explosionZ;
double d11 = MathHelper.sqrt_double(d6 * d6 + d8 * d8 + d10 * d10);
d6 /= d11;
d8 /= d11;
d10 /= d11;
double d12 = worldObj.func_494_a(vec3d, entity.boundingBox);
double d13 = (1.0D - d4) * d12;
entity.attackEntityFrom(exploder, (int)(((d13 * d13 + d13) / 2D) * 8D * explosionSize + 1.0D));
double d14 = d13;
entity.motionX += d6 * d14;
entity.motionY += d8 * d14;
entity.motionZ += d10 * d14;
}
}
explosionSize = f;
var arraylist = new ArrayList();
arraylist.addAll(destroyedBlockPositions);
if (isFlaming)
{
for (int l2 = arraylist.size() - 1; l2 >= 0; l2--)
{
var chunkposition = (ChunkPosition)arraylist.get(l2);
int i3 = chunkposition.x;
int j3 = chunkposition.y;
int k3 = chunkposition.z;
int l3 = worldObj.getBlockId(i3, j3, k3);
int i4 = worldObj.getBlockId(i3, j3 - 1, k3);
if (l3 == 0 && Block.opaqueCubeLookup[i4] && ExplosionRNG.nextInt(3) == 0)
{
worldObj.setBlockWithNotify(i3, j3, k3, Block.fire.blockID);
}
}
}
}
public virtual void getCollidingBoundingBoxes(World world, int i, int j, int k, AxisAlignedBB axisalignedbb,
ArrayList arraylist)
{
AxisAlignedBB axisalignedbb1 = getCollisionBoundingBoxFromPool(world, i, j, k);
if (axisalignedbb1 != null && axisalignedbb.intersectsWith(axisalignedbb1))
{
arraylist.add(axisalignedbb1);
}
}
public override void getEntitiesWithinAABBForEntity(Entity entity, AxisAlignedBB axisalignedbb, List list)
{
}
public override AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int i, int j, int k)
{
return(AxisAlignedBB.getBoundingBoxFromPool(i + 0, j + 0, k + 0, i + 1, j + 1, k + 1));
}
public override void onUpdate()
{
base.onUpdate();
fire = 10;
if (shake > 0)
{
shake--;
}
if (inGround)
{
int i = worldObj.getBlockId(xTile, yTile, zTile);
if (i != inTile)
{
inGround = false;
motionX *= rand.nextFloat() * 0.2F;
motionY *= rand.nextFloat() * 0.2F;
motionZ *= rand.nextFloat() * 0.2F;
field_9190_an = 0;
ticksInAir = 0;
}
else
{
field_9190_an++;
if (field_9190_an == 1200)
{
setEntityDead();
}
return;
}
}
else
{
ticksInAir++;
}
Vec3D vec3d = Vec3D.createVector(posX, posY, posZ);
Vec3D vec3d1 = Vec3D.createVector(posX + motionX, posY + motionY, posZ + motionZ);
MovingObjectPosition movingobjectposition = worldObj.rayTraceBlocks(vec3d, vec3d1);
vec3d = Vec3D.createVector(posX, posY, posZ);
vec3d1 = Vec3D.createVector(posX + motionX, posY + motionY, posZ + motionZ);
if (movingobjectposition != null)
{
vec3d1 = Vec3D.createVector(movingobjectposition.hitVec.xCoord, movingobjectposition.hitVec.yCoord,
movingobjectposition.hitVec.zCoord);
}
Entity entity = null;
List list = worldObj.getEntitiesWithinAABBExcludingEntity(this,
boundingBox.addCoord(motionX, motionY, motionZ).
expand(1.0D, 1.0D, 1.0D));
double d = 0.0D;
for (int j = 0; j < list.size(); j++)
{
var entity1 = (Entity)list.get(j);
if (!entity1.canBeCollidedWith() || entity1 == owner && ticksInAir < 25)
{
continue;
}
float f2 = 0.3F;
AxisAlignedBB axisalignedbb = entity1.boundingBox.expand(f2, f2, f2);
MovingObjectPosition movingobjectposition1 = axisalignedbb.func_706_a(vec3d, vec3d1);
if (movingobjectposition1 == null)
{
continue;
}
double d1 = vec3d.distanceTo(movingobjectposition1.hitVec);
if (d1 < d || d == 0.0D)
{
entity = entity1;
d = d1;
}
}
if (entity != null)
{
movingobjectposition = new MovingObjectPosition(entity);
}
if (movingobjectposition != null)
{
if (movingobjectposition.entityHit != null)
{
if (!movingobjectposition.entityHit.attackEntityFrom(owner, 0))
{
;
}
}
worldObj.newExplosion(null, posX, posY, posZ, 1.0F, true);
setEntityDead();
}
posX += motionX;
posY += motionY;
posZ += motionZ;
float f = MathHelper.sqrt_double(motionX * motionX + motionZ * motionZ);
rotationYaw = (float)((Math.atan2(motionX, motionZ) * 180D) / 3.1415927410125732D);
for (rotationPitch = (float)((Math.atan2(motionY, f) * 180D) / 3.1415927410125732D);
rotationPitch - prevRotationPitch < -180F;
prevRotationPitch -= 360F)
{
}
for (; rotationPitch - prevRotationPitch >= 180F; prevRotationPitch += 360F)
{
}
for (; rotationYaw - prevRotationYaw < -180F; prevRotationYaw -= 360F)
{
}
for (; rotationYaw - prevRotationYaw >= 180F; prevRotationYaw += 360F)
{
}
rotationPitch = prevRotationPitch + (rotationPitch - prevRotationPitch) * 0.2F;
rotationYaw = prevRotationYaw + (rotationYaw - prevRotationYaw) * 0.2F;
float f1 = 0.95F;
if (handleWaterMovement())
{
for (int k = 0; k < 4; k++)
{
float f3 = 0.25F;
worldObj.spawnParticle("bubble", posX - motionX * f3, posY - motionY * f3,
posZ - motionZ * f3, motionX, motionY, motionZ);
}
f1 = 0.8F;
}
motionX += field_9199_b;
motionY += field_9198_c;
motionZ += field_9196_d;
motionX *= f1;
motionY *= f1;
motionZ *= f1;
worldObj.spawnParticle("smoke", posX, posY + 0.5D, posZ, 0.0D, 0.0D, 0.0D);
setPosition(posX, posY, posZ);
}
