/** Ejects the current record inside of the jukebox. */
public void ejectRecord(World par1World, int par2, int par3, int par4) {
if (!par1World.isRemote) {
TileEntityRecordPlayer var5 =
(TileEntityRecordPlayer) par1World.getBlockTileEntity(par2, par3, par4);
if (var5 != null) {
ItemStack var6 = var5.func_96097_a();
if (var6 != null) {
par1World.playAuxSFX(1005, par2, par3, par4, 0);
par1World.playRecord((String) null, par2, par3, par4);
var5.func_96098_a((ItemStack) null);
par1World.setBlockMetadataWithNotify(par2, par3, par4, 0, 2);
float var7 = 0.7F;
double var8 =
(double) (par1World.rand.nextFloat() * var7) + (double) (1.0F - var7) * 0.5D;
double var10 =
(double) (par1World.rand.nextFloat() * var7) + (double) (1.0F - var7) * 0.2D + 0.6D;
double var12 =
(double) (par1World.rand.nextFloat() * var7) + (double) (1.0F - var7) * 0.5D;
ItemStack var14 = var6.copy();
EntityItem var15 =
new EntityItem(
par1World,
(double) par2 + var8,
(double) par3 + var10,
(double) par4 + var12,
var14);
var15.delayBeforeCanPickup = 10;
par1World.spawnEntityInWorld(var15);
}
}
}
}
/**
* called when the player releases the use item button. Args: itemstack, world, entityplayer,
* itemInUseCount
*/
public void onPlayerStoppedUsing(
ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer, int par4) {
boolean flag =
par3EntityPlayer.capabilities.isCreativeMode
|| EnchantmentHelper.getEnchantmentLevel(Enchantment.infinity.effectId, par1ItemStack)
> 0;
if (flag || par3EntityPlayer.inventory.hasItem(Item.arrow.shiftedIndex)) {
int i = getMaxItemUseDuration(par1ItemStack) - par4;
float f = (float) i / 20F;
f = (f * f + f * 2.0F) / 3F;
if ((double) f < 0.10000000000000001D) {
return;
}
if (f > 1.0F) {
f = 1.0F;
}
EntityArrow entityarrow = new EntityArrow(par2World, par3EntityPlayer, f * 2.0F);
if (f == 1.0F) {
entityarrow.func_56125_a(true);
}
int j = EnchantmentHelper.getEnchantmentLevel(Enchantment.power.effectId, par1ItemStack);
if (j > 0) {
entityarrow.setDamage(entityarrow.getDamage() + (double) j * 0.5D + 0.5D);
}
int k = EnchantmentHelper.getEnchantmentLevel(Enchantment.punch.effectId, par1ItemStack);
if (k > 0) {
entityarrow.func_46007_b(k);
}
if (EnchantmentHelper.getEnchantmentLevel(Enchantment.flame.effectId, par1ItemStack) > 0) {
entityarrow.setFire(100);
}
par1ItemStack.damageItem(1, par3EntityPlayer);
par2World.playSoundAtEntity(
par3EntityPlayer,
"random.bow",
1.0F,
1.0F / (itemRand.nextFloat() * 0.4F + 1.2F) + f * 0.5F);
if (flag) {
entityarrow.field_58012_a = 2;
} else {
par3EntityPlayer.inventory.consumeInventoryItem(Item.arrow.shiftedIndex);
}
if (!par2World.isRemote) {
par2World.spawnEntityInWorld(entityarrow);
}
}
}
/** Dispense the specified stack, play the dispense sound and spawn particles. */
public ItemStack dispenseStack(IBlockSource par1IBlockSource, ItemStack par2ItemStack) {
EnumFacing var3 = EnumFacing.func_82600_a(par1IBlockSource.func_82620_h());
World var4 = par1IBlockSource.getWorld();
double var5 = par1IBlockSource.getX() + (double) ((float) var3.func_82601_c() * 1.125F);
double var7 = par1IBlockSource.getY();
double var9 = par1IBlockSource.getZ() + (double) ((float) var3.func_82599_e() * 1.125F);
int var11 = par1IBlockSource.getXInt() + var3.func_82601_c();
int var12 = par1IBlockSource.getYInt();
int var13 = par1IBlockSource.getZInt() + var3.func_82599_e();
Material var14 = var4.getBlockMaterial(var11, var12, var13);
double var15;
if (Material.water.equals(var14)) {
var15 = 1.0D;
} else {
if (!Material.air.equals(var14)
|| !Material.water.equals(var4.getBlockMaterial(var11, var12 - 1, var13))) {
return this.defaultItemDispenseBehavior.dispense(par1IBlockSource, par2ItemStack);
}
var15 = 0.0D;
}
EntityBoat var17 = new EntityBoat(var4, var5, var7 + var15, var9);
var4.spawnEntityInWorld(var17);
par2ItemStack.splitStack(1);
return par2ItemStack;
}
/**
* Spawns a number of villagers in this component. Parameters: world, component bounding box, x
* offset, y offset, z offset, number of villagers
*/
protected void spawnVillagers(
World par1World,
StructureBoundingBox par2StructureBoundingBox,
int par3,
int par4,
int par5,
int par6) {
if (this.villagersSpawned < par6) {
for (int var7 = this.villagersSpawned; var7 < par6; ++var7) {
int var8 = this.getXWithOffset(par3 + var7, par5);
int var9 = this.getYWithOffset(par4);
int var10 = this.getZWithOffset(par3 + var7, par5);
if (!par2StructureBoundingBox.isVecInside(var8, var9, var10)) {
break;
}
++this.villagersSpawned;
EntityVillager var11 = new EntityVillager(par1World, this.getVillagerType(var7));
var11.setLocationAndAngles(
(double) var8 + 0.5D, (double) var9, (double) var10 + 0.5D, 0.0F, 0.0F);
par1World.spawnEntityInWorld(var11);
}
}
}
/**
* called when the player releases the use item button. Args: itemstack, world, entityplayer,
* itemInUseCount
*/
public void onPlayerStoppedUsing(
ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer, int par4) {
boolean var5 =
par3EntityPlayer.capabilities.isCreativeMode
|| EnchantmentHelper.getEnchantmentLevel(Enchantment.infinity.effectId, par1ItemStack)
> 0;
if (var5 || par3EntityPlayer.inventory.hasItem(Item.arrow.shiftedIndex)) {
int var6 = this.getMaxItemUseDuration(par1ItemStack) - par4;
float var7 = (float) var6 / 20.0F;
var7 = (var7 * var7 + var7 * 2.0F) / 3.0F;
if ((double) var7 < 0.1D) {
return;
}
if (var7 > 1.0F) {
var7 = 1.0F;
}
EntityArrow var8 = new EntityArrow(par2World, par3EntityPlayer, var7 * 2.0F);
if (var7 == 1.0F) {
var8.setIsCritical(true);
}
int var9 = EnchantmentHelper.getEnchantmentLevel(Enchantment.power.effectId, par1ItemStack);
if (var9 > 0) {
var8.setDamage(var8.getDamage() + (double) var9 * 0.5D + 0.5D);
}
int var10 = EnchantmentHelper.getEnchantmentLevel(Enchantment.punch.effectId, par1ItemStack);
if (var10 > 0) {
var8.setKnockbackStrength(var10);
}
if (EnchantmentHelper.getEnchantmentLevel(Enchantment.flame.effectId, par1ItemStack) > 0) {
var8.setFire(100);
}
par1ItemStack.damageItem(1, par3EntityPlayer);
par2World.playSoundAtEntity(
par3EntityPlayer,
"random.bow",
1.0F,
1.0F / (itemRand.nextFloat() * 0.4F + 1.2F) + var7 * 0.5F);
if (var5) {
var8.canBePickedUp = 2;
} else {
par3EntityPlayer.inventory.consumeInventoryItem(Item.arrow.shiftedIndex);
}
if (!par2World.isRemote) {
par2World.spawnEntityInWorld(var8);
}
}
}
/** If there is space to fall below will start this block falling */
private void tryToFall(World par1World, int par2, int par3, int par4) {
if (canFallBelow(par1World, par2, par3 - 1, par4) && par3 >= 0) {
byte var8 = 32;
if (!fallInstantly
&& par1World.checkChunksExist(
par2 - var8, par3 - var8, par4 - var8, par2 + var8, par3 + var8, par4 + var8)) {
if (!par1World.isRemote) {
EntityFallingSand var9 =
new EntityFallingSand(
par1World,
(double) ((float) par2 + 0.5F),
(double) ((float) par3 + 0.5F),
(double) ((float) par4 + 0.5F),
this.blockID,
par1World.getBlockMetadata(par2, par3, par4));
this.onStartFalling(var9);
par1World.spawnEntityInWorld(var9);
}
} else {
par1World.setBlockWithNotify(par2, par3, par4, 0);
while (canFallBelow(par1World, par2, par3 - 1, par4) && par3 > 0) {
--par3;
}
if (par3 > 0) {
par1World.setBlockWithNotify(par2, par3, par4, this.blockID);
}
}
}
}
/** Drops an item at the position of the entity. */
public EntityItem entityDropItem(ItemStack par1ItemStack, float par2) {
EntityItem entityitem =
new EntityItem(worldObj, posX, posY + (double) par2, posZ, par1ItemStack);
entityitem.delayBeforeCanPickup = 10;
worldObj.spawnEntityInWorld(entityitem);
return entityitem;
}
/** determines if a skeleton spawns on a spider, and if a sheep is a different color */
private static void creatureSpecificInit(
EntityLiving par0EntityLiving, World par1World, float par2, float par3, float par4) {
if ((par0EntityLiving instanceof EntitySpider) && par1World.rand.nextInt(100) == 0) {
EntitySkeleton entityskeleton = new EntitySkeleton(par1World);
entityskeleton.setLocationAndAngles(par2, par3, par4, par0EntityLiving.rotationYaw, 0.0F);
par1World.spawnEntityInWorld(entityskeleton);
entityskeleton.mountEntity(par0EntityLiving);
} else if (par0EntityLiving instanceof EntitySheep) {
((EntitySheep) par0EntityLiving)
.setFleeceColor(EntitySheep.getRandomFleeceColor(par1World.rand));
} else if ((par0EntityLiving instanceof EntityOcelot) && par1World.rand.nextInt(7) == 0) {
for (int i = 0; i < 2; i++) {
EntityOcelot entityocelot = new EntityOcelot(par1World);
entityocelot.setLocationAndAngles(par2, par3, par4, par0EntityLiving.rotationYaw, 0.0F);
entityocelot.setGrowingAge(-24000);
par1World.spawnEntityInWorld(entityocelot);
}
}
}
/** Called right before the block is destroyed by a player. Args: world, x, y, z, metaData */
public void onBlockDestroyedByPlayer(World par1World, int par2, int par3, int par4, int par5) {
if (!par1World.isRemote) {
EntitySilverfish entitysilverfish = new EntitySilverfish(par1World);
entitysilverfish.setLocationAndAngles(
(double) par2 + 0.5D, par3, (double) par4 + 0.5D, 0.0F, 0.0F);
par1World.spawnEntityInWorld(entitysilverfish);
entitysilverfish.spawnExplosionParticle();
}
super.onBlockDestroyedByPlayer(par1World, par2, par3, par4, par5);
}
@Override
public void harvestBlock(World world, EntityPlayer entityplayer, int i, int j, int k, int l) {
// we need to make sure the player has the correct tool out
boolean isAxeorSaw = false;
boolean isHammer = false;
ItemStack equip = entityplayer.getCurrentEquippedItem();
if (!world.isRemote) {
if (equip != null) {
for (int cnt = 0; cnt < Recipes.Axes.length && !isAxeorSaw; cnt++) {
if (equip.getItem() == Recipes.Axes[cnt]) {
isAxeorSaw = true;
if (cnt < 4) isStone = true;
}
}
// for(int cnt = 0; cnt < Recipes.Saws.length && !isAxeorSaw; cnt++)
// {
// if(equip.getItem() == Recipes.Saws[cnt])
// {
// isAxeorSaw = true;
// }
// }
for (int cnt = 0; cnt < Recipes.Hammers.length && !isAxeorSaw; cnt++) {
if (equip.getItem() == Recipes.Hammers[cnt]) {
isHammer = true;
}
}
}
if (isAxeorSaw) {
damage = -1;
ProcessTree(world, i, j, k, l, equip);
if (damage + equip.getItemDamage() > equip.getMaxDamage()) {
int ind = entityplayer.inventory.currentItem;
entityplayer.inventory.setInventorySlotContents(ind, null);
world.setBlockAndMetadataWithNotify(i, j, k, blockID, l, 3);
} else {
equip.damageItem(damage, entityplayer);
}
} else if (isHammer) {
EntityItem item =
new EntityItem(
world,
i + 0.5,
j + 0.5,
k + 0.5,
new ItemStack(Item.stick, 1 + world.rand.nextInt(3)));
world.spawnEntityInWorld(item);
} else {
world.setBlockAndMetadataWithNotify(i, j, k, blockID, l, 3);
}
}
}
public void onBlockDestroyedByPlayer(World world, int i, int j, int k, int l) {
if (world.multiplayerWorld) {
return;
}
if ((l & 1) == 0) {
dropBlockAsItem_do(world, i, j, k, new ItemStack(Block.tnt.blockID, 1, 0));
} else {
EntityTNTPrimed entitytntprimed =
new EntityTNTPrimed(world, (float) i + 0.5F, (float) j + 0.5F, (float) k + 0.5F);
world.spawnEntityInWorld(entitytntprimed);
world.playSoundAtEntity(entitytntprimed, "random.fuse", 1.0F, 1.0F);
}
}
public void explode(World worldIn, BlockPos pos, IBlockState state, EntityLivingBase igniter) {
if (!worldIn.isRemote) {
if (((Boolean) state.getValue(EXPLODE)).booleanValue()) {
// float power = 2F + (((5000) / 10369F) * 18F);
// ProcessHandler.addProcess(new NuclearExplosion(worldIn, pos.getX(), pos.getY(),
// pos.getZ(), power));
EntityNukePrimed entitytntprimed =
new EntityNukePrimed(
worldIn, pos.getX() + 0.5F, pos.getY() + 0.5F, pos.getZ() + 0.5F, igniter);
worldIn.spawnEntityInWorld(entitytntprimed);
worldIn.playSoundAtEntity(entitytntprimed, "game.tnt.primed", 1.0F, 1.0F);
}
}
}
/** Called upon the block being destroyed by an explosion */
public void onBlockDestroyedByExplosion(
World par1World, int par2, int par3, int par4, Explosion par5Explosion) {
if (!par1World.isRemote) {
EntityTNTPrimed var6 =
new EntityTNTPrimed(
par1World,
(double) ((float) par2 + 0.5F),
(double) ((float) par3 + 0.5F),
(double) ((float) par4 + 0.5F),
par5Explosion.func_94613_c());
var6.fuse = par1World.rand.nextInt(var6.fuse / 4) + var6.fuse / 8;
par1World.spawnEntityInWorld(var6);
}
}
public static boolean func_48440_a(
World par0World, int par1, double par2, double par4, double par6) {
if (!EntityList.entityEggs.containsKey(Integer.valueOf(par1))) {
return false;
} else {
Entity var8 = EntityList.createEntityByID(par1, par0World);
if (var8 != null) {
var8.setLocationAndAngles(par2, par4, par6, par0World.rand.nextFloat() * 360.0F, 0.0F);
par0World.spawnEntityInWorld(var8);
((EntityLiving) var8).playLivingSound();
}
return var8 != null;
}
}
@Override
public void onBlockDestroyedByExplosion(World worldIn, BlockPos pos, Explosion explosionIn) {
if (!worldIn.isRemote) {
EntityNukePrimed entitytntprimed =
new EntityNukePrimed(
worldIn,
pos.getX() + 0.5F,
pos.getY() + 0.5F,
pos.getZ() + 0.5F,
explosionIn.getExplosivePlacedBy());
entitytntprimed.fuse =
worldIn.rand.nextInt(entitytntprimed.fuse / 4) + entitytntprimed.fuse / 8;
worldIn.spawnEntityInWorld(entitytntprimed);
}
}
public void func_94391_a(
World par1World, int par2, int par3, int par4, int par5, EntityLiving par6EntityLiving) {
if (!par1World.isRemote) {
if ((par5 & 1) == 1) {
EntityTNTPrimed var7 =
new EntityTNTPrimed(
par1World,
(double) ((float) par2 + 0.5F),
(double) ((float) par3 + 0.5F),
(double) ((float) par4 + 0.5F),
par6EntityLiving);
par1World.spawnEntityInWorld(var7);
par1World.playSoundAtEntity(var7, "random.fuse", 1.0F, 1.0F);
}
}
}
/**
* Callback for item usage. If the item does something special on right clicking, he will have one
* of those. Return True if something happen and false if it don't. This is for ITEMS, not BLOCKS
*/
public boolean onItemUse(
ItemStack par1ItemStack,
EntityPlayer par2EntityPlayer,
World par3World,
int par4,
int par5,
int par6,
int par7,
float par8,
float par9,
float par10) {
if (par7 == 0) {
return false;
} else if (par7 == 1) {
return false;
} else {
byte var11 = 0;
if (par7 == 4) {
var11 = 1;
}
if (par7 == 3) {
var11 = 2;
}
if (par7 == 5) {
var11 = 3;
}
if (!par2EntityPlayer.canPlayerEdit(par4, par5, par6)) {
return false;
} else {
EntityPainting var12 = new EntityPainting(par3World, par4, par5, par6, var11);
if (var12.onValidSurface()) {
if (!par3World.isRemote) {
par3World.spawnEntityInWorld(var12);
}
--par1ItemStack.stackSize;
}
return true;
}
}
}
@Override
public void breakBlock(World world, int x, int y, int z, int i1, int i2) {
TileEntityBasicMachine tileEntity = (TileEntityBasicMachine) world.getBlockTileEntity(x, y, z);
if (tileEntity != null) {
for (int i = 0; i < tileEntity.getSizeInventory(); ++i) {
ItemStack slotStack = tileEntity.getStackInSlot(i);
if (slotStack != null) {
float xRandom = machineRand.nextFloat() * 0.8F + 0.1F;
float yRandom = machineRand.nextFloat() * 0.8F + 0.1F;
float zRandom = machineRand.nextFloat() * 0.8F + 0.1F;
while (slotStack.stackSize > 0) {
int j = machineRand.nextInt(21) + 10;
if (j > slotStack.stackSize) {
j = slotStack.stackSize;
}
slotStack.stackSize -= j;
EntityItem item =
new EntityItem(
world,
(double) ((float) x + xRandom),
(double) ((float) y + yRandom),
(double) ((float) z + zRandom),
new ItemStack(slotStack.itemID, j, slotStack.getItemDamage()));
if (slotStack.hasTagCompound()) {
item.item.setTagCompound((NBTTagCompound) slotStack.getTagCompound().copy());
}
float k = 0.05F;
item.motionX = (double) ((float) machineRand.nextGaussian() * k);
item.motionY = (double) ((float) machineRand.nextGaussian() * k + 0.2F);
item.motionZ = (double) ((float) machineRand.nextGaussian() * k);
world.spawnEntityInWorld(item);
}
}
}
tileEntity.invalidate();
}
super.breakBlock(world, x, y, z, i1, i2);
}
/** ejects contained items into the world, and notifies neighbours of an update, as appropriate */
public void breakBlock(World par1World, int par2, int par3, int par4, int par5, int par6) {
TileEntityChest var7 = (TileEntityChest) par1World.getBlockTileEntity(par2, par3, par4);
if (var7 != null) {
for (int var8 = 0; var8 < var7.getSizeInventory(); ++var8) {
ItemStack var9 = var7.getStackInSlot(var8);
if (var9 != null) {
float var10 = this.random.nextFloat() * 0.8F + 0.1F;
float var11 = this.random.nextFloat() * 0.8F + 0.1F;
EntityItem var14;
for (float var12 = this.random.nextFloat() * 0.8F + 0.1F;
var9.stackSize > 0;
par1World.spawnEntityInWorld(var14)) {
int var13 = this.random.nextInt(21) + 10;
if (var13 > var9.stackSize) {
var13 = var9.stackSize;
}
var9.stackSize -= var13;
var14 =
new EntityItem(
par1World,
(double) ((float) par2 + var10),
(double) ((float) par3 + var11),
(double) ((float) par4 + var12),
new ItemStack(var9.itemID, var13, var9.getItemDamage()));
float var15 = 0.05F;
var14.motionX = (double) ((float) this.random.nextGaussian() * var15);
var14.motionY = (double) ((float) this.random.nextGaussian() * var15 + 0.2F);
var14.motionZ = (double) ((float) this.random.nextGaussian() * var15);
if (var9.hasTagCompound()) {
var14.getEntityItem().setTagCompound((NBTTagCompound) var9.getTagCompound().copy());
}
}
}
}
}
super.breakBlock(par1World, par2, par3, par4, par5, par6);
}
@Override
public boolean generate(World par1World, Random par2Random, int par3, int par4, int par5) {
if (!par1World.isAirBlock(par3, par4, par5)
|| par1World.getBlockId(par3, par4 - 1, par5) != this.replaceID) {
return false;
}
int i = par2Random.nextInt(32) + 6;
int j = par2Random.nextInt(4) + 1;
for (int k = par3 - j; k <= par3 + j; k++) {
for (int i1 = par5 - j; i1 <= par5 + j; i1++) {
int k1 = k - par3;
int i2 = i1 - par5;
if (k1 * k1 + i2 * i2 <= j * j + 1
&& par1World.getBlockId(k, par4 - 1, i1) != this.replaceID) {
return false;
}
}
}
for (int l = par4; l < par4 + i && l < 128; l++) {
for (int j1 = par3 - j; j1 <= par3 + j; j1++) {
for (int l1 = par5 - j; l1 <= par5 + j; l1++) {
int j2 = j1 - par3;
int k2 = l1 - par5;
if (j2 * j2 + k2 * k2 <= j * j + 1) {
par1World.setBlockWithNotify(j1, l, l1, Block.obsidian.blockID);
}
}
}
}
EntityEnderCrystal entityendercrystal = new EntityEnderCrystal(par1World);
entityendercrystal.setLocationAndAngles(
par3 + 0.5F, par4 + i, par5 + 0.5F, par2Random.nextFloat() * 360F, 0.0F);
par1World.spawnEntityInWorld(entityendercrystal);
par1World.setBlockWithNotify(par3, par4 + i, par5, Block.bedrock.blockID);
return true;
}
protected void spawnVillagers(
World world, StructureBoundingBox structureboundingbox, int i, int j, int k, int l) {
if (villagersSpawned >= l) {
return;
}
int i1 = villagersSpawned;
do {
if (i1 >= l) {
break;
}
int j1 = getXWithOffset(i + i1, k);
int k1 = getYWithOffset(j);
int l1 = getZWithOffset(i + i1, k);
if (!structureboundingbox.isVecInside(j1, k1, l1)) {
break;
}
villagersSpawned++;
EntityVillager entityvillager = new EntityVillager(world, getVillagerType(i1));
entityvillager.setLocationAndAngles((double) j1 + 0.5D, k1, (double) l1 + 0.5D, 0.0F, 0.0F);
world.spawnEntityInWorld(entityvillager);
i1++;
} while (true);
}
/** Drops the block items with a specified chance of dropping the specified items */
public void dropBlockAsItemWithChance(
World par1World, int par2, int par3, int par4, int par5, float par6, int par7) {
super.dropBlockAsItemWithChance(par1World, par2, par3, par4, par5, par6, par7);
if (par1World.isRemote) {
return;
}
Item item = null;
if (fruitType == Block.pumpkin) {
item = Item.pumpkinSeeds;
}
if (fruitType == Block.melon) {
item = Item.melonSeeds;
}
for (int i = 0; i < 3; i++) {
if (par1World.rand.nextInt(15) <= par5) {
float f = 0.7F;
float f1 = par1World.rand.nextFloat() * f + (1.0F - f) * 0.5F;
float f2 = par1World.rand.nextFloat() * f + (1.0F - f) * 0.5F;
float f3 = par1World.rand.nextFloat() * f + (1.0F - f) * 0.5F;
EntityItem entityitem =
new EntityItem(
par1World,
(float) par2 + f1,
(float) par3 + f2,
(float) par4 + f3,
new ItemStack(item));
entityitem.delayBeforeCanPickup = 10;
par1World.spawnEntityInWorld(entityitem);
}
}
}
/** The main spawning algorithm, spawns three random creatures of types in the subclass array */
public static final int performSpawning(World par0World, boolean par1, boolean par2) {
if (!par1 && !par2) {
return 0;
} else {
eligibleChunksForSpawning.clear();
int var3;
int var6;
for (var3 = 0; var3 < par0World.playerEntities.size(); ++var3) {
EntityPlayer var4 = (EntityPlayer) par0World.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 = par0World.getSpawnPoint();
EnumCreatureType[] var32 = EnumCreatureType.values();
var6 = var32.length;
for (int var33 = 0; var33 < var6; ++var33) {
EnumCreatureType var34 = var32[var33];
if ((!var34.getPeacefulCreature() || par2)
&& (var34.getPeacefulCreature() || par1)
&& par0World.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(par0World, var37.chunkXPos, var37.chunkZPos);
int var12 = var36.x;
int var13 = var36.y;
int var14 = var36.z;
if (!par0World.isBlockNormalCube(var12, var13, var14)
&& par0World.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;
int var22 = 0;
while (true) {
if (var22 < 4) {
label101:
{
var17 += par0World.rand.nextInt(var20) - par0World.rand.nextInt(var20);
var18 += par0World.rand.nextInt(1) - par0World.rand.nextInt(1);
var19 += par0World.rand.nextInt(var20) - par0World.rand.nextInt(var20);
if (canCreatureTypeSpawnAtLocation(var34, par0World, var17, var18, var19)) {
float var23 = (float) var17 + 0.5F;
float var24 = (float) var18;
float var25 = (float) var19 + 0.5F;
if (par0World.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 = par0World.getRandomMob(var34, var17, var18, var19);
if (var21 == null) {
break label101;
}
}
EntityLiving var38;
try {
var38 =
(EntityLiving)
var21
.entityClass
.getConstructor(new Class[] {World.class})
.newInstance(new Object[] {par0World});
} catch (Exception var30) {
var30.printStackTrace();
return var3;
}
var38.setLocationAndAngles(
(double) var23,
(double) var24,
(double) var25,
par0World.rand.nextFloat() * 360.0F,
0.0F);
if (var38.getCanSpawnHere()) {
++var15;
par0World.spawnEntityInWorld(var38);
creatureSpecificInit(var38, par0World, var23, var24, var25);
if (var15 >= var38.getMaxSpawnedInChunk()) {
continue label108;
}
}
var3 += var15;
}
}
}
++var22;
continue;
}
}
++var16;
break;
}
}
}
}
}
}
}
return var3;
}
}
/** This method attempts to create a wither at the given location and skull */
public void makeWither(
World par1World, int par2, int par3, int par4, TileEntitySkull par5TileEntitySkull) {
if (par5TileEntitySkull.func_82117_a() == 1 && par3 >= 2 && par1World.difficultySetting > 0) {
int var6 = Block.slowSand.blockID;
int var7;
EntityWither var8;
int var9;
for (var7 = -2; var7 <= 0; ++var7) {
if (par1World.getBlockId(par2, par3 - 1, par4 + var7) == var6
&& par1World.getBlockId(par2, par3 - 1, par4 + var7 + 1) == var6
&& par1World.getBlockId(par2, par3 - 2, par4 + var7 + 1) == var6
&& par1World.getBlockId(par2, par3 - 1, par4 + var7 + 2) == var6
&& this.func_82528_d(par1World, par2, par3, par4 + var7, 1)
&& this.func_82528_d(par1World, par2, par3, par4 + var7 + 1, 1)
&& this.func_82528_d(par1World, par2, par3, par4 + var7 + 2, 1)) {
par1World.setBlockMetadata(par2, par3, par4 + var7, 8);
par1World.setBlockMetadata(par2, par3, par4 + var7 + 1, 8);
par1World.setBlockMetadata(par2, par3, par4 + var7 + 2, 8);
par1World.setBlock(par2, par3, par4 + var7, 0);
par1World.setBlock(par2, par3, par4 + var7 + 1, 0);
par1World.setBlock(par2, par3, par4 + var7 + 2, 0);
par1World.setBlock(par2, par3 - 1, par4 + var7, 0);
par1World.setBlock(par2, par3 - 1, par4 + var7 + 1, 0);
par1World.setBlock(par2, par3 - 1, par4 + var7 + 2, 0);
par1World.setBlock(par2, par3 - 2, par4 + var7 + 1, 0);
if (!par1World.isRemote) {
var8 = new EntityWither(par1World);
var8.setLocationAndAngles(
(double) par2 + 0.5D,
(double) par3 - 1.45D,
(double) (par4 + var7) + 1.5D,
90.0F,
0.0F);
var8.renderYawOffset = 90.0F;
var8.func_82206_m();
par1World.spawnEntityInWorld(var8);
}
for (var9 = 0; var9 < 120; ++var9) {
par1World.spawnParticle(
"snowballpoof",
(double) par2 + par1World.rand.nextDouble(),
(double) (par3 - 2) + par1World.rand.nextDouble() * 3.9D,
(double) (par4 + var7 + 1) + par1World.rand.nextDouble(),
0.0D,
0.0D,
0.0D);
}
par1World.notifyBlockChange(par2, par3, par4 + var7, 0);
par1World.notifyBlockChange(par2, par3, par4 + var7 + 1, 0);
par1World.notifyBlockChange(par2, par3, par4 + var7 + 2, 0);
par1World.notifyBlockChange(par2, par3 - 1, par4 + var7, 0);
par1World.notifyBlockChange(par2, par3 - 1, par4 + var7 + 1, 0);
par1World.notifyBlockChange(par2, par3 - 1, par4 + var7 + 2, 0);
par1World.notifyBlockChange(par2, par3 - 2, par4 + var7 + 1, 0);
return;
}
}
for (var7 = -2; var7 <= 0; ++var7) {
if (par1World.getBlockId(par2 + var7, par3 - 1, par4) == var6
&& par1World.getBlockId(par2 + var7 + 1, par3 - 1, par4) == var6
&& par1World.getBlockId(par2 + var7 + 1, par3 - 2, par4) == var6
&& par1World.getBlockId(par2 + var7 + 2, par3 - 1, par4) == var6
&& this.func_82528_d(par1World, par2 + var7, par3, par4, 1)
&& this.func_82528_d(par1World, par2 + var7 + 1, par3, par4, 1)
&& this.func_82528_d(par1World, par2 + var7 + 2, par3, par4, 1)) {
par1World.setBlockMetadata(par2 + var7, par3, par4, 8);
par1World.setBlockMetadata(par2 + var7 + 1, par3, par4, 8);
par1World.setBlockMetadata(par2 + var7 + 2, par3, par4, 8);
par1World.setBlock(par2 + var7, par3, par4, 0);
par1World.setBlock(par2 + var7 + 1, par3, par4, 0);
par1World.setBlock(par2 + var7 + 2, par3, par4, 0);
par1World.setBlock(par2 + var7, par3 - 1, par4, 0);
par1World.setBlock(par2 + var7 + 1, par3 - 1, par4, 0);
par1World.setBlock(par2 + var7 + 2, par3 - 1, par4, 0);
par1World.setBlock(par2 + var7 + 1, par3 - 2, par4, 0);
if (!par1World.isRemote) {
var8 = new EntityWither(par1World);
var8.setLocationAndAngles(
(double) (par2 + var7) + 1.5D,
(double) par3 - 1.45D,
(double) par4 + 0.5D,
0.0F,
0.0F);
var8.func_82206_m();
par1World.spawnEntityInWorld(var8);
}
for (var9 = 0; var9 < 120; ++var9) {
par1World.spawnParticle(
"snowballpoof",
(double) (par2 + var7 + 1) + par1World.rand.nextDouble(),
(double) (par3 - 2) + par1World.rand.nextDouble() * 3.9D,
(double) par4 + par1World.rand.nextDouble(),
0.0D,
0.0D,
0.0D);
}
par1World.notifyBlockChange(par2 + var7, par3, par4, 0);
par1World.notifyBlockChange(par2 + var7 + 1, par3, par4, 0);
par1World.notifyBlockChange(par2 + var7 + 2, par3, par4, 0);
par1World.notifyBlockChange(par2 + var7, par3 - 1, par4, 0);
par1World.notifyBlockChange(par2 + var7 + 1, par3 - 1, par4, 0);
par1World.notifyBlockChange(par2 + var7 + 2, par3 - 1, par4, 0);
par1World.notifyBlockChange(par2 + var7 + 1, par3 - 2, par4, 0);
return;
}
}
}
}
public void onBlockDestroyedByExplosion(World world, int i, int j, int k) {
EntityTNTPrimed entitytntprimed =
new EntityTNTPrimed(world, (float) i + 0.5F, (float) j + 0.5F, (float) k + 0.5F);
entitytntprimed.fuse = world.rand.nextInt(entitytntprimed.fuse / 4) + entitytntprimed.fuse / 8;
world.spawnEntityInWorld(entitytntprimed);
}
/** 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++;
}
}
}
/** Called upon block activation (right click on the block.) */
public boolean onBlockActivated(
World par1World,
int par2,
int par3,
int par4,
EntityPlayer par5EntityPlayer,
int par6,
float par7,
float par8,
float par9) {
if (par1World.isRemote) {
return true;
} else {
ItemStack var10 = par5EntityPlayer.inventory.getCurrentItem();
if (var10 == null) {
return true;
} else {
int var11 = par1World.getBlockMetadata(par2, par3, par4);
if (var10.itemID == Item.bucketWater.shiftedIndex) {
if (var11 < 3) {
if (!par5EntityPlayer.capabilities.isCreativeMode) {
par5EntityPlayer.inventory.setInventorySlotContents(
par5EntityPlayer.inventory.currentItem, new ItemStack(Item.bucketEmpty));
}
par1World.setBlockMetadataWithNotify(par2, par3, par4, 3);
}
return true;
} else {
if (var10.itemID == Item.glassBottle.shiftedIndex && var11 > 0) {
ItemStack var12 = new ItemStack(Item.potion, 1, 0);
if (!par5EntityPlayer.inventory.addItemStackToInventory(var12)) {
par1World.spawnEntityInWorld(
new EntityItem(
par1World,
(double) par2 + 0.5D,
(double) par3 + 1.5D,
(double) par4 + 0.5D,
var12));
} else if (par5EntityPlayer instanceof EntityPlayerMP) {
((EntityPlayerMP) par5EntityPlayer)
.sendContainerToPlayer(par5EntityPlayer.inventorySlots);
}
--var10.stackSize;
if (var10.stackSize <= 0) {
par5EntityPlayer.inventory.setInventorySlotContents(
par5EntityPlayer.inventory.currentItem, (ItemStack) null);
}
par1World.setBlockMetadataWithNotify(par2, par3, par4, var11 - 1);
}
return true;
}
}
}
}
/** Called whenever the block is added into the world. Args: world, x, y, z */
public void onBlockAdded(World par1World, int par2, int par3, int par4) {
super.onBlockAdded(par1World, par2, par3, par4);
if (par1World.getBlockId(par2, par3 - 1, par4) == Block.blockSnow.blockID
&& par1World.getBlockId(par2, par3 - 2, par4) == Block.blockSnow.blockID) {
if (!par1World.isRemote) {
par1World.setBlock(par2, par3, par4, 0);
par1World.setBlock(par2, par3 - 1, par4, 0);
par1World.setBlock(par2, par3 - 2, par4, 0);
EntitySnowman entitysnowman = new EntitySnowman(par1World);
entitysnowman.setLocationAndAngles(
(double) par2 + 0.5D, (double) par3 - 1.95D, (double) par4 + 0.5D, 0.0F, 0.0F);
par1World.spawnEntityInWorld(entitysnowman);
par1World.notifyBlockChange(par2, par3, par4, 0);
par1World.notifyBlockChange(par2, par3 - 1, par4, 0);
par1World.notifyBlockChange(par2, par3 - 2, par4, 0);
}
for (int i = 0; i < 120; i++) {
par1World.spawnParticle(
"snowshovel",
(double) par2 + par1World.rand.nextDouble(),
(double) (par3 - 2) + par1World.rand.nextDouble() * 2.5D,
(double) par4 + par1World.rand.nextDouble(),
0.0D,
0.0D,
0.0D);
}
} else if (par1World.getBlockId(par2, par3 - 1, par4) == Block.blockSteel.blockID
&& par1World.getBlockId(par2, par3 - 2, par4) == Block.blockSteel.blockID) {
boolean flag =
par1World.getBlockId(par2 - 1, par3 - 1, par4) == Block.blockSteel.blockID
&& par1World.getBlockId(par2 + 1, par3 - 1, par4) == Block.blockSteel.blockID;
boolean flag1 =
par1World.getBlockId(par2, par3 - 1, par4 - 1) == Block.blockSteel.blockID
&& par1World.getBlockId(par2, par3 - 1, par4 + 1) == Block.blockSteel.blockID;
if (flag || flag1) {
par1World.setBlock(par2, par3, par4, 0);
par1World.setBlock(par2, par3 - 1, par4, 0);
par1World.setBlock(par2, par3 - 2, par4, 0);
if (flag) {
par1World.setBlock(par2 - 1, par3 - 1, par4, 0);
par1World.setBlock(par2 + 1, par3 - 1, par4, 0);
} else {
par1World.setBlock(par2, par3 - 1, par4 - 1, 0);
par1World.setBlock(par2, par3 - 1, par4 + 1, 0);
}
EntityIronGolem entityirongolem = new EntityIronGolem(par1World);
entityirongolem.func_48115_b(true);
entityirongolem.setLocationAndAngles(
(double) par2 + 0.5D, (double) par3 - 1.95D, (double) par4 + 0.5D, 0.0F, 0.0F);
par1World.spawnEntityInWorld(entityirongolem);
for (int j = 0; j < 120; j++) {
par1World.spawnParticle(
"snowballpoof",
(double) par2 + par1World.rand.nextDouble(),
(double) (par3 - 2) + par1World.rand.nextDouble() * 3.8999999999999999D,
(double) par4 + par1World.rand.nextDouble(),
0.0D,
0.0D,
0.0D);
}
par1World.notifyBlockChange(par2, par3, par4, 0);
par1World.notifyBlockChange(par2, par3 - 1, par4, 0);
par1World.notifyBlockChange(par2, par3 - 2, par4, 0);
if (flag) {
par1World.notifyBlockChange(par2 - 1, par3 - 1, par4, 0);
par1World.notifyBlockChange(par2 + 1, par3 - 1, par4, 0);
} else {
par1World.notifyBlockChange(par2, par3 - 1, par4 - 1, 0);
par1World.notifyBlockChange(par2, par3 - 1, par4 + 1, 0);
}
}
}
}
