public void updateTick(World worldIn, BlockPos pos, IBlockState state, Random rand) {
if (this.blockMaterial == Material.lava) {
if (worldIn.getGameRules().getGameRuleBooleanValue("doFireTick")) {
int var5 = rand.nextInt(3);
if (var5 > 0) {
BlockPos var6 = pos;
for (int var7 = 0; var7 < var5; ++var7) {
var6 = var6.add(rand.nextInt(3) - 1, 1, rand.nextInt(3) - 1);
Block var8 = worldIn.getBlockState(var6).getBlock();
if (var8.blockMaterial == Material.air) {
if (this.isSurroundingBlockFlammable(worldIn, var6)) {
worldIn.setBlockState(var6, Blocks.fire.getDefaultState());
return;
}
} else if (var8.blockMaterial.blocksMovement()) {
return;
}
}
} else {
for (int var9 = 0; var9 < 3; ++var9) {
BlockPos var10 = pos.add(rand.nextInt(3) - 1, 0, rand.nextInt(3) - 1);
if (worldIn.isAirBlock(var10.offsetUp()) && this.getCanBlockBurn(worldIn, var10)) {
worldIn.setBlockState(var10.offsetUp(), Blocks.fire.getDefaultState());
}
}
}
}
}
}
public boolean onBlockActivated(
World worldIn,
BlockPos pos,
IBlockState state,
EntityPlayer playerIn,
EnumHand hand,
@Nullable ItemStack heldItem,
EnumFacing side,
float hitX,
float hitY,
float hitZ) {
if (((Boolean) state.getValue(OPEN)).booleanValue()) {
state = state.withProperty(OPEN, Boolean.valueOf(false));
worldIn.setBlockState(pos, state, 10);
} else {
EnumFacing enumfacing = EnumFacing.fromAngle((double) playerIn.rotationYaw);
if (state.getValue(FACING) == enumfacing.getOpposite()) {
state = state.withProperty(FACING, enumfacing);
}
state = state.withProperty(OPEN, Boolean.valueOf(true));
worldIn.setBlockState(pos, state, 10);
}
worldIn.playEvent(
playerIn, ((Boolean) state.getValue(OPEN)).booleanValue() ? 1008 : 1014, pos, 0);
return true;
}
public static void placeDoor(World worldIn, BlockPos pos, EnumFacing facing, Block door) {
BlockPos blockpos = pos.offset(facing.rotateY());
BlockPos blockpos1 = pos.offset(facing.rotateYCCW());
int i =
(worldIn.getBlockState(blockpos1).getBlock().isNormalCube() ? 1 : 0)
+ (worldIn.getBlockState(blockpos1.up()).getBlock().isNormalCube() ? 1 : 0);
int j =
(worldIn.getBlockState(blockpos).getBlock().isNormalCube() ? 1 : 0)
+ (worldIn.getBlockState(blockpos.up()).getBlock().isNormalCube() ? 1 : 0);
boolean flag =
worldIn.getBlockState(blockpos1).getBlock() == door
|| worldIn.getBlockState(blockpos1.up()).getBlock() == door;
boolean flag1 =
worldIn.getBlockState(blockpos).getBlock() == door
|| worldIn.getBlockState(blockpos.up()).getBlock() == door;
boolean flag2 = false;
if (flag && !flag1 || j > i) {
flag2 = true;
}
BlockPos blockpos2 = pos.up();
IBlockState iblockstate =
door.getDefaultState()
.withProperty(BlockDoor.FACING, facing)
.withProperty(
BlockDoor.HINGE,
flag2 ? BlockDoor.EnumHingePosition.RIGHT : BlockDoor.EnumHingePosition.LEFT);
worldIn.setBlockState(
pos, iblockstate.withProperty(BlockDoor.HALF, BlockDoor.EnumDoorHalf.LOWER), 2);
worldIn.setBlockState(
blockpos2, iblockstate.withProperty(BlockDoor.HALF, BlockDoor.EnumDoorHalf.UPPER), 2);
worldIn.notifyNeighborsOfStateChange(pos, door);
worldIn.notifyNeighborsOfStateChange(blockpos2, door);
}
@Override
public boolean onBlockActivated(
World world,
BlockPos pos,
IBlockState state,
EntityPlayer player,
EnumFacing side,
float hitX,
float hitY,
float hitZ) {
state = world.getBlockState(pos);
int i = ((Integer) state.getValue(COLOR)).intValue();
if (world.isBlockPowered(pos)) {
world.setBlockState(pos, state.withProperty(POWERED, Boolean.valueOf(true)));
}
if (((Boolean) state.getValue(POWERED)).booleanValue() == true) {
if (i < 3) {
world.setBlockState(pos, state.withProperty(COLOR, i + 1));
} else if (i == 3) {
world.setBlockState(pos, state.withProperty(COLOR, 0));
} else {
return false;
}
} else {
return false;
}
return true;
}
/**
* Called when a neighboring block was changed and marks that this state should perform any checks
* during a neighbor change. Cases may include when redstone power is updated, cactus blocks
* popping off due to a neighboring solid block, etc.
*/
public void neighborChanged(IBlockState state, World worldIn, BlockPos pos, Block blockIn) {
if (!worldIn.isRemote) {
boolean flag = worldIn.isBlockPowered(pos);
if (flag || blockIn.getDefaultState().canProvidePower()) {
if (flag
&& !((Boolean) state.getValue(OPEN)).booleanValue()
&& !((Boolean) state.getValue(POWERED)).booleanValue()) {
worldIn.setBlockState(
pos,
state
.withProperty(OPEN, Boolean.valueOf(true))
.withProperty(POWERED, Boolean.valueOf(true)),
2);
worldIn.playEvent((EntityPlayer) null, 1008, pos, 0);
} else if (!flag
&& ((Boolean) state.getValue(OPEN)).booleanValue()
&& ((Boolean) state.getValue(POWERED)).booleanValue()) {
worldIn.setBlockState(
pos,
state
.withProperty(OPEN, Boolean.valueOf(false))
.withProperty(POWERED, Boolean.valueOf(false)),
2);
worldIn.playEvent((EntityPlayer) null, 1014, pos, 0);
} else if (flag != ((Boolean) state.getValue(POWERED)).booleanValue()) {
worldIn.setBlockState(pos, state.withProperty(POWERED, Boolean.valueOf(flag)), 2);
}
}
}
}
public void generateGoldPile(World world, Random rand, BlockPos position) {
int height = 1 + new Random().nextInt(7);
int chance = rand.nextInt(100);
if (chance < 20) {
world.setBlockState(
position,
Blocks.CHEST
.getDefaultState()
.withProperty(BlockChest.FACING, EnumFacing.HORIZONTALS[new Random().nextInt(3)]),
3);
if (world.getBlockState(position).getBlock() instanceof BlockChest) {
TileEntity tileentity1 = world.getTileEntity(position);
if (tileentity1 instanceof TileEntityChest
&& !((TileEntityChest) tileentity1).isInvalid()) {
((TileEntityChest) tileentity1)
.setLootTable(WorldGenIceDragonCave.ICEDRAGON_CHEST, new Random().nextLong());
}
}
} else {
world.setBlockState(
position,
ModBlocks.silverPile.getDefaultState().withProperty(BlockGoldPile.LAYERS, height),
3);
}
}
private void func_176462_k(World world, BlockPos pos, IBlockState state) {
int newStrength = this.func_176460_j(world, pos, state);
int oldStrength =
F.or(
world.bindTileEntity(
pos,
TileEntityComparator.class,
t -> {
int old = t.getOutputSignal();
t.setOutputSignal(newStrength);
return old;
}),
0);
if (oldStrength != newStrength
|| state.getValue(MODE) == BlockRedstoneComparator.Mode.COMPARE) {
boolean var9 = this.isPowered(world, pos, state);
boolean var8 = this.isPowered(state);
if (var8 && !var9) {
world.setBlockState(pos, state.withProperty(POWERED, false), 2);
} else if (!var8 && var9) {
world.setBlockState(pos, state.withProperty(POWERED, true), 2);
}
this.updateRedstoneState(world, pos, state);
}
}
@Override
public void grow(World world, Random rand, BlockPos pos, IBlockState state) {
int meta = this.getMetaFromState(state);
if (meta < getMaxMeta(meta)) {
int span = getMaxMeta(meta) - meta;
int newMeta = meta + rand.nextInt(span) + 1;
if (newMeta != meta) world.setBlockState(pos, this.getStateFromMeta(newMeta));
meta = newMeta;
}
if (meta == 4 && world.isAirBlock(pos.add(0, 1, 0)))
world.setBlockState(pos.add(0, 1, 0), this.getStateFromMeta(meta + 1));
}
public void neighborDidChange(
World world, BlockPos pos, IBlockState state, IBlock neighborBlock) {
boolean var5 = world.isBlockBeingPowered(pos) || world.isBlockBeingPowered(pos.offsetUp());
boolean var6 = state.getValue(TRIGGERED);
if (var5 && !var6) {
world.scheduleUpdate(pos, this, this.tickRate(world));
world.setBlockState(pos, state.withProperty(TRIGGERED, true), 4);
} else if (!var5 && var6) {
world.setBlockState(pos, state.withProperty(TRIGGERED, false), 4);
}
}
private void spawnRubble(Random random, int chunkX, int chunkZ, World world) {
// Spawn above ground
for (int i = 0; i < random.nextInt(ROCK_TRIES); i++) {
int x = chunkX * 16 + random.nextInt(16);
int z = chunkZ * 16 + random.nextInt(16);
BlockPos pos = world.getTopSolidOrLiquidBlock(new BlockPos(x, 0, z)).down();
Block block = world.getBlockState(pos).getBlock();
if (isRockSpawnable(block)) {
if (world.isAirBlock(pos.up())) {
world.setBlockState(
pos.up(),
ModBlocks.rockBlock
.getDefaultState()
.withProperty(
GenericBlock.FACING_HORIZ, EnumFacing.getHorizontal(random.nextInt(4))),
3);
}
}
}
for (int i = 0; i < random.nextInt(STICK_TRIES); i++) {
int x = chunkX * 16 + random.nextInt(16);
int z = chunkZ * 16 + random.nextInt(16);
BlockPos pos = world.getTopSolidOrLiquidBlock(new BlockPos(x, 0, z)).down();
Block block = world.getBlockState(pos).getBlock();
if (isStickSpawnable(block)) {
trySpawnSticks(world, pos, random);
}
}
// Spawn in caves
for (int i = 0; i < random.nextInt(ROCK_TRIES); i++) {
int x = chunkX * 16 + random.nextInt(16);
int z = chunkZ * 16 + random.nextInt(16);
BlockPos pos = world.getTopSolidOrLiquidBlock(new BlockPos(x, 0, z)).down();
int y = findCaveSpot(world, pos);
pos = new BlockPos(x, y, z);
Block block = world.getBlockState(pos).getBlock();
if (y != -1 && isRockSpawnable(block)) {
if (world.isAirBlock(pos.up())) {
world.setBlockState(
pos.up(),
ModBlocks.rockBlock
.getDefaultState()
.withProperty(
GenericBlock.FACING_HORIZ, EnumFacing.getHorizontal(random.nextInt(4))),
3);
}
}
}
}
/** Called when a Block is right-clicked with this Item */
public boolean onItemUse(
ItemStack stack,
EntityPlayer playerIn,
World worldIn,
BlockPos pos,
EnumFacing side,
float hitX,
float hitY,
float hitZ) {
if (side == EnumFacing.DOWN) {
return false;
} else if (!worldIn.getBlockState(pos).getBlock().getMaterial().isSolid()) {
return false;
} else {
pos = pos.offset(side);
if (!playerIn.canPlayerEdit(pos, side, stack)) {
return false;
} else if (!Blocks.standing_sign.canPlaceBlockAt(worldIn, pos)) {
return false;
} else if (worldIn.isRemote) {
return true;
} else {
if (side == EnumFacing.UP) {
int i =
MathHelper.floor_double(
(double) ((playerIn.rotationYaw + 180.0F) * 16.0F / 360.0F) + 0.5D)
& 15;
worldIn.setBlockState(
pos,
Blocks.standing_sign
.getDefaultState()
.withProperty(BlockStandingSign.ROTATION, Integer.valueOf(i)),
3);
} else {
worldIn.setBlockState(
pos, Blocks.wall_sign.getDefaultState().withProperty(BlockWallSign.FACING, side), 3);
}
--stack.stackSize;
TileEntity tileentity = worldIn.getTileEntity(pos);
if (tileentity instanceof TileEntitySign
&& !ItemBlock.setTileEntityNBT(worldIn, playerIn, pos, stack)) {
playerIn.openEditSign((TileEntitySign) tileentity);
}
return true;
}
}
}
public void generateArchEW(World world, Random rand, BlockPos position) {
int height = 3 + rand.nextInt(1);
int width = 1 + rand.nextInt(2);
for (int sides = 0; sides < height; sides++) {
world.setBlockState(
position.up(sides).north(width / 2), ModBlocks.frozenCobblestone.getDefaultState(), 3);
world.setBlockState(
position.up(sides).south(width / 2), ModBlocks.frozenCobblestone.getDefaultState(), 3);
}
for (int way = 0; way < width; way++) {
world.setBlockState(
position.up(height).south(way), ModBlocks.frozenCobblestone.getDefaultState(), 3);
}
}
public boolean generate(World worldIn, Random rand, BlockPos position) {
if (worldIn.isAirBlock(position)
&& worldIn.getBlockState(position.down()).getBlock() == this.baseBlockRequired) {
int i = rand.nextInt(32) + 6;
int j = rand.nextInt(4) + 1;
BlockPos.MutableBlockPos blockpos$mutableblockpos = new BlockPos.MutableBlockPos();
for (int k = position.getX() - j; k <= position.getX() + j; ++k) {
for (int l = position.getZ() - j; l <= position.getZ() + j; ++l) {
int i1 = k - position.getX();
int j1 = l - position.getZ();
if (i1 * i1 + j1 * j1 <= j * j + 1
&& worldIn
.getBlockState(blockpos$mutableblockpos.set(k, position.getY() - 1, l))
.getBlock()
!= this.baseBlockRequired) {
return false;
}
}
}
for (int l1 = position.getY(); l1 < position.getY() + i && l1 < 256; ++l1) {
for (int i2 = position.getX() - j; i2 <= position.getX() + j; ++i2) {
for (int j2 = position.getZ() - j; j2 <= position.getZ() + j; ++j2) {
int k2 = i2 - position.getX();
int k1 = j2 - position.getZ();
if (k2 * k2 + k1 * k1 <= j * j + 1) {
worldIn.setBlockState(new BlockPos(i2, l1, j2), Blocks.obsidian.getDefaultState(), 2);
}
}
}
}
Entity entity = new EntityEnderCrystal(worldIn);
entity.setLocationAndAngles(
(double) ((float) position.getX() + 0.5F),
(double) (position.getY() + i),
(double) ((float) position.getZ() + 0.5F),
rand.nextFloat() * 360.0F,
0.0F);
worldIn.spawnEntityInWorld(entity);
worldIn.setBlockState(position.up(i), Blocks.bedrock.getDefaultState(), 2);
return true;
} else {
return false;
}
}
@Override
public void onBlockPlacedBy(
World world, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack itemStack) {
switch (getMetaUsage()) {
case HORIZROTATION:
world.setBlockState(
pos, state.withProperty(FACING_HORIZ, placer.getHorizontalFacing().getOpposite()), 2);
break;
case ROTATION:
world.setBlockState(pos, state.withProperty(FACING, getFacingFromEntity(pos, placer)), 2);
break;
case NONE:
break;
}
}
private void trySpawnSticks(World world, BlockPos pos, Random random) {
int x = pos.getX();
int y = pos.getY();
int z = pos.getZ();
y++;
if (!world.isAirBlock(new BlockPos(x, y, z))) {
return;
}
y++;
if (!BlockTools.isTopValidAndSolid(world, pos)) {
return;
}
for (int i = 0; i < 15; i++) {
if (!world.isAirBlock(new BlockPos(x, y, z))) {
if (isLeafBlock(world.getBlockState(new BlockPos(x, y, z)).getBlock())) {
world.setBlockState(
pos.up(),
ModBlocks.sticksBlock
.getDefaultState()
.withProperty(
GenericBlock.FACING_HORIZ, EnumFacing.getHorizontal(random.nextInt(4))),
3);
SticksTE sticksTE = (SticksTE) world.getTileEntity(pos.up());
sticksTE.setSticks(random.nextInt(6) + 1);
}
return;
}
y++;
}
}
public void didPlaceBlock(
World world, BlockPos pos, IBlockState state, EntityLivingBase player, ItemStack stack) {
world.setBlockState(
pos, state.withProperty(FACING, BlockPistonBase.func_180695_a(world, pos, player)), 2);
world.withTileEntity(
pos, TileEntityDispenser.class, t -> stack.withDisplayName(t::setCustomName));
}
@Override
public void updateTick(World worldIn, BlockPos pos, IBlockState state, Random rand) {
int age = (Integer) state.getValue(AGE);
if (age < 7 && rand.nextDouble() < this.default_ripeningProbability) {
worldIn.setBlockState(pos, state.withProperty(AGE, age + 1), 2);
}
}
@Override
public void onBlockPlacedBy(
World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack) {
final int angle = MathHelper.floor_double(placer.rotationYaw * 4.0F / 360.0F + 0.5D) & 3;
int change = EnumFacing.getHorizontal(angle).getOpposite().getIndex();
worldIn.setBlockState(pos, getStateFromMeta(change), 3);
}
/*
* This messy function is a work in progress. It is a temporary setup for
* placing a custom block from my mod over the door of the given npch.
*
* Returns the location of where the sign should be placed.
*
* Needs to be rewritten badly.
*/
public static BlockPos placeBlockOverDoor(
ItemStack stack,
EntityPlayer playerIn,
World worldIn,
NPCHouse npch,
String block_name,
float hitX,
float hitY,
float hitZ) {
String placeMe = ("bh_housing:" + block_name);
BlockPos door = BlockHelper.findDoor(worldIn, npch);
if (!door.equals(npch.getCorner(0))) {
int north = npch.getCorner(0).getZ();
int south = npch.getCorner(2).getZ();
int west = npch.getCorner(0).getX();
int east = npch.getCorner(1).getX();
BlockPos placeHere = door;
boolean shouldUse = false;
EnumFacing direction = EnumFacing.NORTH;
if (worldIn.getBlockState(placeHere).getBlock() instanceof NPCHouse_Block) {
return placeHere;
} else if (door.getX() == west) {
placeHere = door.up().west();
direction = EnumFacing.WEST;
} else if (door.getX() == east) {
placeHere = door.up().east();
direction = EnumFacing.EAST;
} else if (door.getZ() == north) {
placeHere = door.up().north();
direction = EnumFacing.NORTH;
} else if (door.getZ() == south) {
placeHere = door.up().south();
direction = EnumFacing.SOUTH;
}
shouldUse =
worldIn.setBlockState(
placeHere,
NPCHouse_Block.getBlockFromName(placeMe)
.getDefaultState()
.withProperty(NPCHouse_Block.FACING, direction),
3);
if (shouldUse) {
--stack.stackSize;
if (stack.stackSize == 0) {
playerIn.destroyCurrentEquippedItem();
}
if (block_name == "npch_block") {
NPCHouse_Block npchblock = (NPCHouse_Block) worldIn.getBlockState(placeHere).getBlock();
npchblock.setNPCHouse(npch);
}
IBlockState temp = worldIn.getBlockState(placeHere);
if (temp.getBlock().getRegistryName() == "npch_block") {
ItemBlock.setTileEntityNBT(
worldIn, playerIn, placeHere, new ItemStack(Block.getBlockFromName("npch_block"), 1));
}
}
return placeHere;
}
return null;
}
void createPlane(World world, BlockPos center, int wdt, IBlockState state) {
for (int x = -wdt / 2; x < wdt; x++) {
for (int z = -wdt / 2; z < wdt; z++) {
world.setBlockState(center.add(x, -1, z), state);
}
}
}
public void updateTick(World worldIn, BlockPos pos, IBlockState state, Random rand) {
if (rand.nextInt(25) == 0) {
int var5 = 5;
boolean var6 = true;
Iterator var7 = BlockPos.getAllInBoxMutable(pos.add(-4, -1, -4), pos.add(4, 1, 4)).iterator();
while (var7.hasNext()) {
BlockPos var8 = (BlockPos) var7.next();
if (worldIn.getBlockState(var8).getBlock() == this) {
--var5;
if (var5 <= 0) {
return;
}
}
}
BlockPos var9 =
pos.add(rand.nextInt(3) - 1, rand.nextInt(2) - rand.nextInt(2), rand.nextInt(3) - 1);
for (int var10 = 0; var10 < 4; ++var10) {
if (worldIn.isAirBlock(var9) && this.canBlockStay(worldIn, var9, this.getDefaultState())) {
pos = var9;
}
var9 = pos.add(rand.nextInt(3) - 1, rand.nextInt(2) - rand.nextInt(2), rand.nextInt(3) - 1);
}
if (worldIn.isAirBlock(var9) && this.canBlockStay(worldIn, var9, this.getDefaultState())) {
worldIn.setBlockState(var9, this.getDefaultState(), 2);
}
}
}
public boolean onBlockActivated(
World worldIn,
BlockPos pos,
IBlockState state,
EntityPlayer playerIn,
EnumFacing side,
float hitX,
float hitY,
float hitZ) {
if (((Boolean) state.getValue(POWERED)).booleanValue()) {
return true;
} else {
worldIn.setBlockState(pos, state.withProperty(POWERED, Boolean.valueOf(true)), 3);
worldIn.markBlockRangeForRenderUpdate(pos, pos);
worldIn.playSoundEffect(
(double) pos.getX() + 0.5D,
(double) pos.getY() + 0.5D,
(double) pos.getZ() + 0.5D,
"random.click",
0.3F,
0.6F);
this.notifyNeighbors(worldIn, pos, (EnumFacing) state.getValue(FACING));
worldIn.scheduleUpdate(pos, this, this.tickRate(worldIn));
return true;
}
}
/**
* Called when a Block is right-clicked with this Item
*
* @param pos The block being right-clicked
* @param side The side being right-clicked
*/
public boolean onItemUse(
ItemStack stack,
EntityPlayer playerIn,
World worldIn,
BlockPos pos,
EnumFacing side,
float hitX,
float hitY,
float hitZ) {
if (side != EnumFacing.UP) {
return false;
} else if (!playerIn.canPlayerEdit(pos.offset(side), side, stack)) {
return false;
} else if (worldIn
.getBlockState(pos)
.getBlock()
.canSustainPlant(worldIn, pos, EnumFacing.UP, this)
&& worldIn.isAirBlock(pos.up())) {
worldIn.setBlockState(pos.up(), this.crops.getDefaultState());
--stack.stackSize;
return true;
} else {
return false;
}
}
@Override
/**
* Updates the task
*/
public void updateTask()
{
Random random = this.field_179473_a.getRNG();
World world = this.field_179473_a.worldObj;
int i = MathHelper.floor_double(this.field_179473_a.posX - 2.0D + random.nextDouble() * 4.0D);
int j = MathHelper.floor_double(this.field_179473_a.posY + random.nextDouble() * 3.0D);
int k = MathHelper.floor_double(this.field_179473_a.posZ - 2.0D + random.nextDouble() * 4.0D);
BlockPos blockpos = new BlockPos(i, j, k);
IBlockState iblockstate = world.getBlockState(blockpos);
Block block = iblockstate.getBlock();
if (EntityChaoticEnderman.carriableBlocks.contains(block))
{
int blockMeta = ModBlocks.chaos_Block.getMetaFromState(iblockstate);
if (block != ModBlocks.chaos_Block || (blockMeta < 4)) {
this.field_179473_a.func_175490_a(iblockstate);
world.setBlockState(blockpos, Blocks.air.getDefaultState());
} else
this.field_179473_a.func_175490_a(ModBlocks.chaos_Block.getStateFromMeta((world.rand.nextFloat() >= 0.2F ?
13 : 14) + blockMeta < 2 ? 0 : 1));
}
}
@Override
protected void generateStalagmiteBase(World world, Random random, BlockPos botY, int aux) {
if (world.getBlockState(botY.down()) == Blocks.stone)
world.setBlockState(botY.down(), Blocks.sandstone.getDefaultState(), 2);
super.generateStalagmiteBase(world, random, botY, aux);
Utils.convertToSandType(world, random, botY);
}
/* Ticking methods */
public void updateTick(World world, BlockPos pos, IBlockState state, Random rand) {
if (this.powered) {
world.setBlockState(pos, this.getUnpoweredState(state).withProperty(POWERED, true), 4);
}
this.func_176462_k(world, pos, state);
}
public boolean generate(World worldIn, Random p_180709_2_, BlockPos p_180709_3_) {
while (worldIn.isAirBlock(p_180709_3_) && p_180709_3_.getY() > 2) {
p_180709_3_ = p_180709_3_.offsetDown();
}
if (worldIn.getBlockState(p_180709_3_).getBlock() != Blocks.snow) {
return false;
} else {
int var4 = p_180709_2_.nextInt(this.field_150554_b - 2) + 2;
byte var5 = 1;
for (int var6 = p_180709_3_.getX() - var4; var6 <= p_180709_3_.getX() + var4; ++var6) {
for (int var7 = p_180709_3_.getZ() - var4; var7 <= p_180709_3_.getZ() + var4; ++var7) {
int var8 = var6 - p_180709_3_.getX();
int var9 = var7 - p_180709_3_.getZ();
if (var8 * var8 + var9 * var9 <= var4 * var4) {
for (int var10 = p_180709_3_.getY() - var5;
var10 <= p_180709_3_.getY() + var5;
++var10) {
BlockPos var11 = new BlockPos(var6, var10, var7);
Block var12 = worldIn.getBlockState(var11).getBlock();
if (var12 == Blocks.dirt || var12 == Blocks.snow || var12 == Blocks.ice) {
worldIn.setBlockState(var11, this.field_150555_a.getDefaultState(), 2);
}
}
}
}
}
return true;
}
}
public boolean onItemUse(
ItemStack par1ItemStack,
EntityPlayer par2EntityPlayer,
World par3World,
BlockPos pos,
EnumFacing par5EnumFacing,
float hitX,
float hitY,
float hitZ) {
if (!par3World.isRemote) {
if (BlockUtils.getBlock(par3World, pos) == mod_SecurityCraft.frame) {
String owner = ((IOwnable) par3World.getTileEntity(pos)).getOwnerName();
String uuid = ((IOwnable) par3World.getTileEntity(pos)).getOwnerUUID();
EnumFacing enumfacing =
(EnumFacing) par3World.getBlockState(pos).getValue(BlockKeypad.FACING);
par3World.setBlockState(
pos,
mod_SecurityCraft
.Keypad
.getDefaultState()
.withProperty(BlockKeypad.FACING, enumfacing)
.withProperty(BlockKeypad.POWERED, false));
((IOwnable) par3World.getTileEntity(pos)).setOwner(uuid, owner);
par1ItemStack.stackSize -= 1;
}
return true;
}
return false;
}
public boolean generate(World worldIn, Random rand, BlockPos position) {
if (worldIn.getBlockState(position).getBlock().getMaterial() != Material.water) {
return false;
} else {
int i = rand.nextInt(this.numberOfBlocks - 2) + 2;
int j = 1;
for (int k = position.getX() - i; k <= position.getX() + i; ++k) {
for (int l = position.getZ() - i; l <= position.getZ() + i; ++l) {
int i1 = k - position.getX();
int j1 = l - position.getZ();
if (i1 * i1 + j1 * j1 <= i * i) {
for (int k1 = position.getY() - j; k1 <= position.getY() + j; ++k1) {
BlockPos blockpos = new BlockPos(k, k1, l);
Block block = worldIn.getBlockState(blockpos).getBlock();
if (block == Blocks.dirt || block == Blocks.clay) {
worldIn.setBlockState(blockpos, this.field_150546_a.getDefaultState(), 2);
}
}
}
}
}
return true;
}
}
public boolean generate(World worldIn, Random rand, BlockPos position) {
for (int i = 0; i < 20; ++i) {
BlockPos blockpos =
position.add(rand.nextInt(4) - rand.nextInt(4), 0, rand.nextInt(4) - rand.nextInt(4));
if (worldIn.isAirBlock(blockpos)) {
BlockPos blockpos1 = blockpos.down();
if (worldIn.getBlockState(blockpos1.west()).getBlock().getMaterial() == Material.water
|| worldIn.getBlockState(blockpos1.east()).getBlock().getMaterial() == Material.water
|| worldIn.getBlockState(blockpos1.north()).getBlock().getMaterial() == Material.water
|| worldIn.getBlockState(blockpos1.south()).getBlock().getMaterial()
== Material.water) {
int j = 2 + rand.nextInt(rand.nextInt(3) + 1);
for (int k = 0; k < j; ++k) {
if (Blocks.reeds.canBlockStay(worldIn, blockpos)) {
worldIn.setBlockState(blockpos.up(k), Blocks.reeds.getDefaultState(), 2);
}
}
}
}
}
return true;
}