public void preparePlayerToSpawn() {
   yOffset = 1.62F;
   setSize(0.6F, 1.8F);
   super.preparePlayerToSpawn();
   setEntityHealth(getMaxHealth());
   deathTime = 0;
 }
 public void readEntityFromNBT(NBTTagCompound nbttagcompound) {
   super.readEntityFromNBT(nbttagcompound);
   NBTTagList nbttaglist = nbttagcompound.getTagList("Inventory");
   inventory.readFromNBT(nbttaglist);
   dimension = nbttagcompound.getInteger("Dimension");
   sleeping = nbttagcompound.getBoolean("Sleeping");
   sleepTimer = nbttagcompound.getShort("SleepTimer");
   currentXP = nbttagcompound.getFloat("XpP");
   playerLevel = nbttagcompound.getInteger("XpLevel");
   totalXP = nbttagcompound.getInteger("XpTotal");
   if (sleeping) {
     bedChunkCoordinates =
         new ChunkCoordinates(
             MathHelper.floor_double(posX),
             MathHelper.floor_double(posY),
             MathHelper.floor_double(posZ));
     wakeUpPlayer(true, true, false);
   }
   if (nbttagcompound.hasKey("SpawnX")
       && nbttagcompound.hasKey("SpawnY")
       && nbttagcompound.hasKey("SpawnZ")) {
     playerSpawnCoordinate =
         new ChunkCoordinates(
             nbttagcompound.getInteger("SpawnX"),
             nbttagcompound.getInteger("SpawnY"),
             nbttagcompound.getInteger("SpawnZ"));
   }
   foodStats.readStatsFromNBT(nbttagcompound);
   capabilities.readCapabilitiesFromNBT(nbttagcompound);
 }
 public void setEntityDead() {
   super.setEntityDead();
   inventorySlots.onCraftGuiClosed(this);
   if (craftingInventory != null) {
     craftingInventory.onCraftGuiClosed(this);
   }
 }
 public void handleHealthUpdate(byte byte0) {
   if (byte0 == 9) {
     func_35208_ae();
   } else {
     super.handleHealthUpdate(byte0);
   }
 }
 public void moveEntityWithHeading(float f, float f1) {
   double d = posX;
   double d1 = posY;
   double d2 = posZ;
   if (capabilities.isFlying) {
     double d3 = motionY;
     float f2 = jumpMovementFactor;
     jumpMovementFactor = 0.05F;
     super.moveEntityWithHeading(f, f1);
     motionY = d3 * 0.59999999999999998D;
     jumpMovementFactor = f2;
   } else {
     super.moveEntityWithHeading(f, f1);
   }
   addMovementStat(posX - d, posY - d1, posZ - d2);
 }
 protected void jump() {
   super.jump();
   addStat(StatList.jumpStat, 1);
   if (isSprinting()) {
     addExhaustion(0.8F);
   } else {
     addExhaustion(0.2F);
   }
 }
 public void updateRidden() {
   double d = posX;
   double d1 = posY;
   double d2 = posZ;
   super.updateRidden();
   prevCameraYaw = cameraYaw;
   cameraYaw = 0.0F;
   addMountedMovementStat(posX - d, posY - d1, posZ - d2);
 }
 protected void fall(float f) {
   if (capabilities.allowFlying) {
     return;
   }
   if (f >= 2.0F) {
     addStat(StatList.distanceFallenStat, (int) Math.round((double) f * 100D));
   }
   super.fall(f);
 }
 public void b(EntityLiving entityliving) {
   super.b(entityliving);
   if (village != null && entityliving != null) {
     village.a(entityliving);
     if (entityliving instanceof EntityHuman) {
       byte byte0 = -1;
       if (isBaby()) byte0 = -3;
       village.a(entityliving.getName(), byte0);
       if (isAlive()) world.broadcastEntityEffect(this, (byte) 13);
     }
   }
 }
 private static List getSpawnableList(
     World w, BiomeGenBase par1BiomeGenBase, EnumCreatureType par2EnumCreatureType) {
   List list2 = par1BiomeGenBase.getSpawnableList(par2EnumCreatureType);
   List list = new ArrayList();
   for (Object o : list2) {
     SpawnListEntry s = (SpawnListEntry) o;
     String str = (String) (classToStringMapping.get(s.entityClass));
     if (EntityLiving.allow(str, w.provider.dimensionId)) {
       list.add(s);
     }
   }
   return list;
 }
 public void writeEntityToNBT(NBTTagCompound nbttagcompound) {
   super.writeEntityToNBT(nbttagcompound);
   nbttagcompound.setTag("Inventory", inventory.writeToNBT(new NBTTagList()));
   nbttagcompound.setInteger("Dimension", dimension);
   nbttagcompound.setBoolean("Sleeping", sleeping);
   nbttagcompound.setShort("SleepTimer", (short) sleepTimer);
   nbttagcompound.setFloat("XpP", currentXP);
   nbttagcompound.setInteger("XpLevel", playerLevel);
   nbttagcompound.setInteger("XpTotal", totalXP);
   if (playerSpawnCoordinate != null) {
     nbttagcompound.setInteger("SpawnX", playerSpawnCoordinate.posX);
     nbttagcompound.setInteger("SpawnY", playerSpawnCoordinate.posY);
     nbttagcompound.setInteger("SpawnZ", playerSpawnCoordinate.posZ);
   }
   foodStats.writeStatsToNBT(nbttagcompound);
   capabilities.writeCapabilitiesToNBT(nbttagcompound);
 }
 public void onDeath(DamageSource damagesource) {
   super.onDeath(damagesource);
   setSize(0.2F, 0.2F);
   setPosition(posX, posY, posZ);
   motionY = 0.10000000149011612D;
   if (username.equals("Notch")) {
     dropPlayerItemWithRandomChoice(new ItemStack(Item.appleRed, 1), true);
   }
   inventory.dropAllItems();
   if (damagesource != null) {
     motionX = -MathHelper.cos(((attackedAtYaw + rotationYaw) * 3.141593F) / 180F) * 0.1F;
     motionZ = -MathHelper.sin(((attackedAtYaw + rotationYaw) * 3.141593F) / 180F) * 0.1F;
   } else {
     motionX = motionZ = 0.0D;
   }
   yOffset = 0.1F;
   addStat(StatList.deathsStat, 1);
 }
 public void onLivingUpdate() {
   if (flyToggleTimer > 0) {
     flyToggleTimer--;
   }
   if (worldObj.difficultySetting == 0
       && getEntityHealth() < getMaxHealth()
       && (ticksExisted % 20) * 12 == 0) {
     heal(1);
   }
   inventory.decrementAnimations();
   prevCameraYaw = cameraYaw;
   super.onLivingUpdate();
   landMovementFactor = speedOnGround;
   jumpMovementFactor = speedInAir;
   if (isSprinting()) {
     landMovementFactor += (double) speedOnGround * 0.29999999999999999D;
     jumpMovementFactor += (double) speedInAir * 0.29999999999999999D;
   }
   float f = MathHelper.sqrt_double(motionX * motionX + motionZ * motionZ);
   float f1 = (float) Math.atan(-motionY * 0.20000000298023224D) * 15F;
   if (f > 0.1F) {
     f = 0.1F;
   }
   if (!onGround || getEntityHealth() <= 0) {
     f = 0.0F;
   }
   if (onGround || getEntityHealth() <= 0) {
     f1 = 0.0F;
   }
   cameraYaw += (f - cameraYaw) * 0.4F;
   cameraPitch += (f1 - cameraPitch) * 0.8F;
   if (getEntityHealth() > 0) {
     List list =
         worldObj.getEntitiesWithinAABBExcludingEntity(this, boundingBox.expand(1.0D, 0.0D, 1.0D));
     if (list != null) {
       for (int i = 0; i < list.size(); i++) {
         Entity entity = (Entity) list.get(i);
         if (!entity.isDead) {
           collideWithPlayer(entity);
         }
       }
     }
   }
 }
 private static SpawnListEntry spawnRandomCreature(
     World w, EnumCreatureType par1EnumCreatureType, int par2, int par3, int par4) {
   if (w instanceof FakeWorldServer) {
     return null;
   }
   List list2 = w.getChunkProvider().getPossibleCreatures(par1EnumCreatureType, par2, par3, par4);
   List list = new ArrayList();
   for (Object o : list2) {
     SpawnListEntry s = (SpawnListEntry) o;
     String str = (String) (classToStringMapping.get(s.entityClass));
     if (EntityLiving.allow(str, w.provider.dimensionId)) {
       list.add(s);
     }
   }
   if (list == null || list.isEmpty()) {
     return null;
   }
   return (SpawnListEntry) WeightedRandom.getRandomItem(w.rand, list);
 }
  /**
   * Allows the entity to update its state. Overridden in most subclasses, e.g. the mob spawner uses
   * this to count ticks and creates a new spawn inside its implementation.
   */
  public void updateEntity() {
    if (!anyPlayerInRange()) {
      return;
    }

    if (worldObj.isRemote) {
      double d = (float) xCoord + worldObj.rand.nextFloat();
      double d1 = (float) yCoord + worldObj.rand.nextFloat();
      double d3 = (float) zCoord + worldObj.rand.nextFloat();
      worldObj.spawnParticle("smoke", d, d1, d3, 0.0D, 0.0D, 0.0D);
      worldObj.spawnParticle("flame", d, d1, d3, 0.0D, 0.0D, 0.0D);
      yaw2 = yaw % 360D;
      yaw += 4.5454545021057129D;
    } else {
      if (delay == -1) {
        updateDelay();
      }

      if (delay > 0) {
        delay--;
        return;
      }

      for (int i = 0; i < field_70395_h; i++) {
        Entity entity = EntityList.createEntityByName(mobID, worldObj);

        if (entity == null) {
          return;
        }

        int j =
            worldObj
                .getEntitiesWithinAABB(
                    entity.getClass(),
                    AxisAlignedBB.getAABBPool()
                        .addOrModifyAABBInPool(
                            xCoord, yCoord, zCoord, xCoord + 1, yCoord + 1, zCoord + 1)
                        .expand(8D, 4D, 8D))
                .size();

        if (j >= 6) {
          updateDelay();
          return;
        }

        if (entity == null) {
          continue;
        }

        double d2 =
            (double) xCoord + (worldObj.rand.nextDouble() - worldObj.rand.nextDouble()) * 4D;
        double d4 = (yCoord + worldObj.rand.nextInt(3)) - 1;
        double d5 =
            (double) zCoord + (worldObj.rand.nextDouble() - worldObj.rand.nextDouble()) * 4D;
        EntityLiving entityliving = (entity instanceof EntityLiving) ? (EntityLiving) entity : null;
        entity.setLocationAndAngles(d2, d4, d5, worldObj.rand.nextFloat() * 360F, 0.0F);

        if (entityliving != null && !entityliving.getCanSpawnHere()) {
          continue;
        }

        func_70383_a(entity);
        worldObj.spawnEntityInWorld(entity);
        worldObj.playAuxSFX(2004, xCoord, yCoord, zCoord, 0);

        if (entityliving != null) {
          entityliving.spawnExplosionParticle();
        }

        updateDelay();
      }
    }

    super.updateEntity();
  }
 public void onUpdate() {
   if (itemInUse != null) {
     ItemStack itemstack = inventory.getCurrentItem();
     if (itemstack != itemInUse) {
       clearItemInUse();
     } else {
       if (itemInUseCount <= 25 && itemInUseCount % 4 == 0) {
         func_35201_a(itemstack, 5);
       }
       if (--itemInUseCount == 0 && !worldObj.multiplayerWorld) {
         func_35208_ae();
       }
     }
   }
   if (xpCooldown > 0) {
     xpCooldown--;
   }
   if (isPlayerSleeping()) {
     sleepTimer++;
     if (sleepTimer > 100) {
       sleepTimer = 100;
     }
     if (!worldObj.multiplayerWorld) {
       if (!isInBed()) {
         wakeUpPlayer(true, true, false);
       } else if (worldObj.isDaytime()) {
         wakeUpPlayer(false, true, true);
       }
     }
   } else if (sleepTimer > 0) {
     sleepTimer++;
     if (sleepTimer >= 110) {
       sleepTimer = 0;
     }
   }
   super.onUpdate();
   if (!worldObj.multiplayerWorld
       && craftingInventory != null
       && !craftingInventory.canInteractWith(this)) {
     closeScreen();
     craftingInventory = inventorySlots;
   }
   if (capabilities.isFlying) {
     for (int i = 0; i < 8; i++) {}
   }
   if (isBurning() && capabilities.disableDamage) {
     extinguish();
   }
   field_20066_r = field_20063_u;
   field_20065_s = field_20062_v;
   field_20064_t = field_20061_w;
   double d = posX - field_20063_u;
   double d1 = posY - field_20062_v;
   double d2 = posZ - field_20061_w;
   double d3 = 10D;
   if (d > d3) {
     field_20066_r = field_20063_u = posX;
   }
   if (d2 > d3) {
     field_20064_t = field_20061_w = posZ;
   }
   if (d1 > d3) {
     field_20065_s = field_20062_v = posY;
   }
   if (d < -d3) {
     field_20066_r = field_20063_u = posX;
   }
   if (d2 < -d3) {
     field_20064_t = field_20061_w = posZ;
   }
   if (d1 < -d3) {
     field_20065_s = field_20062_v = posY;
   }
   field_20063_u += d * 0.25D;
   field_20061_w += d2 * 0.25D;
   field_20062_v += d1 * 0.25D;
   addStat(StatList.minutesPlayedStat, 1);
   if (ridingEntity == null) {
     startMinecartRidingCoordinate = null;
   }
   if (!worldObj.multiplayerWorld) {
     foodStats.onUpdate(this);
   }
 }
  /** Called during chunk generation to spawn initial creatures. */
  public static void performWorldGenSpawning(
      World par0World,
      BiomeGenBase par1BiomeGenBase,
      int par2,
      int par3,
      int par4,
      int par5,
      Random par6Random) {
    List list = getSpawnableList(par0World, par1BiomeGenBase, EnumCreatureType.creature);

    if (list.isEmpty()) {
      return;
    }

    while (par6Random.nextFloat() < par1BiomeGenBase.getSpawningChance()) {
      SpawnListEntry spawnlistentry =
          (SpawnListEntry) WeightedRandom.getRandomItem(par0World.rand, list);
      EntityLivingData entitylivingdata = null;
      int i =
          spawnlistentry.minGroupCount
              + par6Random.nextInt(
                  (1 + spawnlistentry.maxGroupCount) - spawnlistentry.minGroupCount);
      int j = par2 + par6Random.nextInt(par4);
      int k = par3 + par6Random.nextInt(par5);
      int l = j;
      int i1 = k;
      int j1 = 0;

      while (j1 < i) {
        boolean flag = false;

        for (int k1 = 0; !flag && k1 < 4; k1++) {
          int l1 = par0World.getTopSolidOrLiquidBlock(j, k);

          if (canCreatureTypeSpawnAtLocation(EnumCreatureType.creature, par0World, j, l1, k)) {
            float f = (float) j + 0.5F;
            float f1 = l1;
            float f2 = (float) k + 0.5F;
            EntityLiving entityliving;

            try {
              entityliving =
                  (EntityLiving)
                      spawnlistentry
                          .entityClass
                          .getConstructor(new Class[] {net.minecraft.src.World.class})
                          .newInstance(new Object[] {par0World});
            } catch (Exception exception) {
              exception.printStackTrace();
              continue;
            }

            entityliving.setLocationAndAngles(f, f1, f2, par6Random.nextFloat() * 360F, 0.0F);
            par0World.spawnEntityInWorld(entityliving);
            entitylivingdata = entityliving.onSpawnWithEgg(entitylivingdata);
            flag = true;
          }

          j += par6Random.nextInt(5) - par6Random.nextInt(5);

          for (k += par6Random.nextInt(5) - par6Random.nextInt(5);
              j < par2 || j >= par2 + par4 || k < par3 || k >= par3 + par4;
              k = (i1 + par6Random.nextInt(5)) - par6Random.nextInt(5)) {
            j = (l + par6Random.nextInt(5)) - par6Random.nextInt(5);
          }
        }

        j1++;
      }
    }
  }
  /**
   * adds all chunks within the spawn radius of the players to eligibleChunksForSpawning. pars: the
   * world, hostileCreatures, passiveCreatures. returns number of eligible chunks.
   */
  public int findChunksForSpawning(
      WorldServer par1WorldServer, boolean par2, boolean par3, boolean par4) {
    if (!par2 && !par3) {
      return 0;
    } else {
      eligibleChunksForSpawning.clear();
      int var3;
      int var6;

      for (var3 = 0; var3 < par1WorldServer.playerEntities.size(); ++var3) {
        EntityPlayer var4 = (EntityPlayer) par1WorldServer.playerEntities.get(var3);
        int var5 = MathHelper.floor_double(var4.posX / 16.0D);
        var6 = MathHelper.floor_double(var4.posZ / 16.0D);
        byte var7 = 8;

        for (int var8 = -var7; var8 <= var7; ++var8) {
          for (int var9 = -var7; var9 <= var7; ++var9) {
            boolean var10 = var8 == -var7 || var8 == var7 || var9 == -var7 || var9 == var7;
            ChunkCoordIntPair var11 = new ChunkCoordIntPair(var8 + var5, var9 + var6);

            if (!var10) {
              eligibleChunksForSpawning.put(var11, Boolean.valueOf(false));
            } else if (!eligibleChunksForSpawning.containsKey(var11)) {
              eligibleChunksForSpawning.put(var11, Boolean.valueOf(true));
            }
          }
        }
      }

      var3 = 0;
      ChunkCoordinates var31 = par1WorldServer.getSpawnPoint();
      EnumCreatureType[] var32 = EnumCreatureType.values();
      var6 = var32.length;

      for (int var33 = 0; var33 < var6; ++var33) {
        EnumCreatureType var34 = var32[var33];

        if ((!var34.getPeacefulCreature() || par3)
            && (var34.getPeacefulCreature() || par2)
            && par1WorldServer.countEntities(var34.getCreatureClass())
                <= var34.getMaxNumberOfCreature() * eligibleChunksForSpawning.size() / 256) {
          Iterator var35 = eligibleChunksForSpawning.keySet().iterator();
          label108:
          while (var35.hasNext()) {
            ChunkCoordIntPair var37 = (ChunkCoordIntPair) var35.next();

            if (!((Boolean) eligibleChunksForSpawning.get(var37)).booleanValue()) {
              ChunkPosition var36 =
                  getRandomSpawningPointInChunk(par1WorldServer, var37.chunkXPos, var37.chunkZPos);
              int var12 = var36.x;
              int var13 = var36.y;
              int var14 = var36.z;

              if (!par1WorldServer.isBlockNormalCube(var12, var13, var14)
                  && par1WorldServer.getBlockMaterial(var12, var13, var14)
                      == var34.getCreatureMaterial()) {
                int var15 = 0;
                int var16 = 0;

                while (var16 < 3) {
                  int var17 = var12;
                  int var18 = var13;
                  int var19 = var14;
                  byte var20 = 6;
                  SpawnListEntry var21 = null;
                  EntityLivingData entitylivingdata = null;
                  int var22 = 0;

                  while (true) {
                    if (var22 < 4) {
                      label101:
                      {
                        var17 +=
                            par1WorldServer.rand.nextInt(var20)
                                - par1WorldServer.rand.nextInt(var20);
                        var18 += par1WorldServer.rand.nextInt(1) - par1WorldServer.rand.nextInt(1);
                        var19 +=
                            par1WorldServer.rand.nextInt(var20)
                                - par1WorldServer.rand.nextInt(var20);

                        if (canCreatureTypeSpawnAtLocation(
                            var34, par1WorldServer, var17, var18, var19)) {
                          float var23 = (float) var17 + 0.5F;
                          float var24 = (float) var18;
                          float var25 = (float) var19 + 0.5F;

                          if (par1WorldServer.getClosestPlayer(
                                  (double) var23, (double) var24, (double) var25, 24.0D)
                              == null) {
                            float var26 = var23 - (float) var31.posX;
                            float var27 = var24 - (float) var31.posY;
                            float var28 = var25 - (float) var31.posZ;
                            float var29 = var26 * var26 + var27 * var27 + var28 * var28;

                            if (var29 >= 576.0F) {
                              if (var21 == null) {
                                var21 =
                                    spawnRandomCreature(
                                        par1WorldServer, var34, var17, var18, var19);

                                if (var21 == null) {
                                  break label101;
                                }
                              }

                              EntityLiving var38;

                              try {
                                var38 =
                                    (EntityLiving)
                                        var21
                                            .entityClass
                                            .getConstructor(new Class[] {World.class})
                                            .newInstance(new Object[] {par1WorldServer});
                              } catch (Exception var30) {
                                var30.printStackTrace();
                                return var3;
                              }

                              var38.setLocationAndAngles(
                                  (double) var23,
                                  (double) var24,
                                  (double) var25,
                                  par1WorldServer.rand.nextFloat() * 360.0F,
                                  0.0F);

                              if (var38.getCanSpawnHere()) {
                                ++var15;
                                par1WorldServer.spawnEntityInWorld(var38);
                                entitylivingdata = var38.onSpawnWithEgg(entitylivingdata);

                                if (var15 >= var38.getMaxSpawnedInChunk()) {
                                  continue label108;
                                }
                              }

                              var3 += var15;
                            }
                          }
                        }

                        ++var22;
                        continue;
                      }
                    }

                    ++var16;
                    break;
                  }
                }
              }
            }
          }
        }
      }

      return var3;
    }
  }
 protected void entityInit() {
   super.entityInit();
   dataWatcher.addObject(16, Byte.valueOf((byte) 0));
   dataWatcher.addObject(17, Byte.valueOf((byte) 0));
 }