/** 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));
}
}
@Override
public void updateTick(World world, int i, int j, int k, Random random) {
if (world.getBlockMetadata(i, j, k) < 2) {
if (random.nextInt(5) == 2) {
world.setBlockWithNotify(i, j, k, 0);
} else {
world.scheduleBlockUpdate(i, j, k, blockID, tickRate());
}
}
}
/** Called when the block is placed in the world. */
public void onBlockPlacedBy(
World par1World, int par2, int par3, int par4, EntityLiving par5EntityLiving) {
int var6 =
((MathHelper.floor_double((double) (par5EntityLiving.rotationYaw * 4.0F / 360.0F) + 0.5D)
& 3)
+ 2)
% 4;
par1World.setBlockMetadataWithNotify(par2, par3, par4, var6);
boolean var7 = this.ignoreTick(par1World, par2, par3, par4, var6);
if (var7) {
par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, 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) {
if (!this.canBlockStay(par1World, par2, par3, par4)) {
this.dropBlockAsItem(
par1World, par2, par3, par4, par1World.getBlockMetadata(par2, par3, par4), 0);
par1World.setBlockWithNotify(par2, par3, par4, 0);
par1World.notifyBlocksOfNeighborChange(par2 + 1, par3, par4, this.blockID);
par1World.notifyBlocksOfNeighborChange(par2 - 1, par3, par4, this.blockID);
par1World.notifyBlocksOfNeighborChange(par2, par3, par4 + 1, this.blockID);
par1World.notifyBlocksOfNeighborChange(par2, par3, par4 - 1, this.blockID);
par1World.notifyBlocksOfNeighborChange(par2, par3 - 1, par4, this.blockID);
par1World.notifyBlocksOfNeighborChange(par2, par3 + 1, par4, this.blockID);
} else {
int var6 = par1World.getBlockMetadata(par2, par3, par4);
boolean var7 = this.ignoreTick(par1World, par2, par3, par4, var6);
int var8 = (var6 & 12) >> 2;
if (this.isRepeaterPowered && !var7) {
par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, repeaterState[var8] * 2);
} else if (!this.isRepeaterPowered && var7) {
par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, repeaterState[var8] * 2);
}
}
}
/** 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.provider.dimensionId <= 0
&& par1World.getBlockId(par2, par3 - 1, par4) == Block.obsidian.blockID
&& Block.portal.tryToCreatePortal(par1World, par2, par3, par4)) {
return;
}
if (!par1World.doesBlockHaveSolidTopSurface(par2, par3 - 1, par4)
&& !canNeighborBurn(par1World, par2, par3, par4)) {
par1World.setBlockToAir(par2, par3, par4);
return;
} else {
par1World.scheduleBlockUpdate(
par2, par3, par4, blockID, tickRate(par1World) + par1World.rand.nextInt(10));
return;
}
}
/** Ticks the block if it's been scheduled */
public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random) {
int var6 = par1World.getBlockMetadata(par2, par3, par4);
boolean var7 = this.ignoreTick(par1World, par2, par3, par4, var6);
if (this.isRepeaterPowered && !var7) {
par1World.setBlockAndMetadataWithNotify(
par2, par3, par4, Block.redstoneRepeaterIdle.blockID, var6);
} else if (!this.isRepeaterPowered) {
par1World.setBlockAndMetadataWithNotify(
par2, par3, par4, Block.redstoneRepeaterActive.blockID, var6);
if (!var7) {
int var8 = (var6 & 12) >> 2;
par1World.scheduleBlockUpdate(
par2, par3, par4, Block.redstoneRepeaterActive.blockID, repeaterState[var8] * 2);
}
}
}
/** Called when the block is placed in the world. */
public void onBlockPlacedBy(
World par1World,
int par2,
int par3,
int par4,
EntityLiving par5EntityLiving,
ItemStack par6ItemStack) {
int var7 =
((MathHelper.floor_double((double) (par5EntityLiving.rotationYaw * 4.0F / 360.0F) + 0.5D)
& 3)
+ 2)
% 4;
par1World.setBlockMetadata(par2, par3, par4, var7, 3);
boolean var8 = this.func_94478_d(par1World, par2, par3, par4, var7);
if (var8) {
par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, 1);
}
}
public void onNeighborBlockChange(World world, int i, int j, int k, int l) {
Coords coords = new Coords(i, j, k);
if (coordsState.containsKey(coords)) return;
int blockState = getPowerStateMetadata(world, i, j, k);
if (disabledPower == blockState || disabledNoPower == blockState) {
if (!isClkPowerd(world, i, j, k)) {
if (disabledPower == blockState) coordsState.put(coords, readyToRunPower);
else coordsState.put(coords, readyToRunNoPower);
}
} else {
if (isClkPowerd(world, i, j, k)) {
if (isInputPowerd(world, i, j, k)) coordsState.put(coords, disabledPower);
else coordsState.put(coords, disabledNoPower);
}
}
world.scheduleBlockUpdate(i, j, k, blockID, tickRate());
}
/**
* 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());
}
/** 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) {
par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, this.tickRate());
}
/** Ticks the block if it's been scheduled */
public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random) {
int var6 = this.getFlowDecay(par1World, par2, par3, par4);
byte var7 = 1;
if (this.blockMaterial == Material.lava && !par1World.provider.isHellWorld) {
var7 = 2;
}
boolean var8 = true;
int var9 = this.tickRate(par1World);
int var11;
if (var6 > 0) {
byte var10 = -100;
this.numAdjacentSources = 0;
int var13 = this.getSmallestFlowDecay(par1World, par2 - 1, par3, par4, var10);
var13 = this.getSmallestFlowDecay(par1World, par2 + 1, par3, par4, var13);
var13 = this.getSmallestFlowDecay(par1World, par2, par3, par4 - 1, var13);
var13 = this.getSmallestFlowDecay(par1World, par2, par3, par4 + 1, var13);
var11 = var13 + var7;
if (var11 >= 8 || var13 < 0) {
var11 = -1;
}
if (this.getFlowDecay(par1World, par2, par3 + 1, par4) >= 0) {
int var12 = this.getFlowDecay(par1World, par2, par3 + 1, par4);
if (var12 >= 8) {
var11 = var12;
} else {
var11 = var12 + 8;
}
}
if (this.numAdjacentSources >= 2 && this.blockMaterial == Material.water) {
if (par1World.getBlockMaterial(par2, par3 - 1, par4).isSolid()) {
var11 = 0;
} else if (par1World.getBlockMaterial(par2, par3 - 1, par4) == this.blockMaterial
&& par1World.getBlockMetadata(par2, par3 - 1, par4) == 0) {
var11 = 0;
}
}
if (this.blockMaterial == Material.lava
&& var6 < 8
&& var11 < 8
&& var11 > var6
&& par5Random.nextInt(4) != 0) {
var9 *= 4;
}
if (var11 == var6) {
if (var8) {
this.updateFlow(par1World, par2, par3, par4);
}
} else {
var6 = var11;
if (var11 < 0) {
par1World.setBlockToAir(par2, par3, par4);
} else {
par1World.setBlockMetadata(par2, par3, par4, var11, 2);
par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, var9);
par1World.notifyBlocksOfNeighborChange(par2, par3, par4, this.blockID);
}
}
} else {
this.updateFlow(par1World, par2, par3, par4);
}
if (this.liquidCanDisplaceBlock(par1World, par2, par3 - 1, par4)) {
if (this.blockMaterial == Material.lava
&& par1World.getBlockMaterial(par2, par3 - 1, par4) == Material.water) {
par1World.setBlock(par2, par3 - 1, par4, Block.stone.blockID);
this.triggerLavaMixEffects(par1World, par2, par3 - 1, par4);
return;
}
if (var6 >= 8) {
this.flowIntoBlock(par1World, par2, par3 - 1, par4, var6);
} else {
this.flowIntoBlock(par1World, par2, par3 - 1, par4, var6 + 8);
}
} else if (var6 >= 0 && (var6 == 0 || this.blockBlocksFlow(par1World, par2, par3 - 1, par4))) {
boolean[] var14 = this.getOptimalFlowDirections(par1World, par2, par3, par4);
var11 = var6 + var7;
if (var6 >= 8) {
var11 = 1;
}
if (var11 >= 8) {
return;
}
if (var14[0]) {
this.flowIntoBlock(par1World, par2 - 1, par3, par4, var11);
}
if (var14[1]) {
this.flowIntoBlock(par1World, par2 + 1, par3, par4, var11);
}
if (var14[2]) {
this.flowIntoBlock(par1World, par2, par3, par4 - 1, var11);
}
if (var14[3]) {
this.flowIntoBlock(par1World, par2, par3, par4 + 1, var11);
}
}
}
@Override
public void onBlockAdded(World world, int i, int j, int k) {
if (world.getBlockMetadata(i, j, k) < 2) {
world.scheduleBlockUpdate(i, j, k, blockID, tickRate());
}
}
public void updateTick(World world, int i, int j, int k, Random random) {
int l = getFlowDecay(world, i, j, k);
byte byte0 = 1;
if (blockMaterial == Material.lava && !world.worldProvider.isHellWorld) {
byte0 = 2;
}
boolean flag = true;
if (l > 0) {
int i1 = -100;
numAdjacentSources = 0;
i1 = getSmallestFlowDecay(world, i - 1, j, k, i1);
i1 = getSmallestFlowDecay(world, i + 1, j, k, i1);
i1 = getSmallestFlowDecay(world, i, j, k - 1, i1);
i1 = getSmallestFlowDecay(world, i, j, k + 1, i1);
int j1 = i1 + byte0;
if (j1 >= 8 || i1 < 0) {
j1 = -1;
}
if (getFlowDecay(world, i, j + 1, k) >= 0) {
int l1 = getFlowDecay(world, i, j + 1, k);
if (l1 >= 8) {
j1 = l1;
} else {
j1 = l1 + 8;
}
}
if (numAdjacentSources >= 2 && blockMaterial == Material.water) {
if (world.getBlockMaterial(i, j - 1, k).isSolid()) {
j1 = 0;
} else if (world.getBlockMaterial(i, j - 1, k) == blockMaterial
&& world.getBlockMetadata(i, j, k) == 0) {
j1 = 0;
}
}
if (blockMaterial == Material.lava && l < 8 && j1 < 8 && j1 > l && random.nextInt(4) != 0) {
j1 = l;
flag = false;
}
if (j1 != l) {
l = j1;
if (l < 0) {
world.setBlockWithNotify(i, j, k, 0);
} else {
world.setBlockMetadataWithNotify(i, j, k, l);
world.scheduleBlockUpdate(i, j, k, blockID, tickRate());
world.notifyBlocksOfNeighborChange(i, j, k, blockID);
}
} else if (flag) {
func_30003_j(world, i, j, k);
}
} else {
func_30003_j(world, i, j, k);
}
if (liquidCanDisplaceBlock(world, i, j - 1, k)) {
if (l >= 8) {
world.setBlockAndMetadataWithNotify(i, j - 1, k, blockID, l);
} else {
world.setBlockAndMetadataWithNotify(i, j - 1, k, blockID, l + 8);
}
} else if (l >= 0 && (l == 0 || blockBlocksFlow(world, i, j - 1, k))) {
boolean aflag[] = getOptimalFlowDirections(world, i, j, k);
int k1 = l + byte0;
if (l >= 8) {
k1 = 1;
}
if (k1 >= 8) {
return;
}
if (aflag[0]) {
flowIntoBlock(world, i - 1, j, k, k1);
}
if (aflag[1]) {
flowIntoBlock(world, i + 1, j, k, k1);
}
if (aflag[2]) {
flowIntoBlock(world, i, j, k - 1, k1);
}
if (aflag[3]) {
flowIntoBlock(world, i, j, k + 1, k1);
}
}
}
public void onBlockAdded(World world, int i, int j, int k) {
super.onBlockAdded(world, i, j, k);
if (world.getBlockId(i, j, k) == blockID) {
world.scheduleBlockUpdate(i, j, k, blockID, tickRate());
}
}
public void updateTickOld(World world, int i, int j, int k, Random random) {
boolean flag = world.getBlockId(i, j - 1, k) == Block.netherrack.blockID;
if (!flag
&& world.isRaining()
&& (world.canLightningStrikeAt(i, j, k)
|| world.canLightningStrikeAt(i - 1, j, k)
|| world.canLightningStrikeAt(i + 1, j, k)
|| world.canLightningStrikeAt(i, j, k - 1)
|| world.canLightningStrikeAt(i, j, k + 1))) {
world.setBlockToAir(i, j, k);
return;
}
int l = world.getBlockMetadata(i, j, k);
if (l < 15) {
world.setBlockMetadataWithNotify(i, j, k, l + 1, 3);
world.scheduleBlockUpdate(i, j, k, blockID, tickRate(world));
}
if (!flag && !canNeighborBurn(world, i, j, k)) {
if (!world.isBlockOpaqueCube(i, j - 1, k) || l > 3) {
world.setBlockToAir(i, j, k);
}
return;
}
if (!flag && !canBlockCatchFire(world, i, j - 1, k) && l == 15 && random.nextInt(4) == 0) {
world.setBlockToAir(i, j, k);
return;
}
if (l % 2 == 0 && l > 2) {
tryToCatchBlockOnFire_old(world, i + 1, j, k, 300, random);
tryToCatchBlockOnFire_old(world, i - 1, j, k, 300, random);
tryToCatchBlockOnFire_old(world, i, j - 1, k, 250, random);
tryToCatchBlockOnFire_old(world, i, j + 1, k, 250, random);
tryToCatchBlockOnFire_old(world, i, j, k - 1, 300, random);
tryToCatchBlockOnFire_old(world, i, j, k + 1, 300, random);
for (int i1 = i - 1; i1 <= i + 1; i1++) {
for (int j1 = k - 1; j1 <= k + 1; j1++) {
for (int k1 = j - 1; k1 <= j + 4; k1++) {
if (i1 == i && k1 == j && j1 == k) {
continue;
}
int l1 = 100;
if (k1 > j + 1) {
l1 += (k1 - (j + 1)) * 100;
}
int i2 = getChanceOfNeighborsEncouragingFire(world, i1, k1, j1);
if (i2 > 0
&& random.nextInt(l1) <= i2
&& (!world.isRaining() || !world.canLightningStrikeAt(i1, k1, j1))
&& !world.canLightningStrikeAt(i1 - 1, k1, k)
&& !world.canLightningStrikeAt(i1 + 1, k1, j1)
&& !world.canLightningStrikeAt(i1, k1, j1 - 1)
&& !world.canLightningStrikeAt(i1, k1, j1 + 1)) {
world.setBlock(i1, k1, j1, blockID);
}
}
}
}
}
if (l == 15 && !infiniteBurn) {
tryToCatchBlockOnFire_old(world, i + 1, j, k, 1, random);
tryToCatchBlockOnFire_old(world, i - 1, j, k, 1, random);
tryToCatchBlockOnFire_old(world, i, j - 1, k, 1, random);
tryToCatchBlockOnFire_old(world, i, j + 1, k, 1, random);
tryToCatchBlockOnFire_old(world, i, j, k - 1, 1, random);
tryToCatchBlockOnFire_old(world, i, j, k + 1, 1, random);
}
}
@Override
public void onNeighborBlockChange(World world, int i, int j, int k, int l) {
if (!mod_NWater.chunkPass(world, i, j, k)) {
return;
}
if (world.getBlockMetadata(i, j, k) < 2) {
world.scheduleBlockUpdate(i, j, k, blockID, tickRate());
}
if (world.multiplayerWorld) {
return;
}
if (BlockNWater_Ocean.noOcean) {
return;
}
checkForHarden(world, i, j, k);
int i1 = world.getBlockMetadata(i, j, k);
boolean flag = false;
if ((world.getBlockId(i, j - 1, k) == mod_NWater.nwater_ocean.blockID)
& (world.getBlockMetadata(i, j - 1, k) < 2 || world.getBlockMetadata(i, j - 1, k) > 3)) {
flag = true;
}
if (mod_NWater.canMoveAmt(world, i, j - 1, k, i1)) {
flag = true;
}
if (checkSponge(world, i - 1, j, k)) {
flag = true;
}
if (checkSponge(world, i + 1, j, k)) {
flag = true;
}
if (checkSponge(world, i, j - 1, k)) {
flag = true;
}
if (checkSponge(world, i, j, k - 1)) {
flag = true;
}
if (checkSponge(world, i, j, k + 1)) {
flag = true;
}
if ((!flag) & isWater(world, i, j - 1, k)) {
int j1 = world.getBlockMetadata(i, j - 1, k);
if (j1 < 15) {
if (j1 + (1 + i1) < 16) {
flag = true;
} else {
flag = true;
}
}
}
if (!flag) {
int k1 = 1;
int i2 = 1;
for (int k2 = -1; k2 <= 1; k2++) {
for (int i3 = -1; i3 <= 1; i3++) {
int k3 = k2 * k1;
int i4 = i3 * i2;
if (!((!flag) & (k2 != 0 || i3 != 0) & (k2 == 0 || i3 == 0))) {
continue;
}
world.getBlockId(i + k3, j, k + i4);
world.getBlockMetadata(i + k3, j, k + i4);
boolean flag1 = mod_NWater.canMoveAmt(world, i + k3, j, k + i4, i1);
if (!((!flag) & flag1)) {
continue;
}
world.getBlockId(i + k3, j - 1, k + i4);
world.getBlockMetadata(i + k3, j - 1, k + i4);
flag1 = mod_NWater.canMoveAmt(world, i + k3, j - 1, k + i4, i1);
if ((!flag) & flag1) {
flag = true;
}
if (!((!flag) & isWater(world, i + k3, j - 1, k + i4))) {
continue;
}
int k5 = world.getBlockMetadata(i + k3, j - 1, k + i4);
if (k5 >= 15) {
continue;
}
if (k5 + (1 + i1) < 16) {
flag = true;
} else {
flag = true;
}
}
}
}
if ((!flag) & (i1 > 0)) {
int l1 = 1;
int j2 = 1;
for (int l2 = -1; l2 <= 1; l2++) {
for (int j3 = -1; j3 <= 1; j3++) {
int l3 = l2 * l1;
int j4 = j3 * j2;
if (!((!flag) & (l2 != 0 || j3 != 0) & (l2 == 0 || j3 == 0))) {
continue;
}
world.getBlockId(i + l3, j, k + j4);
int j5 = world.getBlockMetadata(i + l3, j, k + j4);
boolean flag2 = mod_NWater.canMoveAmt(world, i + l3, j, k + j4, i1);
if ((!flag) & flag2) {
flag = true;
}
if (!((!flag) & isWater(world, i + l3, j, k + j4))) {
continue;
}
if (j5 + 1 < i1) {
flag = true;
}
float f = getSurfaceMull();
if (!((!flag)
& (Math.pow(mod_NWater.getMetaAvg2(world, i + l3, j, k + j4), f)
< mod_NWater.getMetaAvg2(world, i, j, k)))) {
continue;
}
int l5 = i1;
int j6 = (i1 + j5) / 2;
if (l5 != j6) {
flag = true;
}
}
}
}
if (flag) {
world.setBlockAndMetadata(i, j, k, getMoving(), i1);
}
}
/** Ticks the block if it's been scheduled */
public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random) {
if (!par1World.getGameRules().getGameRuleBooleanValue("doFireTick")) {
return;
}
if (oldFire) {
updateTickOld(par1World, par2, par3, par4, par5Random);
return;
}
boolean flag = par1World.getBlockId(par2, par3 - 1, par4) == Block.netherrack.blockID;
if ((par1World.provider instanceof WorldProviderEnd)
&& par1World.getBlockId(par2, par3 - 1, par4) == Block.bedrock.blockID) {
flag = true;
}
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);
return;
}
int i = par1World.getBlockMetadata(par2, par3, par4);
if (i < 15) {
par1World.setBlockMetadataWithNotify(par2, par3, par4, i + par5Random.nextInt(3) / 2, 4);
}
par1World.scheduleBlockUpdate(
par2, par3, par4, blockID, tickRate(par1World) + par5Random.nextInt(10));
if (!flag && !canNeighborBurn(par1World, par2, par3, par4)) {
if (!par1World.doesBlockHaveSolidTopSurface(par2, par3 - 1, par4) || i > 3) {
par1World.setBlockToAir(par2, par3, par4);
}
return;
}
if (!flag
&& !canBlockCatchFire(par1World, par2, par3 - 1, par4)
&& i == 15
&& par5Random.nextInt(4) == 0) {
par1World.setBlockToAir(par2, par3, par4);
return;
}
boolean flag1 = par1World.isBlockHighHumidity(par2, par3, par4);
byte byte0 = 0;
if (flag1) {
byte0 = -50;
}
tryToCatchBlockOnFire(par1World, par2 + 1, par3, par4, 300 + byte0, par5Random, i);
tryToCatchBlockOnFire(par1World, par2 - 1, par3, par4, 300 + byte0, par5Random, i);
tryToCatchBlockOnFire(par1World, par2, par3 - 1, par4, 250 + byte0, par5Random, i);
tryToCatchBlockOnFire(par1World, par2, par3 + 1, par4, 250 + byte0, par5Random, i);
tryToCatchBlockOnFire(par1World, par2, par3, par4 - 1, 300 + byte0, par5Random, i);
tryToCatchBlockOnFire(par1World, par2, par3, par4 + 1, 300 + byte0, par5Random, i);
for (int j = par2 - 1; j <= par2 + 1; j++) {
for (int k = par4 - 1; k <= par4 + 1; k++) {
for (int l = par3 - 1; l <= par3 + 4; l++) {
if (j == par2 && l == par3 && k == par4) {
continue;
}
int i1 = 100;
if (l > par3 + 1) {
i1 += (l - (par3 + 1)) * 100;
}
int j1 = getChanceOfNeighborsEncouragingFire(par1World, j, l, k);
if (j1 <= 0) {
continue;
}
int k1 = (j1 + 40 + (fixedDamage ? 0 : par1World.difficultySetting * 7)) / (i + 30);
if (flag1) {
k1 /= 2;
}
if (k1 <= 0
|| par5Random.nextInt(i1) > k1
|| par1World.isRaining() && par1World.canLightningStrikeAt(j, l, k)
|| par1World.canLightningStrikeAt(j - 1, l, par4)
|| par1World.canLightningStrikeAt(j + 1, l, k)
|| par1World.canLightningStrikeAt(j, l, k - 1)
|| par1World.canLightningStrikeAt(j, l, k + 1)) {
continue;
}
int l1 = i + par5Random.nextInt(5) / 4;
if (l1 > 15) {
l1 = 15;
}
par1World.setBlock(j, l, k, blockID, l1, 3);
}
}
}
}
private void setStateIfMobInteractsWithPlate(World world, int i, int j, int k) {
boolean flag = world.getBlockMetadata(i, j, k) == 1;
boolean flag1 = false;
float f = 0.125F;
List list = null;
if (triggerMobType == EnumMobType.everything) {
list =
world.getEntitiesWithinAABBExcludingEntity(
null,
AxisAlignedBB.getBoundingBoxFromPool(
(float) i + f,
j,
(float) k + f,
(float) (i + 1) - f,
(double) j + 0.25D,
(float) (k + 1) - f));
}
if (triggerMobType == EnumMobType.mobs) {
list =
world.getEntitiesWithinAABB(
net.minecraft.src.EntityLiving.class,
AxisAlignedBB.getBoundingBoxFromPool(
(float) i + f,
j,
(float) k + f,
(float) (i + 1) - f,
(double) j + 0.25D,
(float) (k + 1) - f));
}
if (triggerMobType == EnumMobType.players) {
list =
world.getEntitiesWithinAABB(
net.minecraft.src.EntityPlayer.class,
AxisAlignedBB.getBoundingBoxFromPool(
(float) i + f,
j,
(float) k + f,
(float) (i + 1) - f,
(double) j + 0.25D,
(float) (k + 1) - f));
}
if (list.size() > 0) {
flag1 = true;
}
if (flag1 && !flag) {
world.setBlockMetadataWithNotify(i, j, k, 1);
world.notifyBlocksOfNeighborChange(i, j, k, blockID);
world.notifyBlocksOfNeighborChange(i, j - 1, k, blockID);
world.markBlocksDirty(i, j, k, i, j, k);
world.playSoundEffect(
(double) i + 0.5D,
(double) j + 0.10000000000000001D,
(double) k + 0.5D,
"random.click",
0.3F,
0.6F);
}
if (!flag1 && flag) {
world.setBlockMetadataWithNotify(i, j, k, 0);
world.notifyBlocksOfNeighborChange(i, j, k, blockID);
world.notifyBlocksOfNeighborChange(i, j - 1, k, blockID);
world.markBlocksDirty(i, j, k, i, j, k);
world.playSoundEffect(
(double) i + 0.5D,
(double) j + 0.10000000000000001D,
(double) k + 0.5D,
"random.click",
0.3F,
0.5F);
}
if (flag1) {
world.scheduleBlockUpdate(i, j, k, blockID, tickRate());
}
}
