/** 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, par4) == this.blockID) {
par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, this.tickRate(par1World));
}
}
/** Switches active state of button or lever at x/y/z to and notifies neighbors */
public static void activateButton(World world, Block block, int x, int y, int z) {
int meta = world.getBlockMetadata(x, y, z);
world.setBlockMetadataWithNotify(x, y, z, (meta < 8 ? meta | 8 : meta & ~8), 3);
// func_147479_m is markBlockForRenderUpdate
world.func_147479_m(x, y, z);
world.playSoundEffect(
(double) x + 0.5D, (double) y + 0.5D, (double) z + 0.5D, Sounds.CLICK, 0.3F, 0.6F);
world.scheduleBlockUpdate(x, y, z, block, block.tickRate(world));
world.notifyBlocksOfNeighborChange(x, y, z, block);
switch (meta & 7) {
case 0: // 0 and 7 are ceiling levers
case 7:
world.notifyBlocksOfNeighborChange(x, y + 1, z, block);
break;
case 1:
world.notifyBlocksOfNeighborChange(x - 1, y, z, block);
break;
case 2:
world.notifyBlocksOfNeighborChange(x + 1, y, z, block);
break;
case 3:
world.notifyBlocksOfNeighborChange(x, y, z - 1, block);
break;
case 4:
world.notifyBlocksOfNeighborChange(x, y, z + 1, block);
break;
default:
world.notifyBlocksOfNeighborChange(x, y - 1, z, block);
}
}
@Override
public void onBlockAdded(World world, int x, int y, int z) {
// System.out.println("x: "+x+", y: "+y+", z: "+z);
super.onBlockAdded(world, x, y, z);
if (world.getBlockId(x, y, z) == blockID) {
world.scheduleBlockUpdate(x, y, z, blockID, tickRate());
}
}
/** Changes the block ID to that of an updating fluid. */
private void setNotStationary(World par1World, int par2, int par3, int par4) {
int var5 = par1World.getBlockMetadata(par2, par3, par4);
par1World.editingBlocks = true;
par1World.setBlockAndMetadata(par2, par3, par4, this.blockID - 1, var5);
par1World.markBlockRangeForRenderUpdate(par2, par3, par4, par2, par3, par4);
par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID - 1, this.tickRate());
par1World.editingBlocks = false;
}
@Override
public void updateTick(World world, int i, int j, int k, Random random) {
world.setBlockMetadataWithNotify(i, j, k, 1, 2);
world.notifyBlocksOfNeighborChange(i, j, k, blockID);
world.notifyBlocksOfNeighborChange(i, j - 1, k, blockID);
world.markBlockRangeForRenderUpdate(i, j, k, i, j, k);
world.scheduleBlockUpdate(i, j, k, blockID, this.tickRate(world));
}
public void onNeighborBlockChange(World world, int i, int j, int k, int l) {
if (l > 0 && Block.blocksList[l].canProvidePower()) {
// Which direction the power can come from, i is the x coord, j is y, and k is z.
boolean flag =
world.isBlockIndirectlyGettingPowered(i, j, k)
|| world.isBlockIndirectlyGettingPowered(i, j - 1, k);
if (flag) {
world.scheduleBlockUpdate(i, j, k, blockID, tickRate());
}
}
}
/** 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) {
if (!par1World.isRemote) {
if (this.powered && !par1World.isBlockIndirectlyGettingPowered(par2, par3, par4)) {
par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, 4);
} else if (!this.powered && par1World.isBlockIndirectlyGettingPowered(par2, par3, par4)) {
int m = par1World.getBlockMetadata(par2, par3, par4);
par1World.setBlockAndMetadataWithNotify(
par2, par3, par4, MinecraftPlusBase.holidaylights_1Active.blockID, m);
}
}
}
public void updateTick(World world, int x, int y, int z, Random par5Random) {
world.scheduleBlockUpdate(x, y, z, this.blockID, this.tickRate(world));
EntitySergeantStrongstack entity = new EntitySergeantStrongstack(world);
entity.setLocationAndAngles(x, y + 1, z, world.rand.nextFloat() * 360.0F, 0.0F);
world.spawnEntityInWorld(entity);
world.setBlock(x, y + 1, z, 0);
world.setBlock(x, y + 2, z, 0);
world.setBlock(x, y + 3, z, 0);
// world.setBlock(x, y, z, 0);
}
public void onBlockAdded(World par1World, int par2, int par3, int par4) {
/** Change these to your portal frame and Portal block * */
if ((par1World.getBlockId(par2, par3 - 1, par4) != Block.blockDiamond.blockID)
|| (!Main.TutorialPortal1.tryToCreatePortal(par1World, par2, par3, par4))) {
if ((!par1World.doesBlockHaveSolidTopSurface(par2, par3 - 1, par4))
&& (!canNeighborBurn(par1World, par2, par3, par4))) {
par1World.setBlockToAir(par2, par3, par4);
} else {
par1World.scheduleBlockUpdate(
par2, par3, par4, this.blockID, tickRate(par1World) + par1World.rand.nextInt(10));
}
}
}
@Override
public void updateTick(World world, int i, int j, int k, Random random) {
if (j < 253) {
if (world.getBlockId(i, j + 1, k) == 0) {
world.setBlockAndMetadataWithNotify(i, j + 1, k, blockID, world.getBlockMetadata(i, j, k));
world.scheduleBlockUpdate(i, j + 1, k, blockID, 5);
}
} else if (world.getBlockMetadata(i, j, k) == 1) {
world.setBlockMetadata(i, j, k, 0);
world.setBlockAndMetadataWithNotify(i, j + 1, k, TooManyPlants.objs.blockpod.blockID, 1);
world.setBlockWithNotify(i, j + 2, k, TooManyPlants.objs.blockpod.blockID);
}
}
@Override
public void onNeighborBlockChange(World par1World, int par2, int par3, int par4, Block par5) {
boolean flag =
par1World.isBlockIndirectlyGettingPowered(par2, par3, par4)
|| par1World.isBlockIndirectlyGettingPowered(par2, par3 + 1, par4);
int i1 = par1World.getBlockMetadata(par2, par3, par4);
boolean flag1 = (i1 & 8) != 0;
if (flag && !flag1) {
par1World.scheduleBlockUpdate(par2, par3, par4, this, this.tickRate(par1World));
par1World.setBlockMetadataWithNotify(par2, par3, par4, i1 | 8, 4);
} else if (!flag && flag1) {
par1World.setBlockMetadataWithNotify(par2, par3, par4, i1 & -9, 4);
}
}
@Override
public int onBlockPlaced(
World world,
int int1,
int int2,
int int3,
int int4,
float float1,
float float2,
float float3,
int int5) {
world.scheduleBlockUpdate(int1, int2, int3, this, 1);
return int5;
}
public boolean onBlockActivated(
World par1World,
int par2,
int par3,
int par4,
EntityPlayer par5EntityPlayer,
int par6,
float par7,
float par8,
float par9) {
{
par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, this.tickRate(par1World));
return true;
}
}
/** Called whenever the block is added into the world. Args: world, x, y, z */
@Override
public void onBlockAdded(World par1World, int par2, int par3, int par4) {
if (par1World.worldProvider.worldType <= 0
&& par1World.getBlockId(par2, par3 - 1, par4) == Block.obsidian.blockID
&& ((BlockPortal) Block.portal).tryToCreatePortal(par1World, par2, par3, par4)) {
return;
}
if (!par1World.isBlockNormalCube(par2, par3 - 1, par4)
&& !canNeighborBurn(par1World, par2, par3, par4)) {
par1World.setBlockWithNotify(par2, par3, par4, 0);
return;
} else {
par1World.scheduleBlockUpdate(
par2, par3, par4, blockID, tickRate() + par1World.rand.nextInt(10));
return;
}
}
@Override
public void updateTick(World var1, int var2, int var3, int var4, Random var5) {
if (var1.isRemote) return;
// var1.getBlockMetadata(var2, var3, var4);
// List var7 = var1.getEntitiesWithinAABB(EntTornado.class,
// AxisAlignedBB.getBoundingBoxFromPool((double)var2, (double)var3, (double)var4, (double)var2 +
// 1.0D, (double)var3 + 1.0D, (double)var4 + 1.0D).expand(140.0D, 140.0D, 140.0D));
boolean enable = false;
WeatherManagerServer wms =
ServerTickHandler.lookupDimToWeatherMan.get(var1.provider.dimensionId);
if (wms != null) {
StormObject so =
wms.getClosestStorm(
Vec3.createVectorHelper(var2, var3, var4),
ConfigMisc.sensorActivateDistance,
StormObject.STATE_FORMING);
if (so != null /* && so.attrib_tornado_severity > 0*/) {
enable = true;
}
}
if (enable) {
var1.setBlockMetadataWithNotify(var2, var3, var4, 15, 2);
} else {
var1.setBlockMetadataWithNotify(var2, var3, var4, 0, 2);
}
/*if(var7.size() > 0) {
var1.setBlockMetadataWithNotify(var2, var3, var4, 15);
} else {
var1.setBlockMetadataWithNotify(var2, var3, var4, 0);
}*/
var1.notifyBlocksOfNeighborChange(var2, var3 - 1, var4, this);
var1.notifyBlocksOfNeighborChange(var2, var3 + 1, var4, this);
var1.notifyBlocksOfNeighborChange(var2, var3, var4, this);
var1.markBlockRangeForRenderUpdate(var2, var3, var4, var2, var3, var4);
var1.scheduleBlockUpdate(var2, var3, var4, this, this.tickRate(var1));
}
@Override
public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random) {
if (!par1World.isRemote) {
List<EntityPlayer> players =
par1World.getEntitiesWithinAABB(
EntityPlayer.class,
AxisAlignedBB.getBoundingBox(par2, par3, par4, par2 + 1, par3 + 1, par4 + 1));
if (players.isEmpty()) par1World.setBlockToAir(par2, par3, par4);
else {
boolean has = false;
for (EntityPlayer player : players)
if (player.inventory.hasItem(ModItems.brightNitor.itemID)) {
has = true;
break;
}
if (!has) par1World.setBlockToAir(par2, par3, par4);
}
par1World.scheduleBlockUpdate(par2, par3, par4, blockID, tickRate(par1World));
}
}
public void onEntityCollidedWithBlock(
World par1World, int par2, int par3, int par4, Entity par5Entity) {
if (par1World.isRemote) {
return;
} else {
if (par5Entity instanceof EntityPlayer && !deactivated) {
par1World.setBlock(par2, par3, par4, mod_SecurityCraft.deactivatedCageTrap);
par1World.scheduleBlockUpdate(
par2, par3, par4, mod_SecurityCraft.unbreakableIronBars, 1200);
par1World.setBlock(par2, par3 + 4, par4, mod_SecurityCraft.unbreakableIronBars);
par1World.scheduleBlockUpdate(
par2, par3 + 4, par4, mod_SecurityCraft.unbreakableIronBars, 1200);
par1World.setBlock(par2 + 1, par3 + 4, par4, mod_SecurityCraft.unbreakableIronBars);
par1World.scheduleBlockUpdate(
par2 + 1, par3 + 4, par4, mod_SecurityCraft.unbreakableIronBars, 1200);
par1World.setBlock(par2 - 1, par3 + 4, par4, mod_SecurityCraft.unbreakableIronBars);
par1World.scheduleBlockUpdate(
par2 - 1, par3 + 4, par4, mod_SecurityCraft.unbreakableIronBars, 1200);
par1World.setBlock(par2, par3 + 4, par4 + 1, mod_SecurityCraft.unbreakableIronBars);
par1World.scheduleBlockUpdate(
par2, par3 + 4, par4 + 1, mod_SecurityCraft.unbreakableIronBars, 1200);
par1World.setBlock(par2, par3 + 4, par4 - 1, mod_SecurityCraft.unbreakableIronBars);
par1World.scheduleBlockUpdate(
par2, par3 + 4, par4 - 1, mod_SecurityCraft.unbreakableIronBars, 1200);
HelpfulMethods.setBlockInBox(
par1World, par2, par3, par4, mod_SecurityCraft.unbreakableIronBars);
par1World.playSoundAtEntity(par5Entity, "random.anvil_use", 3.0F, 1.0F);
// ChatMessageComponent.createFromText(((EntityPlayer) par5Entity).getCommandSenderName() +
// " was captured in a trap at" + HelpfulMethods.getFormattedCoordinates(par2, par3, par4))
MinecraftServer.getServer()
.getConfigurationManager()
.sendChatMsg(
new ChatComponentTranslation(
((EntityPlayer) par5Entity).getCommandSenderName()
+ " was captured in a trap at"
+ HelpfulMethods.getFormattedCoordinates(par2, par3, par4)));
}
}
}
@Override
public void onNeighborBlockChange(World world, int i, int j, int k, int notifierID) {
if (notifierID != DECore.ElevatorButton.blockID) {
if (notifierID <= 0
|| notifierID == DECore.Elevator.blockID
|| !Block.blocksList[notifierID].canProvidePower()
|| !isBeingPoweredByNonElevator(world, i, j, k)) {
previouslyPowered = false;
return;
}
if (!previouslyPowered) {
world.scheduleBlockUpdate(i, j, k, blockID, 2);
}
} else {
boolean foundButton = false;
for (int iter = 0; iter < 6; iter++) {
int tempX = i;
int tempZ = k;
int tempY = j;
if (iter == 0) {
tempX--;
} else if (iter == 1) {
tempX++;
} else if (iter == 2) {
tempZ--;
} else if (iter == 3) {
tempZ++;
}
if (world.getBlockId(tempX, j, tempZ) == DECore.ElevatorButton.blockID
&& (world.getBlockMetadata(tempX, j, tempZ) & 8) > 0) {
foundButton = true;
}
}
if (foundButton) {
findAndActivateElevator(world, i, j, k, 0);
}
}
}
/**
* Lets the block know when one of its neighbor changes. Doesn't know which neighbor changed
* (coordinates passed are their own) Args: x, y, z, neighbor blockID
*/
public void onNeighborBlockChange(World par1World, int par2, int par3, int par4, int par5) {
if (!par1World.isRemote) {
if (this.powered && !par1World.isBlockIndirectlyGettingPowered(par2, par3, par4)) {
par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, 4);
} else if (!this.powered && par1World.isBlockIndirectlyGettingPowered(par2, par3, par4)) {
int m = par1World.getBlockMetadata(par2, par3, par4);
par1World.setBlockAndMetadataWithNotify(
par2, par3, par4, MinecraftPlusBase.holidaylights_1Active.blockID, m);
}
}
int var6 = par1World.getBlockMetadata(par2, par3, par4);
boolean var7 = false;
if (var6 == 2 && par1World.isBlockSolidOnSide(par2, par3, par4 + 1, NORTH)) {
var7 = true;
}
if (var6 == 3 && par1World.isBlockSolidOnSide(par2, par3, par4 - 1, SOUTH)) {
var7 = true;
}
if (var6 == 4 && par1World.isBlockSolidOnSide(par2 + 1, par3, par4, WEST)) {
var7 = true;
}
if (var6 == 5 && par1World.isBlockSolidOnSide(par2 - 1, par3, par4, EAST)) {
var7 = true;
}
if (!var7) {
this.dropBlockAsItem(par1World, par2, par3, par4, var6, 0);
par1World.setBlockWithNotify(par2, par3, par4, 0);
}
super.onNeighborBlockChange(par1World, par2, par3, par4, par5);
}
// 右クリック処理
@Override
public boolean onBlockActivated(
World par1World,
int par2,
int par3,
int par4,
EntityPlayer par5EntityPlayer,
int par6,
float par7,
float par8,
float par9) {
ItemStack itemstack = par5EntityPlayer.inventory.getCurrentItem();
int meta = par1World.getBlockMetadata(par2, par3, par4);
TileIncenseBase tile = (TileIncenseBase) par1World.getTileEntity(par2, par3, par4);
AMTBlockRightClickEvent event =
new AMTBlockRightClickEvent(par1World, par5EntityPlayer, itemstack, par2, par3, par4);
MinecraftForge.EVENT_BUS.post(event);
if (event.isCanceled()) {
return true;
}
if (itemstack == null) // 回収動作
{
if (!par5EntityPlayer.inventory.addItemStackToInventory(new ItemStack(this, 1))) {
if (!par1World.isRemote) par5EntityPlayer.entityDropItem(new ItemStack(this, 1), 1);
}
par1World.setBlockToAir(par2, par3, par4);
par1World.playSoundAtEntity(par5EntityPlayer, "random.pop", 0.4F, 1.8F);
return true;
} else if (itemstack.getItem() == Item.getItemFromBlock(this)) {
if (!par1World.isRemote) {
EntityItem entity =
new EntityItem(
par1World,
par5EntityPlayer.posX,
par5EntityPlayer.posY,
par5EntityPlayer.posZ,
new ItemStack(this, 1));
par1World.spawnEntityInWorld(entity);
}
par1World.setBlockToAir(par2, par3, par4);
par1World.playSoundAtEntity(par5EntityPlayer, "random.pop", 0.4F, 1.8F);
return true;
} else if (itemstack.getItem() instanceof IIncenseEffect) // お香アイテムの場合
{
if (tile != null && !tile.hasItem()) {
ItemStack put = itemstack.copy();
tile.setItemstack(put);
if (!par5EntityPlayer.capabilities.isCreativeMode
&& (itemstack.stackSize - put.stackSize) <= 0) {
par5EntityPlayer.inventory.setInventorySlotContents(
par5EntityPlayer.inventory.currentItem, (ItemStack) null);
}
tile.markDirty();
par5EntityPlayer.inventory.markDirty();
par1World.markBlockForUpdate(par2, par3, par4);
par1World.playSoundAtEntity(par5EntityPlayer, "random.pop", 0.4F, 1.8F);
return true;
}
return false;
} else if (itemstack.getItem() == Items.flint_and_steel
|| itemstack.getItem() == DCsAppleMilk.firestarter) {
if (tile != null && tile.hasItem() && !tile.getActive()) {
par5EntityPlayer.triggerAchievement(AchievementRegister.useIncense);
itemstack.attemptDamageItem(1, par1World.rand);
tile.setActive();
tile.markDirty();
par1World.setBlockMetadataWithNotify(par2, par3, par4, 1, 3);
par1World.playSoundAtEntity(par5EntityPlayer, "random.pop", 0.4F, 1.8F);
par1World.scheduleBlockUpdate(par2, par3, par4, this, this.tickRate(par1World));
return true;
}
return false;
} else {
return false;
}
}
public void onNeighborBlockChange(
World p_149695_1_, int p_149695_2_, int p_149695_3_, int p_149695_4_, Block p_149695_5_) {
p_149695_1_.scheduleBlockUpdate(
p_149695_2_, p_149695_3_, p_149695_4_, this, this.tickRate(p_149695_1_));
}
/**
* Lets the block know when one of its neighbor changes. Doesn't know which neighbor changed
* (coordinates passed are their own) Args: x, y, z, neighbor blockID
*/
public void onNeighborBlockChange(World par1World, int par2, int par3, int par4, int par5) {
par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, this.tickRate(par1World));
}
public void onBlockAdded(World p_149726_1_, int p_149726_2_, int p_149726_3_, int p_149726_4_) {
p_149726_1_.scheduleBlockUpdate(
p_149726_2_, p_149726_3_, p_149726_4_, this, this.tickRate(p_149726_1_));
}
@Override
public void updateTick(World world, int x, int y, int z, Random random) {
// System.out.println("x: "+x+", y: "+y+", z: "+z);
int tex = ((LiquidTextureLogic) world.getBlockTileEntity(x, y, z)).getLiquidType();
int l = getFlowDecay(world, x, y, z);
byte byte0 = 1;
boolean flag = true;
if (l > 0) {
int i1 = -100;
i1 = getSmallestFlowDecay(world, x - 1, y, z, i1);
i1 = getSmallestFlowDecay(world, x + 1, y, z, i1);
i1 = getSmallestFlowDecay(world, x, y, z - 1, i1);
i1 = getSmallestFlowDecay(world, x, y, z + 1, i1);
int j1 = i1 + byte0;
if (j1 >= 8 || i1 < 0) {
j1 = -1;
}
if (getFlowDecay(world, x, y + 1, z) >= 0) {
int l1 = getFlowDecay(world, x, y + 1, z);
if (l1 >= 8) {
j1 = l1;
} else {
j1 = l1 + 8;
}
}
if (j1 != l) {
l = j1;
if (l < 0) {
world.setBlockWithNotify(x, y, z, 0);
} else {
world.setBlockMetadataWithNotify(x, y, z, l);
world.scheduleBlockUpdate(x, y, z, blockID, tickRate());
world.notifyBlocksOfNeighborChange(x, y, z, blockID);
}
} else if (flag) {
updateFlow(world, x, y, z);
}
} else {
updateFlow(world, x, y, z);
}
if (liquidCanDisplaceBlock(world, x, y - 1, z)) {
if (l >= 8) {
world.setBlockAndMetadataWithNotify(x, y - 1, z, blockID, l);
} else {
world.setBlockAndMetadataWithNotify(x, y - 1, z, blockID, l + 8);
}
((LiquidTextureLogic) world.getBlockTileEntity(x, y - 1, z)).setTexturePos(tex);
} else if (l >= 0 && (l == 0 || blockBlocksFlow(world, x, y - 1, z))) {
boolean aflag[] = getOptimalFlowDirections(world, x, y, z);
int k1 = l + byte0;
if (l >= 8) {
k1 = 1;
}
if (k1 >= 8) return;
if (aflag[0]) {
flowIntoBlock(world, x - 1, y, z, k1, tex);
}
if (aflag[1]) {
flowIntoBlock(world, x + 1, y, z, k1, tex);
}
if (aflag[2]) {
flowIntoBlock(world, x, y, z - 1, k1, tex);
}
if (aflag[3]) {
flowIntoBlock(world, x, y, z + 1, k1, tex);
}
}
}
// @Override
public void onBlockAdded(World par1World, int par2, int par3, int par4) {
par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, this.tickRate(par1World));
}
public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random) {
if (par1World.getGameRules().getGameRuleBooleanValue("doFireTick")) {
Block base = Block.blocksList[par1World.getBlockId(par2, par3 - 1, par4)];
boolean flag =
(base != null)
&& (base.isFireSource(
par1World,
par2,
par3 - 1,
par4,
par1World.getBlockMetadata(par2, par3 - 1, par4),
ForgeDirection.UP));
if (!canPlaceBlockAt(par1World, par2, par3, par4)) {
par1World.setBlockToAir(par2, par3, par4);
}
if ((!flag)
&& (par1World.isRaining())
&& ((par1World.canLightningStrikeAt(par2, par3, par4))
|| (par1World.canLightningStrikeAt(par2 - 1, par3, par4))
|| (par1World.canLightningStrikeAt(par2 + 1, par3, par4))
|| (par1World.canLightningStrikeAt(par2, par3, par4 - 1))
|| (par1World.canLightningStrikeAt(par2, par3, par4 + 1)))) {
par1World.setBlockToAir(par2, par3, par4);
} else {
int l = par1World.getBlockMetadata(par2, par3, par4);
if (l < 15) {
par1World.setBlockMetadataWithNotify(par2, par3, par4, l + par5Random.nextInt(3) / 2, 4);
}
par1World.scheduleBlockUpdate(
par2, par3, par4, this.blockID, tickRate(par1World) + par5Random.nextInt(10));
if ((!flag) && (!canNeighborBurn(par1World, par2, par3, par4))) {
if ((!par1World.doesBlockHaveSolidTopSurface(par2, par3 - 1, par4)) || (l > 3)) {
par1World.setBlockToAir(par2, par3, par4);
}
} else if ((!flag)
&& (!canBlockCatchFire(par1World, par2, par3 - 1, par4, ForgeDirection.UP))
&& (l == 15)
&& (par5Random.nextInt(4) == 0)) {
par1World.setBlockToAir(par2, par3, par4);
} else {
boolean flag1 = par1World.isBlockHighHumidity(par2, par3, par4);
byte b0 = 0;
if (flag1) {
b0 = -50;
}
tryToCatchBlockOnFire(
par1World, par2 + 1, par3, par4, 300 + b0, par5Random, l, ForgeDirection.WEST);
tryToCatchBlockOnFire(
par1World, par2 - 1, par3, par4, 300 + b0, par5Random, l, ForgeDirection.EAST);
tryToCatchBlockOnFire(
par1World, par2, par3 - 1, par4, 250 + b0, par5Random, l, ForgeDirection.UP);
tryToCatchBlockOnFire(
par1World, par2, par3 + 1, par4, 250 + b0, par5Random, l, ForgeDirection.DOWN);
tryToCatchBlockOnFire(
par1World, par2, par3, par4 - 1, 300 + b0, par5Random, l, ForgeDirection.SOUTH);
tryToCatchBlockOnFire(
par1World, par2, par3, par4 + 1, 300 + b0, par5Random, l, ForgeDirection.NORTH);
for (int i1 = par2 - 1; i1 <= par2 + 1; i1++) {
for (int j1 = par4 - 1; j1 <= par4 + 1; j1++) {
for (int k1 = par3 - 1; k1 <= par3 + 4; k1++) {
if ((i1 != par2) || (k1 != par3) || (j1 != par4)) {
int l1 = 100;
if (k1 > par3 + 1) {
l1 += (k1 - (par3 + 1)) * 100;
}
int i2 = getChanceOfNeighborsEncouragingFire(par1World, i1, k1, j1);
if (i2 > 0) {
int j2 = (i2 + 40 + par1World.difficultySetting * 7) / (l + 30);
if (flag1) {
j2 /= 2;
}
if ((j2 > 0)
&& (par5Random.nextInt(l1) <= j2)
&& ((!par1World.isRaining())
|| (!par1World.canLightningStrikeAt(i1, k1, j1)))
&& (!par1World.canLightningStrikeAt(i1 - 1, k1, par4))
&& (!par1World.canLightningStrikeAt(i1 + 1, k1, j1))
&& (!par1World.canLightningStrikeAt(i1, k1, j1 - 1))
&& (!par1World.canLightningStrikeAt(i1, k1, j1 + 1))) {
int k2 = l + par5Random.nextInt(5) / 4;
if (k2 > 15) {
k2 = 15;
}
par1World.setBlock(i1, k1, j1, this.blockID, k2, 3);
}
}
}
}
}
}
}
}
}
}
@Override
public void updateTick(World world, int x, int y, int z, Random rand) {
if (!world.isRemote) {
TileIncenseBase tile = (TileIncenseBase) world.getTileEntity(x, y, z);
boolean active = tile.getActive();
if (active) {
ItemStack item = tile.getItemstack();
if (item != null && item.getItem() instanceof IIncenseEffect) {
IIncenseEffect effect = (IIncenseEffect) item.getItem();
EffectType type = effect.getEffectType();
int area = effect.effectAreaRange();
if (type == EffectType.Player) {
List list = this.searchPlayer(world, x, y, z, area);
if (list != null && !list.isEmpty()) {
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Entity entity = (Entity) iterator.next();
if (entity instanceof EntityLivingBase) {
EntityLivingBase target = (EntityLivingBase) entity;
effect.formEffect(world, x, y, z, target, effect);
}
}
}
} else if (type == EffectType.EntityLiving) {
List list = this.searchEntity(world, x, y, z, area);
if (list != null && !list.isEmpty()) {
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Entity entity = (Entity) iterator.next();
if (entity instanceof EntityLivingBase) {
EntityLivingBase target = (EntityLivingBase) entity;
effect.formEffect(world, x, y, z, target, effect);
}
}
}
} else if (type == EffectType.Block) {
for (int i = 0; i < effect.effectAreaRange(); i++) {
int[] pos = this.searchBlock(world, x, y, z, area);
if (pos != null && pos.length == 3) {
effect.formEffect(world, pos[0], pos[1], pos[2], null, effect);
}
}
}
}
world.scheduleBlockUpdate(x, y, z, this, this.tickRate(world));
}
}
}
@Override
public boolean onBlockActivated(
World world,
int x,
int y,
int z,
EntityPlayer player,
int side,
float clickX,
float clickY,
float clickZ) {
TileEntityDoorController tileEntity = (TileEntityDoorController) world.getTileEntity(x, y, z);
if (tileEntity == null || player.isSneaking()) {
return false;
}
// If the user is not the owner, or the user is not in creative drop out.
if (tileEntity.getOwner() != null) {
if (!tileEntity.getOwner().equals(player.getUniqueID().toString())
&& !player.capabilities.isCreativeMode) {
if (!tileEntity.getOwner().isEmpty()) {
return false;
}
}
}
// Change the block texture
if (player.getCurrentEquippedItem() != null
&& player.getCurrentEquippedItem().getItem() instanceof ItemBlock) {
Block block = Block.getBlockFromItem(player.getCurrentEquippedItem().getItem());
Item oldBlock = tileEntity.DoorControllerCamo[0].getItem();
if (block.isOpaqueCube()
|| block instanceof BlockGlass
|| block instanceof BlockStainedGlass) {
if (!tileEntity
.DoorControllerCamo[0]
.getItem()
.equals(player.getCurrentEquippedItem().getItem())) {
if (player.capabilities.isCreativeMode) {
tileEntity.overrideTexture(
block,
player.getCurrentEquippedItem().splitStack(0),
ForgeDirection.getOrientation(side));
} else {
tileEntity.overrideTexture(
block,
player.getCurrentEquippedItem().splitStack(1),
ForgeDirection.getOrientation(side));
}
world.scheduleBlockUpdate(x, y, z, tileEntity.block, 5);
if (!world.isRemote) {
ItemStack testAgainst = new ItemStack(oldBlock);
if (!testAgainst
.getItem()
.equals(Item.getItemFromBlock(ContentRegistry.DoorController))) {
EntityItem myItemEntity = new EntityItem(world, x, y, z, testAgainst);
world.spawnEntityInWorld(myItemEntity);
}
}
}
}
// Remove the block texture with the scrench
} else if (player.getCurrentEquippedItem() != null
&& player.getCurrentEquippedItem().getItem() instanceof Wrench) {
if (!world.isRemote) {
if (!tileEntity
.DoorControllerCamo[0]
.getItem()
.equals(Item.getItemFromBlock(ContentRegistry.DoorController))) {
EntityItem myItemEntity =
new EntityItem(world, x, y, z, tileEntity.DoorControllerCamo[0]);
world.spawnEntityInWorld(myItemEntity);
}
}
tileEntity.overrideTexture(
ContentRegistry.DoorController,
new ItemStack(Item.getItemFromBlock(ContentRegistry.DoorController)),
ForgeDirection.getOrientation(side));
world.scheduleBlockUpdate(x, y, z, tileEntity.block, 5);
}
return true;
}
@Override
public void updateTick(World world, int x, int y, int z, Random rand) {
int quantaRemaining = quantaPerBlock - world.getBlockMetadata(x, y, z);
int expQuanta = -101;
// check adjacent block levels if non-source
if (quantaRemaining < quantaPerBlock) {
int y2 = y - densityDir;
if ((world.getBlockId(x, y2, z) == blockID)
|| (world.getBlockId(x - 1, y2, z) == blockID)
|| (world.getBlockId(x + 1, y2, z) == blockID)
|| (world.getBlockId(x, y2, z - 1) == blockID)
|| (world.getBlockId(x, y2, z + 1) == blockID)) {
expQuanta = quantaPerBlock - 1;
} else {
int maxQuanta = -100;
maxQuanta = getLargerQuanta(world, x - 1, y, z, maxQuanta);
maxQuanta = getLargerQuanta(world, x + 1, y, z, maxQuanta);
maxQuanta = getLargerQuanta(world, x, y, z - 1, maxQuanta);
maxQuanta = getLargerQuanta(world, x, y, z + 1, maxQuanta);
expQuanta = maxQuanta - 1;
}
// decay calculation
if (expQuanta != quantaRemaining) {
quantaRemaining = expQuanta;
if (expQuanta <= 0) {
world.setBlockToAir(x, y, z);
} else {
world.setBlockMetadataWithNotify(x, y, z, quantaPerBlock - expQuanta, 3);
world.scheduleBlockUpdate(x, y, z, blockID, tickRate);
world.notifyBlocksOfNeighborChange(x, y, z, blockID);
}
}
} else if (quantaRemaining > quantaPerBlock) {
world.setBlockMetadataWithNotify(x, y, z, 0, 3);
}
// Flow vertically if possible
if (canDisplace(world, x, y + densityDir, z)) {
flowIntoBlock(world, x, y + densityDir, z, 1);
return;
}
// Flow outward if possible
int flowMeta = (quantaPerBlock - quantaRemaining) + 1;
if (flowMeta >= quantaPerBlock) {
return;
}
if (isSourceBlock(world, x, y, z) || !isFlowingVertically(world, x, y, z)) {
if (world.getBlockId(x, y - densityDir, z) == blockID) {
flowMeta = 1;
}
boolean flowTo[] = getOptimalFlowDirections(world, x, y, z);
if (flowTo[0]) {
flowIntoBlock(world, x - 1, y, z, flowMeta);
}
if (flowTo[1]) {
flowIntoBlock(world, x + 1, y, z, flowMeta);
}
if (flowTo[2]) {
flowIntoBlock(world, x, y, z - 1, flowMeta);
}
if (flowTo[3]) {
flowIntoBlock(world, x, y, z + 1, flowMeta);
}
}
}
public void grow(World world, int i, int j, int k) {
world.scheduleBlockUpdate(i, j, k, blockID, 5);
}