content: package net.minecraft.entity;
  
  import de.florianmichael.vialoadingbase.ViaLoadingBase;
  import lombok.Getter;
  import moe.ichinomiya.naven.Naven;
  import moe.ichinomiya.naven.events.api.types.EventType;
  import moe.ichinomiya.naven.events.impl.*;
  import moe.ichinomiya.naven.modules.impl.move.FastWeb;
  import net.minecraft.block.*;
  import net.minecraft.block.material.Material;
  import net.minecraft.block.state.IBlockState;
  import net.minecraft.block.state.pattern.BlockPattern;
  import net.minecraft.client.Minecraft;
  import net.minecraft.command.CommandResultStats;
  import net.minecraft.command.ICommandSender;
  import net.minecraft.crash.CrashReport;
  import net.minecraft.crash.CrashReportCategory;
  import net.minecraft.enchantment.EnchantmentHelper;
  import net.minecraft.enchantment.EnchantmentProtection;
  import net.minecraft.entity.effect.EntityLightningBolt;
  import net.minecraft.entity.item.EntityItem;
  import net.minecraft.entity.player.EntityPlayer;
  import net.minecraft.entity.player.EntityPlayerMP;
  import net.minecraft.event.HoverEvent;
  import net.minecraft.init.Blocks;
  import net.minecraft.item.Item;
  import net.minecraft.item.ItemStack;
  import net.minecraft.nbt.NBTTagCompound;
  import net.minecraft.nbt.NBTTagDouble;
  import net.minecraft.nbt.NBTTagFloat;
  import net.minecraft.nbt.NBTTagList;
  import net.minecraft.server.MinecraftServer;
  import net.minecraft.util.*;
  import net.minecraft.world.Explosion;
  import net.minecraft.world.World;
  import net.minecraft.world.WorldServer;
  
  import java.util.List;
  import java.util.Random;
  import java.util.UUID;
  import java.util.concurrent.Callable;
  
  public abstract class Entity implements ICommandSender {
      private static final AxisAlignedBB ZERO_AABB = new AxisAlignedBB(0.0D, 0.0D, 0.0D, 0.0D, 0.0D, 0.0D);
      private static int nextEntityID;
      private final CommandResultStats cmdResultStats;
      public float movementYaw;
      public double renderDistanceWeight;
      public boolean preventEntitySpawning;
      public Entity riddenByEntity;
      public Entity ridingEntity;
      public boolean forceSpawn;
      public World worldObj;
      public double prevPosX;
      public double prevPosY;
      public double prevPosZ;
      public double posX;
      public double posY;
      public double posZ;
      public double motionX;
      public double motionY;
      public double motionZ;
      public float rotationYaw;
      public float rotationPitch;
      public float prevRotationYaw;
      public float prevRotationPitch;
      public AxisAlignedBB boundingBox;
      public boolean onGround;
      public boolean isCollidedHorizontally;
      public boolean isCollidedVertically;
      public boolean isCollided;
      public boolean velocityChanged;
      public boolean isInWeb;
      public boolean isDead;
      public float width;
      public float height;
      public float prevDistanceWalkedModified;
      public float distanceWalkedModified;
      public float distanceWalkedOnStepModified;
      public float fallDistance;
      public double lastTickPosX;
      public double lastTickPosY;
      public double lastTickPosZ;
      public float stepHeight;
      public boolean noClip;
      public float entityCollisionReduction;
      public int ticksExisted;
      public int fireResistance;
      public int hurtResistantTime;
      public boolean addedToChunk;
      public int chunkCoordX;
      public int chunkCoordY;
      public int chunkCoordZ;
      public int serverPosX2, serverPosY2, serverPosZ2;
      public int serverPosX;
      public int serverPosY;
      public int serverPosZ;
      public boolean ignoreFrustumCheck;
      public boolean isAirBorne;
      public int timeUntilPortal;
      public int dimension;
      protected Random rand;
      @Getter
      protected boolean inWater;
      protected boolean firstUpdate;
      protected boolean isImmuneToFire;
      protected DataWatcher dataWatcher;
      protected boolean inPortal;
      protected int portalCounter;
      protected BlockPos lastPortalPos;
      protected Vec3 lastPortalVec;
      protected EnumFacing teleportDirection;
      protected UUID entityUniqueID;
      int inWebTicks = 0;
      private int entityId;
      private boolean isOutsideBorder;
      private int nextStepDistance;
      private int fire;
      private double entityRiderPitchDelta;
      private double entityRiderYawDelta;
      private boolean invulnerable;
  
      public Entity(World worldIn) {
          this.entityId = nextEntityID++;
          this.renderDistanceWeight = 1.0D;
          this.boundingBox = ZERO_AABB;
          this.width = 0.6F;
          this.height = 1.8F;
          this.nextStepDistance = 1;
          this.rand = new Random();
          this.fireResistance = 1;
          this.firstUpdate = true;
          this.entityUniqueID = MathHelper.getRandomUuid(this.rand);
          this.cmdResultStats = new CommandResultStats();
          this.worldObj = worldIn;
          this.setPosition(0.0D, 0.0D, 0.0D);
  
          if (worldIn != null) {
              this.dimension = worldIn.provider.getDimensionId();
          }
  
          this.dataWatcher = new DataWatcher(this);
          this.dataWatcher.addObject(0, Byte.valueOf((byte) 0));
          this.dataWatcher.addObject(1, Short.valueOf((short) 300));
          this.dataWatcher.addObject(3, Byte.valueOf((byte) 0));
          this.dataWatcher.addObject(2, "");
          this.dataWatcher.addObject(4, Byte.valueOf((byte) 0));
          this.entityInit();
      }
  
      public int getEntityId() {
          return this.entityId;
      }
  
      public void setEntityId(int id) {
          this.entityId = id;
      }
  
      public void onKillCommand() {
          this.setDead();
      }
  
      protected abstract void entityInit();
  
      public DataWatcher getDataWatcher() {
          return this.dataWatcher;
      }
  
      public boolean equals(Object p_equals_1_) {
          return p_equals_1_ instanceof Entity && ((Entity) p_equals_1_).entityId == this.entityId;
      }
  
      public int hashCode() {
          return this.entityId;
      }
  
      protected void preparePlayerToSpawn() {
          if (this.worldObj != null) {
              while (this.posY > 0.0D && this.posY < 256.0D) {
                  this.setPosition(this.posX, this.posY, this.posZ);
  
                  if (this.worldObj.getCollidingBoundingBoxes(this, this.getEntityBoundingBox()).isEmpty()) {
                      break;
                  }
  
                  ++this.posY;
              }
  
              this.motionX = this.motionY = this.motionZ = 0.0D;
              this.rotationPitch = 0.0F;
          }
      }
  
      public void setDead() {
          this.isDead = true;
      }
  
      protected void setSize(float width, float height) {
          if (width != this.width || height != this.height) {
              float f = this.width;
              this.width = width;
              this.height = height;
              this.setEntityBoundingBox(new AxisAlignedBB(this.getEntityBoundingBox().minX, this.getEntityBoundingBox().minY, this.getEntityBoundingBox().minZ, this.getEntityBoundingBox().minX + (double) this.width, this.getEntityBoundingBox().minY + (double) this.height, this.getEntityBoundingBox().minZ + (double) this.width));
  
              if (this.width > f && !this.firstUpdate && !this.worldObj.isRemote) {
                  this.moveEntity(f - this.width, 0.0D, f - this.width);
              }
          }
      }
  
      protected void setRotation(float yaw, float pitch) {
          this.rotationYaw = yaw % 360.0F;
          this.rotationPitch = pitch % 360.0F;
      }
  
      public void setPosition(double x, double y, double z) {
          this.posX = x;
          this.posY = y;
          this.posZ = z;
          float f = this.width / 2.0F;
          float f1 = this.height;
          this.setEntityBoundingBox(new AxisAlignedBB(x - (double) f, y, z - (double) f, x + (double) f, y + (double) f1, z + (double) f));
      }
  
      public void setAngles(float yaw, float pitch) {
          float f = this.rotationPitch;
          float f1 = this.rotationYaw;
          this.rotationYaw = (float) ((double) this.rotationYaw + (double) yaw * 0.15D);
          this.rotationPitch = (float) ((double) this.rotationPitch - (double) pitch * 0.15D);
          this.rotationPitch = MathHelper.clamp_float(this.rotationPitch, -90.0F, 90.0F);
          this.prevRotationPitch += this.rotationPitch - f;
          this.prevRotationYaw += this.rotationYaw - f1;
      }
  
      public void onUpdate() {
          this.onEntityUpdate();
      }
  
      public void onEntityUpdate() {
          this.worldObj.theProfiler.startSection("entityBaseTick");
  
          if (this.ridingEntity != null && this.ridingEntity.isDead) {
              this.ridingEntity = null;
          }
  
          this.prevDistanceWalkedModified = this.distanceWalkedModified;
          this.prevPosX = this.posX;
          this.prevPosY = this.posY;
          this.prevPosZ = this.posZ;
          this.prevRotationPitch = this.rotationPitch;
          this.prevRotationYaw = this.rotationYaw;
  
          if (!this.worldObj.isRemote && this.worldObj instanceof WorldServer) {
              this.worldObj.theProfiler.startSection("portal");
              MinecraftServer minecraftserver = ((WorldServer) this.worldObj).getMinecraftServer();
              int i = this.getMaxInPortalTime();
  
              if (this.inPortal) {
                  if (minecraftserver.getAllowNether()) {
                      if (this.ridingEntity == null && this.portalCounter++ >= i) {
                          this.portalCounter = i;
                          this.timeUntilPortal = this.getPortalCooldown();
                          int j;
  
                          if (this.worldObj.provider.getDimensionId() == -1) {
                              j = 0;
                          } else {
                              j = -1;
                          }
  
                          this.travelToDimension(j);
                      }
  
                      this.inPortal = false;
                  }
              } else {
                  if (this.portalCounter > 0) {
                      this.portalCounter -= 4;
                  }
  
                  if (this.portalCounter < 0) {
                      this.portalCounter = 0;
                  }
              }
  
              if (this.timeUntilPortal > 0) {
                  --this.timeUntilPortal;
              }
  
              this.worldObj.theProfiler.endSection();
          }
  
          this.spawnRunningParticles();
          this.handleWaterMovement();
  
          if (this.worldObj.isRemote) {
              this.fire = 0;
          } else if (this.fire > 0) {
              if (this.isImmuneToFire) {
                  this.fire -= 4;
  
                  if (this.fire < 0) {
                      this.fire = 0;
                  }
              } else {
                  if (this.fire % 20 == 0) {
                      this.attackEntityFrom(DamageSource.onFire, 1.0F);
                  }
  
                  --this.fire;
              }
          }
  
          if (this.isInLava()) {
              this.setOnFireFromLava();
              this.fallDistance *= 0.5F;
          }
  
          if (this.posY < -64.0D) {
              this.kill();
          }
  
          if (!this.worldObj.isRemote) {
              this.setFlag(0, this.fire > 0);
          }
  
          this.firstUpdate = false;
          this.worldObj.theProfiler.endSection();
      }
  
      public int getMaxInPortalTime() {
          return 0;
      }
  
      protected void setOnFireFromLava() {
          if (!this.isImmuneToFire) {
              this.attackEntityFrom(DamageSource.lava, 4.0F);
              this.setFire(15);
          }
      }
  
      public void setFire(int seconds) {
          int i = seconds * 20;
          i = EnchantmentProtection.getFireTimeForEntity(this, i);
  
          if (this.fire < i) {
              this.fire = i;
          }
      }
  
      public void extinguish() {
          this.fire = 0;
      }
  
      protected void kill() {
          this.setDead();
      }
  
      public boolean isOffsetPositionInLiquid(double x, double y, double z) {
          AxisAlignedBB axisalignedbb = this.getEntityBoundingBox().offset(x, y, z);
          return this.isLiquidPresentInAABB(axisalignedbb);
      }
  
      private boolean isLiquidPresentInAABB(AxisAlignedBB bb) {
          return this.worldObj.getCollidingBoundingBoxes(this, bb).isEmpty() && !this.worldObj.isAnyLiquid(bb);
      }
  
      public void moveEntity(double x, double y, double z) {
          // Client
          boolean safeWalk = false;
          boolean ground = false;
          EventMove event;
  
          if (this == Minecraft.getMinecraft().thePlayer) {
              event = new EventMove(x, y, z, false, false);
              Naven.getInstance().getEventManager().call(event);
  
              x = event.getX();
              y = event.getY();
              z = event.getZ();
  
              safeWalk = event.isSafeWalk();
              ground = event.isOnGround();
          }
  
          if (this.noClip) {
              this.setEntityBoundingBox(this.getEntityBoundingBox().offset(x, y, z));
              this.resetPositionToBB();
          } else {
              this.worldObj.theProfiler.startSection("move");
              double d0 = this.posX;
              double d1 = this.posY;
              double d2 = this.posZ;
  
              if (this.isInWeb) {
                  this.isInWeb = false;
  
                  if ((this != Minecraft.getMinecraft().thePlayer || !FastWeb.shouldCancelWeb)) {
                      x *= 0.25D;
                      y *= 0.05000000074505806D;
                      z *= 0.25D;
  
                      this.motionX = 0.0D;
                      this.motionY = 0.0D;
                      this.motionZ = 0.0D;
                  }
              }
  
              double d3 = x;
              double d4 = y;
              double d5 = z;
              boolean flag = ((this.onGround && this.isSneaking()) || safeWalk) && this instanceof EntityPlayer;
  
              if (flag) {
                  double d6;
  
                  for (d6 = 0.05D; x != 0.0D && this.worldObj.getCollidingBoundingBoxes(this, this.getEntityBoundingBox().offset(x, -1.0D, 0.0D)).isEmpty(); d3 = x) {
                      if (x < d6 && x >= -d6) {
                          x = 0.0D;
                      } else if (x > 0.0D) {
                          x -= d6;
                      } else {
                          x += d6;
                      }
                  }
  
                  for (; z != 0.0D && this.worldObj.getCollidingBoundingBoxes(this, this.getEntityBoundingBox().offset(0.0D, -1.0D, z)).isEmpty(); d5 = z) {
                      if (z < d6 && z >= -d6) {
                          z = 0.0D;
                      } else if (z > 0.0D) {
                          z -= d6;
                      } else {
                          z += d6;
                      }
                  }
  
                  for (; x != 0.0D && z != 0.0D && this.worldObj.getCollidingBoundingBoxes(this, this.getEntityBoundingBox().offset(x, -1.0D, z)).isEmpty(); d5 = z) {
                      if (x < d6 && x >= -d6) {
                          x = 0.0D;
                      } else if (x > 0.0D) {
                          x -= d6;
                      } else {
                          x += d6;
                      }
  
                      d3 = x;
  
                      if (z < d6 && z >= -d6) {
                          z = 0.0D;
                      } else if (z > 0.0D) {
                          z -= d6;
                      } else {
                          z += d6;
                      }
                  }
              }
  
              List<AxisAlignedBB> list1 = this.worldObj.getCollidingBoundingBoxes(this, this.getEntityBoundingBox().addCoord(x, y, z));
              AxisAlignedBB axisalignedbb = this.getEntityBoundingBox();
  
              for (AxisAlignedBB axisalignedbb1 : list1) {
                  y = axisalignedbb1.calculateYOffset(this.getEntityBoundingBox(), y);
              }
  
              this.setEntityBoundingBox(this.getEntityBoundingBox().offset(0.0D, y, 0.0D));
              boolean flag1 = this.onGround || d4 != y && d4 < 0.0D;
  
              for (AxisAlignedBB axisalignedbb2 : list1) {
                  x = axisalignedbb2.calculateXOffset(this.getEntityBoundingBox(), x);
              }
  
              this.setEntityBoundingBox(this.getEntityBoundingBox().offset(x, 0.0D, 0.0D));
  
              for (AxisAlignedBB axisalignedbb13 : list1) {
                  z = axisalignedbb13.calculateZOffset(this.getEntityBoundingBox(), z);
              }
  
              this.setEntityBoundingBox(this.getEntityBoundingBox().offset(0.0D, 0.0D, z));
  
              // Client Event Step
              EventStep eventStep = new EventStep(EventType.PRE, stepHeight, 0);
              if (this == Minecraft.getMinecraft().thePlayer) {
                  Naven.getInstance().getEventManager().call(eventStep);
              }
  
              if (eventStep.getStepHeight() > 0.0F && flag1 && (d3 != x || d5 != z)) {
                  double d11 = x;
                  double d7 = y;
                  double d8 = z;
                  AxisAlignedBB axisalignedbb3 = this.getEntityBoundingBox();
                  this.setEntityBoundingBox(axisalignedbb);
                  y = eventStep.getStepHeight();
                  List<AxisAlignedBB> list = this.worldObj.getCollidingBoundingBoxes(this, this.getEntityBoundingBox().addCoord(d3, y, d5));
                  AxisAlignedBB axisalignedbb4 = this.getEntityBoundingBox();
                  AxisAlignedBB axisalignedbb5 = axisalignedbb4.addCoord(d3, 0.0D, d5);
                  double d9 = y;
  
                  for (AxisAlignedBB axisalignedbb6 : list) {
                      d9 = axisalignedbb6.calculateYOffset(axisalignedbb5, d9);
                  }
  
                  axisalignedbb4 = axisalignedbb4.offset(0.0D, d9, 0.0D);
                  double d15 = d3;
  
                  for (AxisAlignedBB axisalignedbb7 : list) {
                      d15 = axisalignedbb7.calculateXOffset(axisalignedbb4, d15);
                  }
  
                  axisalignedbb4 = axisalignedbb4.offset(d15, 0.0D, 0.0D);
                  double d16 = d5;
  
                  for (AxisAlignedBB axisalignedbb8 : list) {
                      d16 = axisalignedbb8.calculateZOffset(axisalignedbb4, d16);
                  }
  
                  axisalignedbb4 = axisalignedbb4.offset(0.0D, 0.0D, d16);
                  AxisAlignedBB axisalignedbb14 = this.getEntityBoundingBox();
                  double d17 = y;
  
                  for (AxisAlignedBB axisalignedbb9 : list) {
                      d17 = axisalignedbb9.calculateYOffset(axisalignedbb14, d17);
                  }
  
                  axisalignedbb14 = axisalignedbb14.offset(0.0D, d17, 0.0D);
                  double d18 = d3;
  
                  for (AxisAlignedBB axisalignedbb10 : list) {
                      d18 = axisalignedbb10.calculateXOffset(axisalignedbb14, d18);
                  }
  
                  axisalignedbb14 = axisalignedbb14.offset(d18, 0.0D, 0.0D);
                  double d19 = d5;
  
                  for (AxisAlignedBB axisalignedbb11 : list) {
                      d19 = axisalignedbb11.calculateZOffset(axisalignedbb14, d19);
                  }
  
                  axisalignedbb14 = axisalignedbb14.offset(0.0D, 0.0D, d19);
                  double d20 = d15 * d15 + d16 * d16;
                  double d10 = d18 * d18 + d19 * d19;
  
                  if (d20 > d10) {
                      x = d15;
                      z = d16;
                      y = -d9;
                      this.setEntityBoundingBox(axisalignedbb4);
                  } else {
                      x = d18;
                      z = d19;
                      y = -d17;
                      this.setEntityBoundingBox(axisalignedbb14);
                  }
  
                  for (AxisAlignedBB axisalignedbb12 : list) {
                      y = axisalignedbb12.calculateYOffset(this.getEntityBoundingBox(), y);
                  }
  
                  this.setEntityBoundingBox(this.getEntityBoundingBox().offset(0.0D, y, 0.0D));
  
                  if (d11 * d11 + d8 * d8 >= x * x + z * z) {
                      x = d11;
                      y = d7;
                      z = d8;
                      this.setEntityBoundingBox(axisalignedbb3);
                  } else if (this == Minecraft.getMinecraft().thePlayer) {
                      Naven.getInstance().getEventManager().call(new EventStep(EventType.POST, stepHeight, 1 + y));
                  }
              }
  
              this.worldObj.theProfiler.endSection();
              this.worldObj.theProfiler.startSection("rest");
              this.resetPositionToBB();
              this.isCollidedHorizontally = d3 != x || d5 != z;
              this.isCollidedVertically = d4 != y;
              this.onGround = this.isCollidedVertically && d4 < 0.0D;
              this.isCollided = this.isCollidedHorizontally || this.isCollidedVertically;
  
              // Client
              if (ground) {
                  this.onGround = true;
              }
  
              int i = MathHelper.floor_double(this.posX);
              int j = MathHelper.floor_double(this.posY - 0.20000000298023224D);
              int k = MathHelper.floor_double(this.posZ);
              BlockPos blockpos = new BlockPos(i, j, k);
              Block block1 = this.worldObj.getBlockState(blockpos).getBlock();
  
              if (block1.getMaterial() == Material.air) {
                  Block block = this.worldObj.getBlockState(blockpos.down()).getBlock();
  
                  if (block instanceof BlockFence || block instanceof BlockWall || block instanceof BlockFenceGate) {
                      block1 = block;
                      blockpos = blockpos.down();
                  }
              }
  
              this.updateFallState(y, this.onGround, block1, blockpos);
  
              if (d3 != x) {
                  this.motionX = 0.0D;
              }
  
              if (d5 != z) {
                  this.motionZ = 0.0D;
              }
  
              if (d4 != y) {
                  block1.onLanded(this.worldObj, this);
              }
  
              if (this.canTriggerWalking() && !flag && this.ridingEntity == null) {
                  double d12 = this.posX - d0;
                  double d13 = this.posY - d1;
                  double d14 = this.posZ - d2;
  
                  if (block1 != Blocks.ladder) {
                      d13 = 0.0D;
                  }
  
                  if (block1 != null && this.onGround) {
                      block1.onEntityCollidedWithBlock(this.worldObj, blockpos, this);
                  }
  
                  this.distanceWalkedModified = (float) ((double) this.distanceWalkedModified + (double) MathHelper.sqrt_double(d12 * d12 + d14 * d14) * 0.6D);
                  this.distanceWalkedOnStepModified = (float) ((double) this.distanceWalkedOnStepModified + (double) MathHelper.sqrt_double(d12 * d12 + d13 * d13 + d14 * d14) * 0.6D);
  
                  if (this.distanceWalkedOnStepModified > (float) this.nextStepDistance && block1.getMaterial() != Material.air) {
                      this.nextStepDistance = (int) this.distanceWalkedOnStepModified + 1;
  
                      if (this.isInWater()) {
                          float f = MathHelper.sqrt_double(this.motionX * this.motionX * 0.20000000298023224D + this.motionY * this.motionY + this.motionZ * this.motionZ * 0.20000000298023224D) * 0.35F;
  
                          if (f > 1.0F) {
                              f = 1.0F;
                          }
  
                          this.playSound(this.getSwimSound(), f, 1.0F + (this.rand.nextFloat() - this.rand.nextFloat()) * 0.4F);
                      }
  
                      this.playStepSound(blockpos, block1);
                  }
              }
  
              try {
                  this.doBlockCollisions();
              } catch (Throwable throwable) {
                  CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Checking entity block collision");
                  CrashReportCategory crashreportcategory = crashreport.makeCategory("Entity being checked for collision");
                  this.addEntityCrashInfo(crashreportcategory);
                  throw new ReportedException(crashreport);
              }
  
              boolean flag2 = this.isWet();
  
              if (this.worldObj.isFlammableWithin(this.getEntityBoundingBox().contract(0.001D, 0.001D, 0.001D))) {
                  this.dealFireDamage(1);
  
                  if (!flag2) {
                      ++this.fire;
  
                      if (this.fire == 0) {
                          this.setFire(8);
                      }
                  }
              } else if (this.fire <= 0) {
                  this.fire = -this.fireResistance;
              }
  
              if (flag2 && this.fire > 0) {
                  this.playSound("random.fizz", 0.7F, 1.6F + (this.rand.nextFloat() - this.rand.nextFloat()) * 0.4F);
                  this.fire = -this.fireResistance;
              }
  
              this.worldObj.theProfiler.endSection();
          }
      }
  
      private void resetPositionToBB() {
          this.posX = (this.getEntityBoundingBox().minX + this.getEntityBoundingBox().maxX) / 2.0D;
          this.posY = this.getEntityBoundingBox().minY;
          this.posZ = (this.getEntityBoundingBox().minZ + this.getEntityBoundingBox().maxZ) / 2.0D;
      }
  
      protected String getSwimSound() {
          return "game.neutral.swim";
      }
  
      protected void doBlockCollisions() {
          BlockPos blockpos = new BlockPos(this.getEntityBoundingBox().minX + 0.001D, this.getEntityBoundingBox().minY + 0.001D, this.getEntityBoundingBox().minZ + 0.001D);
          BlockPos blockpos1 = new BlockPos(this.getEntityBoundingBox().maxX - 0.001D, this.getEntityBoundingBox().maxY - 0.001D, this.getEntityBoundingBox().maxZ - 0.001D);
  
          if (this.worldObj.isAreaLoaded(blockpos, blockpos1)) {
              for (int i = blockpos.getX(); i <= blockpos1.getX(); ++i) {
                  for (int j = blockpos.getY(); j <= blockpos1.getY(); ++j) {
                      for (int k = blockpos.getZ(); k <= blockpos1.getZ(); ++k) {
                          BlockPos blockpos2 = new BlockPos(i, j, k);
                          IBlockState iblockstate = this.worldObj.getBlockState(blockpos2);
  
                          try {
                              iblockstate.getBlock().onEntityCollidedWithBlock(this.worldObj, blockpos2, iblockstate, this);
                          } catch (Throwable throwable) {
                              CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Colliding entity with block");
                              CrashReportCategory crashreportcategory = crashreport.makeCategory("Block being collided with");
                              CrashReportCategory.addBlockInfo(crashreportcategory, blockpos2, iblockstate);
                              throw new ReportedException(crashreport);
                          }
                      }
                  }
              }
          }
      }
  
      protected void playStepSound(BlockPos pos, Block blockIn) {
          Block.SoundType block$soundtype = blockIn.stepSound;
  
          if (this.worldObj.getBlockState(pos.up()).getBlock() == Blocks.snow_layer) {
              block$soundtype = Blocks.snow_layer.stepSound;
              this.playSound(block$soundtype.getStepSound(), block$soundtype.getVolume() * 0.15F, block$soundtype.getFrequency());
          } else if (!blockIn.getMaterial().isLiquid()) {
              this.playSound(block$soundtype.getStepSound(), block$soundtype.getVolume() * 0.15F, block$soundtype.getFrequency());
          }
      }
  
      public void playSound(String name, float volume, float pitch) {
          if (!this.isSilent()) {
              this.worldObj.playSoundAtEntity(this, name, volume, pitch);
          }
      }
  
      public boolean isSilent() {
          return this.dataWatcher.getWatchableObjectByte(4) == 1;
      }
  
      public void setSilent(boolean isSilent) {
          this.dataWatcher.updateObject(4, Byte.valueOf((byte) (isSilent ? 1 : 0)));
      }
  
      protected boolean canTriggerWalking() {
          return true;
      }
  
      protected void updateFallState(double y, boolean onGroundIn, Block blockIn, BlockPos pos) {
          if (onGroundIn) {
              if (this.fallDistance > 0.0F) {
                  if (blockIn != null) {
                      blockIn.onFallenUpon(this.worldObj, pos, this, this.fallDistance);
                  } else {
                      this.fall(this.fallDistance, 1.0F);
                  }
  
                  this.fallDistance = 0.0F;
              }
          } else if (y < 0.0D) {
              this.fallDistance = (float) ((double) this.fallDistance - y);
          }
      }
  
      public AxisAlignedBB getCollisionBoundingBox() {
          return null;
      }
  
      protected void dealFireDamage(int amount) {
          if (!this.isImmuneToFire) {
              this.attackEntityFrom(DamageSource.inFire, (float) amount);
          }
      }
  
      public final boolean isImmuneToFire() {
          return this.isImmuneToFire;
      }
  
      public void fall(float distance, float damageMultiplier) {
          if (this.riddenByEntity != null) {
              this.riddenByEntity.fall(distance, damageMultiplier);
          }
      }
  
      public boolean isWet() {
          return this.inWater || this.worldObj.isRainingAt(new BlockPos(this.posX, this.posY, this.posZ)) || this.worldObj.isRainingAt(new BlockPos(this.posX, this.posY + (double) this.height, this.posZ));
      }
  
      public boolean handleWaterMovement() {
          if (this.worldObj.handleMaterialAcceleration(this.getEntityBoundingBox().expand(0.0D, -0.4000000059604645D, 0.0D).contract(0.001D, 0.001D, 0.001D), Material.water, this)) {
              if (!this.inWater && !this.firstUpdate) {
                  this.resetHeight();
              }
  
              this.fallDistance = 0.0F;
              this.inWater = true;
              this.fire = 0;
          } else {
              this.inWater = false;
          }
  
          return this.inWater;
      }
  
      protected void resetHeight() {
          float f = MathHelper.sqrt_double(this.motionX * this.motionX * 0.20000000298023224D + this.motionY * this.motionY + this.motionZ * this.motionZ * 0.20000000298023224D) * 0.2F;
  
          if (f > 1.0F) {
              f = 1.0F;
          }
  
          this.playSound(this.getSplashSound(), f, 1.0F + (this.rand.nextFloat() - this.rand.nextFloat()) * 0.4F);
          float f1 = (float) MathHelper.floor_double(this.getEntityBoundingBox().minY);
  
          for (int i = 0; (float) i < 1.0F + this.width * 20.0F; ++i) {
              float f2 = (this.rand.nextFloat() * 2.0F - 1.0F) * this.width;
              float f3 = (this.rand.nextFloat() * 2.0F - 1.0F) * this.width;
              this.worldObj.spawnParticle(EnumParticleTypes.WATER_BUBBLE, this.posX + (double) f2, f1 + 1.0F, this.posZ + (double) f3, this.motionX, this.motionY - (double) (this.rand.nextFloat() * 0.2F), this.motionZ);
          }
  
          for (int j = 0; (float) j < 1.0F + this.width * 20.0F; ++j) {
              float f4 = (this.rand.nextFloat() * 2.0F - 1.0F) * this.width;
              float f5 = (this.rand.nextFloat() * 2.0F - 1.0F) * this.width;
              this.worldObj.spawnParticle(EnumParticleTypes.WATER_SPLASH, this.posX + (double) f4, f1 + 1.0F, this.posZ + (double) f5, this.motionX, this.motionY, this.motionZ);
          }
      }
  
      public void spawnRunningParticles() {
          if (this.isSprinting() && !this.isInWater()) {
              this.createRunningParticles();
          }
      }
  
      protected void createRunningParticles() {
          int i = MathHelper.floor_double(this.posX);
          int j = MathHelper.floor_double(this.posY - 0.20000000298023224D);
          int k = MathHelper.floor_double(this.posZ);
          BlockPos blockpos = new BlockPos(i, j, k);
          IBlockState iblockstate = this.worldObj.getBlockState(blockpos);
          Block block = iblockstate.getBlock();
  
          if (block.getRenderType() != -1) {
              this.worldObj.spawnParticle(EnumParticleTypes.BLOCK_CRACK, this.posX + ((double) this.rand.nextFloat() - 0.5D) * (double) this.width, this.getEntityBoundingBox().minY + 0.1D, this.posZ + ((double) this.rand.nextFloat() - 0.5D) * (double) this.width, -this.motionX * 4.0D, 1.5D, -this.motionZ * 4.0D, Block.getStateId(iblockstate));
          }
      }
  
      protected String getSplashSound() {
          return "game.neutral.swim.splash";
      }
  
      public boolean isInsideOfMaterial(Material materialIn) {
          double d0 = this.posY + (double) this.getEyeHeight();
          BlockPos blockpos = new BlockPos(this.posX, d0, this.posZ);
          IBlockState iblockstate = this.worldObj.getBlockState(blockpos);
          Block block = iblockstate.getBlock();
  
          if (block.getMaterial() == materialIn) {
              float f = BlockLiquid.getLiquidHeightPercent(iblockstate.getBlock().getMetaFromState(iblockstate)) - 0.11111111F;
              float f1 = (float) (blockpos.getY() + 1) - f;
              boolean flag = d0 < (double) f1;
              return (flag || !(this instanceof EntityPlayer)) && flag;
          } else {
              return false;
          }
      }
  
      public boolean isInLava() {
          return this.worldObj.isMaterialInBB(this.getEntityBoundingBox().expand(-0.10000000149011612D, -0.4000000059604645D, -0.10000000149011612D), Material.lava);
      }
  
      public void moveFlying(float strafe, float forward, float friction) {
          boolean player = this == Minecraft.getMinecraft().thePlayer;
          float yaw = this.rotationYaw;
  
          if (player) {
              EventStrafe event = new EventStrafe(forward, strafe, friction, rotationYaw);
              Naven.getInstance().getEventManager().call(event);
  
              forward = event.getForward();
              strafe = event.getStrafe();
              friction = event.getFriction();
              yaw = event.getYaw();
          }
  
          float f = strafe * strafe + forward * forward;
  
          if (f >= 1.0E-4F) {
              f = MathHelper.sqrt_float(f);
  
              if (f < 1.0F) {
                  f = 1.0F;
              }
  
              f = friction / f;
              strafe = strafe * f;
              forward = forward * f;
              float f1 = MathHelper.sin(yaw * (float) Math.PI / 180.0F);
              float f2 = MathHelper.cos(yaw * (float) Math.PI / 180.0F);
              this.motionX += (double) (strafe * f2 - forward * f1);
              this.motionZ += (double) (forward * f2 + strafe * f1);
  
  //            ChatUtil.display(Math.hypot((double) (strafe * f2 - forward * f1), (double) (forward * f2 + strafe * f1)));
          }
      }
  
      public int getBrightnessForRender(float partialTicks) {
          BlockPos blockpos = new BlockPos(this.posX, this.posY + (double) this.getEyeHeight(), this.posZ);
          return this.worldObj.isBlockLoaded(blockpos) ? this.worldObj.getCombinedLight(blockpos, 0) : 0;
      }
  
      public float getBrightness(float partialTicks) {
          BlockPos blockpos = new BlockPos(this.posX, this.posY + (double) this.getEyeHeight(), this.posZ);
          return this.worldObj.isBlockLoaded(blockpos) ? this.worldObj.getLightBrightness(blockpos) : 0.0F;
      }
  
      public void setWorld(World worldIn) {
          this.worldObj = worldIn;
      }
  
      public void setPositionAndRotation(double x, double y, double z, float yaw, float pitch) {
          this.prevPosX = this.posX = x;
          this.prevPosY = this.posY = y;
          this.prevPosZ = this.posZ = z;
          this.prevRotationYaw = this.rotationYaw = yaw;
          this.prevRotationPitch = this.rotationPitch = pitch;
          double d0 = this.prevRotationYaw - yaw;
  
          if (d0 < -180.0D) {
              this.prevRotationYaw += 360.0F;
          }
  
          if (d0 >= 180.0D) {
              this.prevRotationYaw -= 360.0F;
          }
  
          this.setPosition(this.posX, this.posY, this.posZ);
          this.setRotation(yaw, pitch);
      }
  
      public void moveToBlockPosAndAngles(BlockPos pos, float rotationYawIn, float rotationPitchIn) {
          this.setLocationAndAngles((double) pos.getX() + 0.5D, pos.getY(), (double) pos.getZ() + 0.5D, rotationYawIn, rotationPitchIn);
      }
  
      public void setLocationAndAngles(double x, double y, double z, float yaw, float pitch) {
          this.lastTickPosX = this.prevPosX = this.posX = x;
          this.lastTickPosY = this.prevPosY = this.posY = y;
          this.lastTickPosZ = this.prevPosZ = this.posZ = z;
          this.rotationYaw = yaw;
          this.rotationPitch = pitch;
          this.setPosition(this.posX, this.posY, this.posZ);
      }
  
      public float getDistanceToEntity(Entity entityIn) {
          float f = (float) (this.posX - entityIn.posX);
          float f1 = (float) (this.posY - entityIn.posY);
          float f2 = (float) (this.posZ - entityIn.posZ);
          return MathHelper.sqrt_float(f * f + f1 * f1 + f2 * f2);
      }
  
      public float getHorizonDistanceToEntity(Entity entityIn) {
          float f = (float) (this.posX - entityIn.posX);
          float f2 = (float) (this.posZ - entityIn.posZ);
          return MathHelper.sqrt_float(f * f + f2 * f2);
      }
  
      public double getDistanceSq(double x, double y, double z) {
          double d0 = this.posX - x;
          double d1 = this.posY - y;
          double d2 = this.posZ - z;
          return d0 * d0 + d1 * d1 + d2 * d2;
      }
  
      public double getDistanceSq(BlockPos pos) {
          return pos.distanceSq(this.posX, this.posY, this.posZ);
      }
  
      public double getDistanceSqToCenter(BlockPos pos) {
          return pos.distanceSqToCenter(this.posX, this.posY, this.posZ);
      }
  
      public double getDistance(double x, double y, double z) {
          double d0 = this.posX - x;
          double d1 = this.posY - y;
          double d2 = this.posZ - z;
          return MathHelper.sqrt_double(d0 * d0 + d1 * d1 + d2 * d2);
      }
  
      public double getDistanceSqToEntity(Entity entityIn) {
          double d0 = this.posX - entityIn.posX;
          double d1 = this.posY - entityIn.posY;
          double d2 = this.posZ - entityIn.posZ;
          return d0 * d0 + d1 * d1 + d2 * d2;
      }
  
      public void onCollideWithPlayer(EntityPlayer entityIn) {
      }
  
      public void applyEntityCollision(Entity entityIn) {
          if (entityIn.riddenByEntity != this && entityIn.ridingEntity != this) {
              if (!entityIn.noClip && !this.noClip) {
                  double d0 = entityIn.posX - this.posX;
                  double d1 = entityIn.posZ - this.posZ;
                  double d2 = MathHelper.abs_max(d0, d1);
  
                  if (d2 >= 0.009999999776482582D) {
                      d2 = MathHelper.sqrt_double(d2);
                      d0 = d0 / d2;
                      d1 = d1 / d2;
                      double d3 = 1.0D / d2;
  
                      if (d3 > 1.0D) {
                          d3 = 1.0D;
                      }
  
                      d0 = d0 * d3;
                      d1 = d1 * d3;
                      d0 = d0 * 0.05000000074505806D;
                      d1 = d1 * 0.05000000074505806D;
                      d0 = d0 * (double) (1.0F - this.entityCollisionReduction);
                      d1 = d1 * (double) (1.0F - this.entityCollisionReduction);
  
                      if (this.riddenByEntity == null) {
                          this.addVelocity(-d0, 0.0D, -d1);
                      }
  
                      if (entityIn.riddenByEntity == null) {
                          entityIn.addVelocity(d0, 0.0D, d1);
                      }
                  }
              }
          }
      }
  
      public void addVelocity(double x, double y, double z) {
          this.motionX += x;
          this.motionY += y;
          this.motionZ += z;
          this.isAirBorne = true;
      }
  
      protected void setBeenAttacked() {
          this.velocityChanged = true;
      }
  
      public boolean attackEntityFrom(DamageSource source, float amount) {
          if (this.isEntityInvulnerable(source)) {
              return false;
          } else {
              this.setBeenAttacked();
              return false;
          }
      }
  
      public Vec3 getLook(float partialTicks) {
          if (partialTicks == 1.0F) {
              return this.getVectorForRotation(this.rotationPitch, this.rotationYaw);
          } else {
              float f = this.prevRotationPitch + (this.rotationPitch - this.prevRotationPitch) * partialTicks;
              float f1 = this.prevRotationYaw + (this.rotationYaw - this.prevRotationYaw) * partialTicks;
              return this.getVectorForRotation(f, f1);
          }
      }
  
      public final Vec3 getVectorForRotation(float pitch, float yaw) {
          float f = MathHelper.cos(-yaw * 0.017453292F - (float) Math.PI);
          float f1 = MathHelper.sin(-yaw * 0.017453292F - (float) Math.PI);
          float f2 = -MathHelper.cos(-pitch * 0.017453292F);
          float f3 = MathHelper.sin(-pitch * 0.017453292F);
          return new Vec3(f1 * f2, f3, f * f2);
      }
  
      public Vec3 getPositionEyes() {
          return new Vec3(this.posX, this.posY + (double) this.getEyeHeight(), this.posZ);
      }
  
      public Vec3 getPositionEyes(float partialTicks) {
          if (partialTicks == 1.0F) {
              return new Vec3(this.posX, this.posY + (double) this.getEyeHeight(), this.posZ);
          } else {
              double d0 = this.prevPosX + (this.posX - this.prevPosX) * (double) partialTicks;
              double d1 = this.prevPosY + (this.posY - this.prevPosY) * (double) partialTicks + (double) this.getEyeHeight();
              double d2 = this.prevPosZ + (this.posZ - this.prevPosZ) * (double) partialTicks;
              return new Vec3(d0, d1, d2);
          }
      }
  
      public Vec3 getLastPositionEyes() {
          return new Vec3(this.lastTickPosX, this.lastTickPosY + (double) this.getEyeHeight(), this.lastTickPosZ);
      }
  
      public MovingObjectPosition rayTrace(double blockReachDistance, float partialTicks) {
          Vec3 vec3 = this.getPositionEyes(partialTicks);
          Vec3 vec31 = this.getLook(partialTicks);
  
          EventRayTrace event = new EventRayTrace(vec3, vec31, blockReachDistance, partialTicks);
          Naven.getInstance().getEventManager().call(event);
  
          vec3 = event.getPositionEyes();
          vec31 = event.getLook();
  
          blockReachDistance = event.getBlockReachDistance();
          Vec3 vec32 = vec3.addVector(vec31.xCoord * blockReachDistance, vec31.yCoord * blockReachDistance, vec31.zCoord * blockReachDistance);
          return this.worldObj.rayTraceBlocks(vec3, vec32, false, false, true);
      }
  
      public boolean canBeCollidedWith() {
          return false;
      }
  
      public boolean canBePushed() {
          return false;
      }
  
      public void addToPlayerScore(Entity entityIn, int amount) {
      }
  
      public boolean isInRangeToRender3d(double x, double y, double z) {
          double d0 = this.posX - x;
          double d1 = this.posY - y;
          double d2 = this.posZ - z;
          double d3 = d0 * d0 + d1 * d1 + d2 * d2;
          return this.isInRangeToRenderDist(d3);
      }
  
      public boolean isInRangeToRenderDist(double distance) {
          double d0 = this.getEntityBoundingBox().getAverageEdgeLength();
  
          if (Double.isNaN(d0)) {
              d0 = 1.0D;
          }
  
          d0 = d0 * 64.0D * this.renderDistanceWeight;
          return distance < d0 * d0;
      }
  
      public boolean writeMountToNBT(NBTTagCompound tagCompund) {
          String s = this.getEntityString();
  
          if (!this.isDead && s != null) {
              tagCompund.setString("id", s);
              this.writeToNBT(tagCompund);
              return true;
          } else {
              return false;
          }
      }
  
      public boolean writeToNBTOptional(NBTTagCompound tagCompund) {
          String s = this.getEntityString();
  
          if (!this.isDead && s != null && this.riddenByEntity == null) {
              tagCompund.setString("id", s);
              this.writeToNBT(tagCompund);
              return true;
          } else {
              return false;
          }
      }
  
      public void writeToNBT(NBTTagCompound tagCompund) {
          try {
              tagCompund.setTag("Pos", this.newDoubleNBTList(this.posX, this.posY, this.posZ));
              tagCompund.setTag("Motion", this.newDoubleNBTList(this.motionX, this.motionY, this.motionZ));
              tagCompund.setTag("Rotation", this.newFloatNBTList(this.rotationYaw, this.rotationPitch));
              tagCompund.setFloat("FallDistance", this.fallDistance);
              tagCompund.setShort("Fire", (short) this.fire);
              tagCompund.setShort("Air", (short) this.getAir());
              tagCompund.setBoolean("OnGround", this.onGround);
              tagCompund.setInteger("Dimension", this.dimension);
              tagCompund.setBoolean("Invulnerable", this.invulnerable);
              tagCompund.setInteger("PortalCooldown", this.timeUntilPortal);
              tagCompund.setLong("UUIDMost", this.getUniqueID().getMostSignificantBits());
              tagCompund.setLong("UUIDLeast", this.getUniqueID().getLeastSignificantBits());
  
              if (this.getCustomNameTag() != null && this.getCustomNameTag().length() > 0) {
                  tagCompund.setString("CustomName", this.getCustomNameTag());
                  tagCompund.setBoolean("CustomNameVisible", this.getAlwaysRenderNameTag());
              }
  
              this.cmdResultStats.writeStatsToNBT(tagCompund);
  
              if (this.isSilent()) {
                  tagCompund.setBoolean("Silent", this.isSilent());
              }
  
              this.writeEntityToNBT(tagCompund);
  
              if (this.ridingEntity != null) {
                  NBTTagCompound nbttagcompound = new NBTTagCompound();
  
                  if (this.ridingEntity.writeMountToNBT(nbttagcompound)) {
                      tagCompund.setTag("Riding", nbttagcompound);
                  }
              }
          } catch (Throwable throwable) {
              CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Saving entity NBT");
              CrashReportCategory crashreportcategory = crashreport.makeCategory("Entity being saved");
              this.addEntityCrashInfo(crashreportcategory);
              throw new ReportedException(crashreport);
          }
      }
  
      public void readFromNBT(NBTTagCompound tagCompund) {
          try {
              NBTTagList nbttaglist = tagCompund.getTagList("Pos", 6);
              NBTTagList nbttaglist1 = tagCompund.getTagList("Motion", 6);
              NBTTagList nbttaglist2 = tagCompund.getTagList("Rotation", 5);
              this.motionX = nbttaglist1.getDoubleAt(0);
              this.motionY = nbttaglist1.getDoubleAt(1);
              this.motionZ = nbttaglist1.getDoubleAt(2);
  
              if (Math.abs(this.motionX) > 10.0D) {
                  this.motionX = 0.0D;
              }
  
              if (Math.abs(this.motionY) > 10.0D) {
                  this.motionY = 0.0D;
              }
  
              if (Math.abs(this.motionZ) > 10.0D) {
                  this.motionZ = 0.0D;
              }
  
              this.prevPosX = this.lastTickPosX = this.posX = nbttaglist.getDoubleAt(0);
              this.prevPosY = this.lastTickPosY = this.posY = nbttaglist.getDoubleAt(1);
              this.prevPosZ = this.lastTickPosZ = this.posZ = nbttaglist.getDoubleAt(2);
              this.prevRotationYaw = this.rotationYaw = nbttaglist2.getFloatAt(0);
              this.prevRotationPitch = this.rotationPitch = nbttaglist2.getFloatAt(1);
              this.setRotationYawHead(this.rotationYaw);
              this.setRenderYawOffset(this.rotationYaw);
              this.fallDistance = tagCompund.getFloat("FallDistance");
              this.fire = tagCompund.getShort("Fire");
              this.setAir(tagCompund.getShort("Air"));
              this.onGround = tagCompund.getBoolean("OnGround");
              this.dimension = tagCompund.getInteger("Dimension");
              this.invulnerable = tagCompund.getBoolean("Invulnerable");
              this.timeUntilPortal = tagCompund.getInteger("PortalCooldown");
  
              if (tagCompund.hasKey("UUIDMost", 4) && tagCompund.hasKey("UUIDLeast", 4)) {
                  this.entityUniqueID = new UUID(tagCompund.getLong("UUIDMost"), tagCompund.getLong("UUIDLeast"));
              } else if (tagCompund.hasKey("UUID", 8)) {
                  this.entityUniqueID = UUID.fromString(tagCompund.getString("UUID"));
              }
  
              this.setPosition(this.posX, this.posY, this.posZ);
              this.setRotation(this.rotationYaw, this.rotationPitch);
  
              if (tagCompund.hasKey("CustomName", 8) && tagCompund.getString("CustomName").length() > 0) {
                  this.setCustomNameTag(tagCompund.getString("CustomName"));
              }
  
              this.setAlwaysRenderNameTag(tagCompund.getBoolean("CustomNameVisible"));
              this.cmdResultStats.readStatsFromNBT(tagCompund);
              this.setSilent(tagCompund.getBoolean("Silent"));
              this.readEntityFromNBT(tagCompund);
  
              if (this.shouldSetPosAfterLoading()) {
                  this.setPosition(this.posX, this.posY, this.posZ);
              }
          } catch (Throwable throwable) {
              CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Loading entity NBT");
              CrashReportCategory crashreportcategory = crashreport.makeCategory("Entity being loaded");
              this.addEntityCrashInfo(crashreportcategory);
              throw new ReportedException(crashreport);
          }
      }
  
      protected boolean shouldSetPosAfterLoading() {
          return true;
      }
  
      protected final String getEntityString() {
          return EntityList.getEntityString(this);
      }
  
      protected abstract void readEntityFromNBT(NBTTagCompound tagCompund);
  
      protected abstract void writeEntityToNBT(NBTTagCompound tagCompound);
  
      public void onChunkLoad() {
      }
  
      protected NBTTagList newDoubleNBTList(double... numbers) {
          NBTTagList nbttaglist = new NBTTagList();
  
          for (double d0 : numbers) {
              nbttaglist.appendTag(new NBTTagDouble(d0));
          }
  
          return nbttaglist;
      }
  
      protected NBTTagList newFloatNBTList(float... numbers) {
          NBTTagList nbttaglist = new NBTTagList();
  
          for (float f : numbers) {
              nbttaglist.appendTag(new NBTTagFloat(f));
          }
  
          return nbttaglist;
      }
  
      public EntityItem dropItem(Item itemIn, int size) {
          return this.dropItemWithOffset(itemIn, size, 0.0F);
      }
  
      public EntityItem dropItemWithOffset(Item itemIn, int size, float offsetY) {
          return this.entityDropItem(new ItemStack(itemIn, size, 0), offsetY);
      }
  
      public EntityItem entityDropItem(ItemStack itemStackIn, float offsetY) {
          if (itemStackIn.stackSize != 0 && itemStackIn.getItem() != null) {
              EntityItem entityitem = new EntityItem(this.worldObj, this.posX, this.posY + (double) offsetY, this.posZ, itemStackIn);
              entityitem.setDefaultPickupDelay();
              this.worldObj.spawnEntityInWorld(entityitem);
              return entityitem;
          } else {
              return null;
          }
      }
  
      public boolean isEntityAlive() {
          return !this.isDead;
      }
  
      public boolean isEntityInsideOpaqueBlock() {
          if (this.noClip) {
              return false;
          } else {
              BlockPos.MutableBlockPos blockpos$mutableblockpos = new BlockPos.MutableBlockPos(Integer.MIN_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE);
  
              for (int i = 0; i < 8; ++i) {
                  int j = MathHelper.floor_double(this.posY + (double) (((float) ((i >> 0) % 2) - 0.5F) * 0.1F) + (double) this.getEyeHeight());
                  int k = MathHelper.floor_double(this.posX + (double) (((float) ((i >> 1) % 2) - 0.5F) * this.width * 0.8F));
                  int l = MathHelper.floor_double(this.posZ + (double) (((float) ((i >> 2) % 2) - 0.5F) * this.width * 0.8F));
  
                  if (blockpos$mutableblockpos.getX() != k || blockpos$mutableblockpos.getY() != j || blockpos$mutableblockpos.getZ() != l) {
                      blockpos$mutableblockpos.set(k, j, l);
  
                      if (this.worldObj.getBlockState(blockpos$mutableblockpos).getBlock().isVisuallyOpaque()) {
                          return true;
                      }
                  }
              }
  
              return false;
          }
      }
  
      public boolean interactFirst(EntityPlayer playerIn) {
          return false;
      }
  
      public AxisAlignedBB getCollisionBox(Entity entityIn) {
          return null;
      }
  
      public void updateRidden() {
          if (this.ridingEntity.isDead) {
              this.ridingEntity = null;
          } else {
              this.motionX = 0.0D;
              this.motionY = 0.0D;
              this.motionZ = 0.0D;
              this.onUpdate();
  
              if (this.ridingEntity != null) {
                  this.ridingEntity.updateRiderPosition();
                  this.entityRiderYawDelta += this.ridingEntity.rotationYaw - this.ridingEntity.prevRotationYaw;
  
                  for (this.entityRiderPitchDelta += this.ridingEntity.rotationPitch - this.ridingEntity.prevRotationPitch; this.entityRiderYawDelta >= 180.0D; this.entityRiderYawDelta -= 360.0D) {
                  }
  
                  while (this.entityRiderYawDelta < -180.0D) {
                      this.entityRiderYawDelta += 360.0D;
                  }
  
                  while (this.entityRiderPitchDelta >= 180.0D) {
                      this.entityRiderPitchDelta -= 360.0D;
                  }
  
                  while (this.entityRiderPitchDelta < -180.0D) {
                      this.entityRiderPitchDelta += 360.0D;
                  }
  
                  double d0 = this.entityRiderYawDelta * 0.5D;
                  double d1 = this.entityRiderPitchDelta * 0.5D;
                  float f = 10.0F;
  
                  if (d0 > (double) f) {
                      d0 = f;
                  }
  
                  if (d0 < (double) (-f)) {
                      d0 = -f;
                  }
  
                  if (d1 > (double) f) {
                      d1 = f;
                  }
  
                  if (d1 < (double) (-f)) {
                      d1 = -f;
                  }
  
                  this.entityRiderYawDelta -= d0;
                  this.entityRiderPitchDelta -= d1;
              }
          }
      }
  
      public void updateRiderPosition() {
          if (this.riddenByEntity != null) {
              this.riddenByEntity.setPosition(this.posX, this.posY + this.getMountedYOffset() + this.riddenByEntity.getYOffset(), this.posZ);
          }
      }
  
      public double getYOffset() {
          return 0.0D;
      }
  
      public double getMountedYOffset() {
          return (double) this.height * 0.75D;
      }
  
      public void mountEntity(Entity entityIn) {
          this.entityRiderPitchDelta = 0.0D;
          this.entityRiderYawDelta = 0.0D;
  
          if (entityIn == null) {
              if (this.ridingEntity != null) {
                  this.setLocationAndAngles(this.ridingEntity.posX, this.ridingEntity.getEntityBoundingBox().minY + (double) this.ridingEntity.height, this.ridingEntity.posZ, this.rotationYaw, this.rotationPitch);
                  this.ridingEntity.riddenByEntity = null;
              }
  
              this.ridingEntity = null;
          } else {
              if (this.ridingEntity != null) {
                  this.ridingEntity.riddenByEntity = null;
              }
  
              if (entityIn != null) {
                  for (Entity entity = entityIn.ridingEntity; entity != null; entity = entity.ridingEntity) {
                      if (entity == this) {
                          return;
                      }
                  }
              }
  
              this.ridingEntity = entityIn;
              entityIn.riddenByEntity = this;
          }
      }
  
      public void setPositionAndRotation2(double x, double y, double z, float yaw, float pitch, int posRotationIncrements, boolean p_180426_10_) {
          this.setPosition(x, y, z);
          this.setRotation(yaw, pitch);
          List<AxisAlignedBB> list = this.worldObj.getCollidingBoundingBoxes(this, this.getEntityBoundingBox().contract(0.03125D, 0.0D, 0.03125D));
  
          if (!list.isEmpty()) {
              double d0 = 0.0D;
  
              for (AxisAlignedBB axisalignedbb : list) {
                  if (axisalignedbb.maxY > d0) {
                      d0 = axisalignedbb.maxY;
                  }
              }
  
              y = y + (d0 - this.getEntityBoundingBox().minY);
              this.setPosition(x, y, z);
          }
      }
  
      public float getCollisionBorderSize() {
          return ViaLoadingBase.getInstance().getTargetVersion().getVersion() <= 47 ? 0.1F : 0.0F;
      }
  
      public Vec3 getLookVec() {
          return null;
      }
  
      public void setPortal(BlockPos pos) {
          if (this.timeUntilPortal > 0) {
              this.timeUntilPortal = this.getPortalCooldown();
          } else {
              if (!this.worldObj.isRemote && !pos.equals(this.lastPortalPos)) {
                  this.lastPortalPos = pos;
                  BlockPattern.PatternHelper blockpattern$patternhelper = Blocks.portal.func_181089_f(this.worldObj, pos);
                  double d0 = blockpattern$patternhelper.getFinger().getAxis() == EnumFacing.Axis.X ? (double) blockpattern$patternhelper.getPos().getZ() : (double) blockpattern$patternhelper.getPos().getX();
                  double d1 = blockpattern$patternhelper.getFinger().getAxis() == EnumFacing.Axis.X ? this.posZ : this.posX;
                  d1 = Math.abs(MathHelper.func_181160_c(d1 - (double) (blockpattern$patternhelper.getFinger().rotateY().getAxisDirection() == EnumFacing.AxisDirection.NEGATIVE ? 1 : 0), d0, d0 - (double) blockpattern$patternhelper.func_181118_d()));
                  double d2 = MathHelper.func_181160_c(this.posY - 1.0D, blockpattern$patternhelper.getPos().getY(), blockpattern$patternhelper.getPos().getY() - blockpattern$patternhelper.func_181119_e());
                  this.lastPortalVec = new Vec3(d1, d2, 0.0D);
                  this.teleportDirection = blockpattern$patternhelper.getFinger();
              }
  
              this.inPortal = true;
          }
      }
  
      public int getPortalCooldown() {
          return 300;
      }
  
      public void setVelocity(double x, double y, double z) {
          this.motionX = x;
          this.motionY = y;
          this.motionZ = z;
      }
  
      public void handleStatusUpdate(byte id) {
      }
  
      public void performHurtAnimation() {
      }
  
      public ItemStack[] getInventory() {
          return null;
      }
  
      public void setCurrentItemOrArmor(int slotIn, ItemStack stack) {
      }
  
      public boolean isBurning() {
          boolean flag = this.worldObj != null && this.worldObj.isRemote;
          return !this.isImmuneToFire && (this.fire > 0 || flag && this.getFlag(0));
      }
  
      public boolean isRiding() {
          return this.ridingEntity != null;
      }
  
      public boolean isSneaking() {
          return this.getFlag(1);
      }
  
      public void setSneaking(boolean sneaking) {
          this.setFlag(1, sneaking);
      }
  
      public boolean isSprinting() {
          return this.getFlag(3);
      }
  
      public void setSprinting(boolean sprinting) {
          this.setFlag(3, sprinting);
      }
  
      public boolean isInvisible() {
          return this.getFlag(5);
      }
  
      public void setInvisible(boolean invisible) {
          this.setFlag(5, invisible);
      }
  
      public boolean isInvisibleToPlayer(EntityPlayer player) {
          return !player.isSpectator() && this.isInvisible();
      }
  
      public boolean isEating() {
          return this.getFlag(4);
      }
  
      public void setEating(boolean eating) {
          this.setFlag(4, eating);
      }
  
      protected boolean getFlag(int flag) {
          return (this.dataWatcher.getWatchableObjectByte(0) & 1 << flag) != 0;
      }
  
      protected void setFlag(int flag, boolean set) {
          byte b0 = this.dataWatcher.getWatchableObjectByte(0);
  
          if (set) {
              this.dataWatcher.updateObject(0, Byte.valueOf((byte) (b0 | 1 << flag)));
          } else {
              this.dataWatcher.updateObject(0, Byte.valueOf((byte) (b0 & ~(1 << flag))));
          }
      }
  
      public int getAir() {
          return this.dataWatcher.getWatchableObjectShort(1);
      }
  
      public void setAir(int air) {
          this.dataWatcher.updateObject(1, Short.valueOf((short) air));
      }
  
      public void onStruckByLightning(EntityLightningBolt lightningBolt) {
          this.attackEntityFrom(DamageSource.lightningBolt, 5.0F);
          ++this.fire;
  
          if (this.fire == 0) {
              this.setFire(8);
          }
      }
  
      public void onKillEntity(EntityLivingBase entityLivingIn) {
      }
  
      protected boolean pushOutOfBlocks(double x, double y, double z) {
          BlockPos blockpos = new BlockPos(x, y, z);
          double d0 = x - (double) blockpos.getX();
          double d1 = y - (double) blockpos.getY();
          double d2 = z - (double) blockpos.getZ();
          List<AxisAlignedBB> list = this.worldObj.getCollisionBoxes(this.getEntityBoundingBox());
  
          if (list.isEmpty() && !this.worldObj.isBlockFullCube(blockpos)) {
              return false;
          } else {
              int i = 3;
              double d3 = 9999.0D;
  
              if (!this.worldObj.isBlockFullCube(blockpos.west()) && d0 < d3) {
                  d3 = d0;
                  i = 0;
              }
  
              if (!this.worldObj.isBlockFullCube(blockpos.east()) && 1.0D - d0 < d3) {
                  d3 = 1.0D - d0;
                  i = 1;
              }
  
              if (!this.worldObj.isBlockFullCube(blockpos.up()) && 1.0D - d1 < d3) {
                  d3 = 1.0D - d1;
                  i = 3;
              }
  
              if (!this.worldObj.isBlockFullCube(blockpos.north()) && d2 < d3) {
                  d3 = d2;
                  i = 4;
              }
  
              if (!this.worldObj.isBlockFullCube(blockpos.south()) && 1.0D - d2 < d3) {
                  d3 = 1.0D - d2;
                  i = 5;
              }
  
              float f = this.rand.nextFloat() * 0.2F + 0.1F;
  
              if (i == 0) {
                  this.motionX = -f;
              }
  
              if (i == 1) {
                  this.motionX = f;
              }
  
              if (i == 3) {
                  this.motionY = f;
              }
  
              if (i == 4) {
                  this.motionZ = -f;
              }
  
              if (i == 5) {
                  this.motionZ = f;
              }
  
              return true;
          }
      }
  
      public void setInWeb() {
          this.isInWeb = true;
          this.fallDistance = 0.0F;
      }
  
      public String getName() {
          if (this.hasCustomName()) {
              return this.getCustomNameTag();
          } else {
              String s = EntityList.getEntityString(this);
  
              if (s == null) {
                  s = "generic";
              }
  
              return StatCollector.translateToLocal("entity." + s + ".name");
          }
      }
  
      public Entity[] getParts() {
          return null;
      }
  
      public boolean isEntityEqual(Entity entityIn) {
          return this == entityIn;
      }
  
      public float getRotationYawHead() {
          return 0.0F;
      }
  
      public void setRotationYawHead(float rotation) {
      }
  
      public void setRenderYawOffset(float offset) {
      }
  
      public boolean canAttackWithItem() {
          return true;
      }
  
      public boolean hitByEntity(Entity entityIn) {
          return false;
      }
  
      public String toString() {
          return String.format("%s['%s'/%d, l='%s', x=%.2f, y=%.2f, z=%.2f]", this.getClass().getSimpleName(), this.getName(), Integer.valueOf(this.entityId), this.worldObj == null ? "~NULL~" : this.worldObj.getWorldInfo().getWorldName(), Double.valueOf(this.posX), Double.valueOf(this.posY), Double.valueOf(this.posZ));
      }
  
      public boolean isEntityInvulnerable(DamageSource source) {
          return this.invulnerable && source != DamageSource.outOfWorld && !source.isCreativePlayer();
      }
  
      public void copyLocationAndAnglesFrom(Entity entityIn) {
          this.setLocationAndAngles(entityIn.posX, entityIn.posY, entityIn.posZ, entityIn.rotationYaw, entityIn.rotationPitch);
      }
  
      public void copyDataFromOld(Entity entityIn) {
          NBTTagCompound nbttagcompound = new NBTTagCompound();
          entityIn.writeToNBT(nbttagcompound);
          this.readFromNBT(nbttagcompound);
          this.timeUntilPortal = entityIn.timeUntilPortal;
          this.lastPortalPos = entityIn.lastPortalPos;
          this.lastPortalVec = entityIn.lastPortalVec;
          this.teleportDirection = entityIn.teleportDirection;
      }
  
      public void travelToDimension(int dimensionId) {
          if (!this.worldObj.isRemote && !this.isDead) {
              this.worldObj.theProfiler.startSection("changeDimension");
              MinecraftServer minecraftserver = MinecraftServer.getServer();
              int i = this.dimension;
              WorldServer worldserver = minecraftserver.worldServerForDimension(i);
              WorldServer worldserver1 = minecraftserver.worldServerForDimension(dimensionId);
              this.dimension = dimensionId;
  
              if (i == 1 && dimensionId == 1) {
                  worldserver1 = minecraftserver.worldServerForDimension(0);
                  this.dimension = 0;
              }
  
              this.worldObj.removeEntity(this);
              this.isDead = false;
              this.worldObj.theProfiler.startSection("reposition");
              minecraftserver.getConfigurationManager().transferEntityToWorld(this, i, worldserver, worldserver1);
              this.worldObj.theProfiler.endStartSection("reloading");
              Entity entity = EntityList.createEntityByName(EntityList.getEntityString(this), worldserver1);
  
              if (entity != null) {
                  entity.copyDataFromOld(this);
  
                  if (i == 1 && dimensionId == 1) {
                      BlockPos blockpos = this.worldObj.getTopSolidOrLiquidBlock(worldserver1.getSpawnPoint());
                      entity.moveToBlockPosAndAngles(blockpos, entity.rotationYaw, entity.rotationPitch);
                  }
  
                  worldserver1.spawnEntityInWorld(entity);
              }
  
              this.isDead = true;
              this.worldObj.theProfiler.endSection();
              worldserver.resetUpdateEntityTick();
              worldserver1.resetUpdateEntityTick();
              this.worldObj.theProfiler.endSection();
          }
      }
  
      public float getExplosionResistance(Explosion explosionIn, World worldIn, BlockPos pos, IBlockState blockStateIn) {
          return blockStateIn.getBlock().getExplosionResistance(this);
      }
  
      public boolean verifyExplosion(Explosion explosionIn, World worldIn, BlockPos pos, IBlockState blockStateIn, float p_174816_5_) {
          return true;
      }
  
      public int getMaxFallHeight() {
          return 3;
      }
  
      public Vec3 func_181014_aG() {
          return this.lastPortalVec;
      }
  
      public EnumFacing getTeleportDirection() {
          return this.teleportDirection;
      }
  
      public boolean doesEntityNotTriggerPressurePlate() {
          return false;
      }
  
      public void addEntityCrashInfo(CrashReportCategory category) {
          category.addCrashSectionCallable("Entity Type", new Callable<String>() {
              public String call() throws Exception {
                  return EntityList.getEntityString(Entity.this) + " (" + Entity.this.getClass().getCanonicalName() + ")";
              }
          });
          category.addCrashSection("Entity ID", Integer.valueOf(this.entityId));
          category.addCrashSectionCallable("Entity Name", new Callable<String>() {
              public String call() throws Exception {
                  return Entity.this.getName();
              }
          });
          category.addCrashSection("Entity's Exact location", String.format("%.2f, %.2f, %.2f", Double.valueOf(this.posX), Double.valueOf(this.posY), Double.valueOf(this.posZ)));
          category.addCrashSection("Entity's Block location", CrashReportCategory.getCoordinateInfo(MathHelper.floor_double(this.posX), MathHelper.floor_double(this.posY), MathHelper.floor_double(this.posZ)));
          category.addCrashSection("Entity's Momentum", String.format("%.2f, %.2f, %.2f", Double.valueOf(this.motionX), Double.valueOf(this.motionY), Double.valueOf(this.motionZ)));
          category.addCrashSectionCallable("Entity's Rider", new Callable<String>() {
              public String call() throws Exception {
                  return Entity.this.riddenByEntity.toString();
              }
          });
          category.addCrashSectionCallable("Entity's Vehicle", new Callable<String>() {
              public String call() throws Exception {
                  return Entity.this.ridingEntity.toString();
              }
          });
      }
  
      public boolean canRenderOnFire() {
          return this.isBurning();
      }
  
      public UUID getUniqueID() {
          return this.entityUniqueID;
      }
  
      public boolean isPushedByWater() {
          return true;
      }
  
      private long patcher$displayNameCachedAt;
      private IChatComponent patcher$cachedDisplayName;
  
      public IChatComponent getDisplayName() {
          // Patcher
          if (System.currentTimeMillis() - patcher$displayNameCachedAt < 50L) {
              return patcher$cachedDisplayName;
          }
  
          ChatComponentText chatcomponenttext = new ChatComponentText(this.getName());
  
          // Patcher
          // chatcomponenttext.getChatStyle().setChatHoverEvent(this.getHoverEvent());
  
          chatcomponenttext.getChatStyle().setInsertion(this.getUniqueID().toString());
  
          // Patcher
          patcher$cachedDisplayName = chatcomponenttext;
          patcher$displayNameCachedAt = System.currentTimeMillis();
  
          return chatcomponenttext;
      }
  
      public String getCustomNameTag() {
          return this.dataWatcher.getWatchableObjectString(2);
      }
  
      public void setCustomNameTag(String name) {
          this.dataWatcher.updateObject(2, name);
      }
  
      public boolean hasCustomName() {
          return this.dataWatcher.getWatchableObjectString(2).length() > 0;
      }
  
      public boolean getAlwaysRenderNameTag() {
          return this.dataWatcher.getWatchableObjectByte(3) == 1;
      }
  
      public void setAlwaysRenderNameTag(boolean alwaysRenderNameTag) {
          this.dataWatcher.updateObject(3, Byte.valueOf((byte) (alwaysRenderNameTag ? 1 : 0)));
      }
  
      public void setPositionAndUpdate(double x, double y, double z) {
          this.setLocationAndAngles(x, y, z, this.rotationYaw, this.rotationPitch);
      }
  
      public boolean getAlwaysRenderNameTagForRender() {
          return this.getAlwaysRenderNameTag();
      }
  
      public void onDataWatcherUpdate(int dataID) {
      }
  
      public EnumFacing getHorizontalFacing(final float yaw) {
          return EnumFacing.getHorizontal(MathHelper.floor_double(yaw * 4.0f / 360.0f + 0.5) & 0x3);
      }
  
      public EnumFacing getHorizontalFacing() {
          return EnumFacing.getHorizontal(MathHelper.floor_double((double) (this.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3);
      }
  
      protected HoverEvent getHoverEvent() {
          NBTTagCompound nbttagcompound = new NBTTagCompound();
          String s = EntityList.getEntityString(this);
          nbttagcompound.setString("id", this.getUniqueID().toString());
  
          if (s != null) {
              nbttagcompound.setString("type", s);
          }
  
          nbttagcompound.setString("name", this.getName());
          return new HoverEvent(HoverEvent.Action.SHOW_ENTITY, new ChatComponentText(nbttagcompound.toString()));
      }
  
      public boolean isSpectatedByPlayer(EntityPlayerMP player) {
          return true;
      }
  
      public AxisAlignedBB getEntityBoundingBox() {
          return this.boundingBox;
      }
  
      public void setEntityBoundingBox(AxisAlignedBB bb) {
          this.boundingBox = bb;
      }
  
      public float getEyeHeight() {
          return this.height * 0.85F;
      }
  
      public boolean isOutsideBorder() {
          return this.isOutsideBorder;
      }
  
      public void setOutsideBorder(boolean outsideBorder) {
          this.isOutsideBorder = outsideBorder;
      }
  
      public boolean replaceItemInInventory(int inventorySlot, ItemStack itemStackIn) {
          return false;
      }
  
      public void addChatMessage(IChatComponent component) {
      }
  
      public boolean canCommandSenderUseCommand(int permLevel, String commandName) {
          return true;
      }
  
      public BlockPos getPosition() {
          return new BlockPos(this.posX, this.posY + 0.5D, this.posZ);
      }
  
      public Vec3 getPositionVector() {
          return new Vec3(this.posX, this.posY, this.posZ);
      }
  
      public World getEntityWorld() {
          return this.worldObj;
      }
  
      public Entity getCommandSenderEntity() {
          return this;
      }
  
      public boolean sendCommandFeedback() {
          return false;
      }
  
      public void setCommandStat(CommandResultStats.Type type, int amount) {
          this.cmdResultStats.setCommandStatScore(this, type, amount);
      }
  
      public CommandResultStats getCommandStats() {
          return this.cmdResultStats;
      }
  
      public void setCommandStats(Entity entityIn) {
          this.cmdResultStats.addAllStats(entityIn.getCommandStats());
      }
  
      public NBTTagCompound getNBTTagCompound() {
          return null;
      }
  
      public void clientUpdateEntityNBT(NBTTagCompound compound) {
      }
  
      public boolean interactAt(EntityPlayer player, Vec3 targetVec3) {
          return false;
      }
  
      public boolean isImmuneToExplosions() {
          return false;
      }
  
      protected void applyEnchantments(EntityLivingBase entityLivingBaseIn, Entity entityIn) {
          if (entityIn instanceof EntityLivingBase) {
              EnchantmentHelper.applyThornEnchantments((EntityLivingBase) entityIn, entityLivingBaseIn);
          }
  
          EnchantmentHelper.applyArthropodEnchantments(entityLivingBaseIn, entityIn);
      }
  
      public Vector3d getCustomPositionVector() {
          return new Vector3d(posX, posY, posZ);
      }
  
      public MovingObjectPosition customRayTrace(final double blockReachDistance, final float partialTicks, final float yaw, final float pitch) {
          final Vec3 vec3 = this.getPositionEyes(partialTicks);
          final Vec3 vec4 = this.getCustomLook(partialTicks, yaw, pitch);
          final Vec3 vec5 = vec3.addVector(vec4.xCoord * blockReachDistance, vec4.yCoord * blockReachDistance, vec4.zCoord * blockReachDistance);
          return this.worldObj.rayTraceBlocks(vec3, vec5, false, false, true);
      }
  
      public MovingObjectPosition customRayTrace(final Vec3 eyes, final double blockReachDistance, final float partialTicks, final float yaw, final float pitch) {
          final Vec3 vec4 = this.getCustomLook(partialTicks, yaw, pitch);
          final Vec3 vec5 = eyes.addVector(vec4.xCoord * blockReachDistance, vec4.yCoord * blockReachDistance, vec4.zCoord * blockReachDistance);
          return this.worldObj.rayTraceBlocks(eyes, vec5, false, false, true);
      }
  
      public Vec3 getCustomLook(final float partialTicks, final float yaw, final float pitch) {
          if (partialTicks == 1.0f || partialTicks == 2.0f) {
              return this.getVectorForRotation(pitch, yaw);
          }
          final float f = this.prevRotationPitch + (this.rotationPitch - this.prevRotationPitch) * partialTicks;
          final float f2 = this.prevRotationYaw + (this.rotationYaw - this.prevRotationYaw) * partialTicks;
          return this.getVectorForRotation(f, f2);
      }
  }
  