@Override public void onUpdate() { super.onUpdate(); if ((this.ticksExisted - 1) % 20 == 0 && this.worldObj.isRemote && FMLCommonHandler.instance().getEffectiveSide() == Side.CLIENT) { this.flagData = ClientUtil.updateFlagData( this.getOwner(), Minecraft.getMinecraft().thePlayer.getDistanceToEntity(this) < 50.0D); } Vector3 vec = new Vector3(this.posX, this.posY, this.posZ); vec = vec.translate(new Vector3(0, -1, 0)); final Block blockAt = vec.getBlock(this.worldObj); if (blockAt != null) { if (blockAt instanceof BlockFence) { } else if (blockAt.isAir(this.worldObj, vec.intX(), vec.intY(), vec.intZ())) { this.motionY -= 0.02F; } } this.moveEntity(this.motionX, this.motionY, this.motionZ); }
public static EntityBlock create( EntityPlayer player, World world, int x, int y, int z, Class<? extends EntityBlock> klazz) { Block block = world.getBlock(x, y, z); if (block.isAir(world, x, y, z)) return null; int meta = world.getBlockMetadata(x, y, z); final EntityBlock entity; try { entity = klazz.getConstructor(World.class).newInstance(world); } catch (Throwable t) { Log.warn(t, "Failed to create EntityBlock(%s) at %d,%d,%d", klazz, x, y, z); return null; } entity.setBlockNameAndMeta(BlockProperties.getBlockName(block), meta); final TileEntity te = world.getTileEntity(x, y, z); if (te != null) { entity.tileEntity = new NBTTagCompound(); te.writeToNBT(entity.tileEntity); } final boolean blockRemoved = new BlockManipulator(world, player, x, y, z).setSilentTeRemove(true).remove(); if (!blockRemoved) return null; entity.setPositionAndRotation(x + 0.5, y + 0.5, z + 0.5, 0, 0); return entity; }
public static boolean isAirBlock(World aWorld, int aX, int aY, int aZ) { Block tID = aWorld.getBlock(aX, aY, aZ); if (tID != Blocks.air) { return tID.isAir(aWorld, aX, aY, aZ); } return true; }
@Override public boolean onBlockActivated( World world, int x, int y, int z, EntityPlayer player, int side, float xOffset, float yOffset, float zOffset) { ItemStack ci = player.inventory.mainInventory[player.inventory.currentItem]; if (ci != null && Block.getBlockFromItem(ci.getItem()).equals(this)) { for (int i = y + 1, e = world.getActualHeight(); i < e; ++i) { Block block = world.getBlock(x, i, z); if (block.isAir(world, x, i, z) || block.isReplaceable(world, x, i, z)) { if (!world.isRemote && world.setBlock(x, i, z, this, 0, 3)) { world.playAuxSFXAtEntity(null, 2001, x, i, z, Block.getIdFromBlock(this)); if (!player.capabilities.isCreativeMode) { ci.stackSize--; if (ci.stackSize == 0) { player.inventory.mainInventory[player.inventory.currentItem] = null; } } } return true; } else if (!block.equals(this)) { return false; } } } return false; }
public void setBlock(World world, int x, int y, int z, Block block, int metadata) { Block b1 = world.getBlock(x, y, z); if (b1.isAir(world, x, y, z) || b1.isLeaves(world, x, y, z)) { world.setBlock(x, y, z, block, metadata, 2); } }
protected boolean isReplaceable(World world, int x, int y, int z) { Block block = world.getBlock(x, y, z); return block.isAir(world, x, y, z) || block.isLeaves(world, x, y, z) || block.isWood(world, x, y, z) || func_150523_a(block); }
@Override public void updateTick(World world, int x, int y, int z, Random rand) { // they don't disappear anymore int blocks = 0; for (int i = 0; i < ForgeDirection.VALID_DIRECTIONS.length; i++) { ForgeDirection dir = ForgeDirection.VALID_DIRECTIONS[i]; Block block = world.getBlock(x + dir.offsetX, y + dir.offsetY, z + dir.offsetZ); if (!block.isAir(world, x, y, z)) { blocks++; } } if (blocks != 6) { int randInt = 0; if (leafType == 3) { randInt = rand.nextInt(20); } else if (leafType < 2) { randInt = rand.nextInt(8); } else { randInt = rand.nextInt(10); } if (randInt == 2) { int meta = world.getBlockMetadata(x, y, z); if (meta != 5) { world.setBlockMetadataWithNotify(x, y, z, meta + 2, 2); } } } }
/* Tests a block to see if it can be mined with the current equipment * Returns 0 if it can't, -1 if it is cobble * Will return 2 if mined with pick, 3 if shovel, 1 if none * return 4 if just need to fill using the filler upgrade */ public int canMineBlock(int x, int y, int z) { BlockPos minePos = new BlockPos(x, y, z); IBlockState tryState = worldObj.getBlockState(minePos); Block tryBlock = tryState.getBlock(); if (tryBlock != null) { int meta = tryBlock.getMetaFromState(tryState); if ((tryBlock.getBlockHardness(tryState, worldObj, minePos) >= 0) && (!tryBlock.isAir(tryState, worldObj, minePos))) { boolean mine = false; // ProgressiveAutomation.logger.info("Tool: "+tryBlock.getHarvestTool(meta)+", Level: // "+tryBlock.getHarvestLevel(meta)+", Can use Pick: "+tryBlock.isToolEffective("pickaxe", // meta)); // ProgressiveAutomation.logger.info("Harvestable: // "+ForgeHooks.canToolHarvestBlock(tryBlock, meta, getStackInSlot(2))); if (tryBlock == Blocks.COBBLESTONE) { return -1; } if (tryBlock.getHarvestTool(tryState) == "chisel") { // this is compatibility for chisel 1 return 2; } else if (tryBlock.getHarvestTool(tryState) == "pickaxe") { if (ForgeHooks.canToolHarvestBlock(worldObj, minePos, getStackInSlot(2))) { // ProgressiveAutomation.logger.info("Tool can harvest"); return 2; } } else if (tryBlock.getHarvestTool(tryState) == "shovel") { if (ForgeHooks.canToolHarvestBlock(worldObj, minePos, getStackInSlot(3))) { return 3; } } else { if (!tryBlock.getMaterial(tryState).isLiquid()) { return 1; } } } // see if the filler upgrade is active, if it is then the block will need to be filled. if (hasUpgrade(UpgradeType.FILLER)) { if ((tryBlock.isAir(tryState, worldObj, minePos)) || (tryBlock.getMaterial(tryState).isLiquid())) { return 4; } } } return 0; }
private void genTreeLayer(int par1, int par2, int par3, float par4, byte par5, Block b) { int var7 = (int) (par4 + 0.618D); byte var8 = OTHER_COORD_PAIRS[par5]; byte var9 = OTHER_COORD_PAIRS[par5 + 3]; int[] var10 = new int[] {par1, par2, par3}; int[] var11 = new int[] {0, 0, 0}; int var12 = -var7; int var13 = -var7; for (var11[par5] = var10[par5]; var12 <= var7; ++var12) { var11[var8] = var10[var8] + var12; var13 = -var7; while (var13 <= var7) { double var15 = Math.sqrt( Math.pow(Math.abs(var12) + 0.5D, 2.0D) + Math.pow(Math.abs(var13) + 0.5D, 2.0D)); if (var15 > par4) { ++var13; } else { var11[var9] = var10[var9] + var13; Block var14 = this.worldObj.getBlock(var11[0], var11[1], var11[2]); if (!var14.isAir(worldObj, var11[0], var11[1], var11[2]) && (var14 != TFCBlocks.leaves || var14 != TFCBlocks.leaves2) && var14 != TFCBlocks.vine) { ++var13; } else { this.setBlockAndNotifyAdequately(worldObj, var11[0], var11[1], var11[2], b, treeId); if (rand.nextInt(8) > 0) { int side = rand.nextInt(4); if (side == 0 && worldObj.isAirBlock(var11[0] - 1, var11[1], var11[2])) { this.setBlockAndNotifyAdequately( worldObj, var11[0] - 1, var11[1], var11[2], TFCBlocks.vine, 8); } else if (side == 1 && worldObj.isAirBlock(var11[0], var11[1], var11[2] - 1)) { this.setBlockAndNotifyAdequately( worldObj, var11[0], var11[1], var11[2] - 1, TFCBlocks.vine, 1); } else if (side == 2 && worldObj.isAirBlock(var11[0] + 1, var11[1], var11[2])) { this.setBlockAndNotifyAdequately( worldObj, var11[0] + 1, var11[1], var11[2], TFCBlocks.vine, 2); } else if (side == 3 && worldObj.isAirBlock(var11[0], var11[1], var11[2] + 1)) { this.setBlockAndNotifyAdequately( worldObj, var11[0], var11[1], var11[2] + 1, TFCBlocks.vine, 4); } } ++var13; } } } } }
public void updateConnections() { for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) { Pos pos = new Pos(this).add(dir); Block b = pos.getBlock(getWorldObj()); if (connectedBlocks.containsKey(dir)) { // TODO notify that a block has changed if (connectedBlocks.get(dir) != b) connectedBlocks.remove(dir); } if (b != null && !b.isAir(getWorldObj(), xCoord, yCoord, zCoord)) { connectedBlocks.put(dir, b); } } }
public static boolean func_149831_e( World p_149831_0_, int p_149831_1_, int p_149831_2_, int p_149831_3_) { Block block = p_149831_0_.getBlock(p_149831_1_, p_149831_2_, p_149831_3_); if (block.isAir(p_149831_0_, p_149831_1_, p_149831_2_, p_149831_3_)) { return true; } else if (block == Blocks.fire) { return true; } else { Material material = block.getMaterial(); return material == Material.water ? true : material == Material.lava; } }
public static int getTopBlockY(World world, int x, int z) { int y = world.getChunkFromBlockCoords(x, z).getTopFilledSegment() + 16; Block block; do { if (--y < 0) { break; } block = world.getBlock(x, y, z); } while (block.isAir(world, x, y, z)); return y; }
public static boolean isPowerProviderOrWire(IBlockAccess world, int i, int j, int k, int l) { Block block = world.getBlock(i, j, k); if (block == AllDemDimensions.floatingWire || block == Blocks.redstone_wire) { return true; } else if (block.isAir(world, i, j, k)) { return false; } else if (block != Blocks.unpowered_repeater && block != Blocks.powered_repeater) { return (block != null && block.canConnectRedstone(world, i, j, k, l)); } else { int metadata = world.getBlockMetadata(i, j, k); return l == (metadata & 3) || l == Direction.rotateOpposite[metadata & 3]; } }
public static int getSurfaceBlockY(World world, int x, int z) { int y = world.getChunkFromBlockCoords(x, z).getTopFilledSegment() + 16; Block block; do { if (--y < 0) { break; } block = world.getBlock(x, y, z); } while (block.isAir(world, x, y, z) || block.isReplaceable(world, x, y, z) || block.isLeaves(world, x, y, z) || block.isFoliage(world, x, y, z) || block.canBeReplacedByLeaves(world, x, y, z)); return y; }
@Override public boolean onItemUse( ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side, float sx, float sy, float sz) { TileEntity te = world.getTileEntity(x, y, z); NBTTagCompound tagCompound = stack.getTagCompound(); if (tagCompound == null) { tagCompound = new NBTTagCompound(); } if (te instanceof CounterTileEntity) { tagCompound.setInteger("dim", world.provider.dimensionId); tagCompound.setInteger("monitorx", x); tagCompound.setInteger("monitory", y); tagCompound.setInteger("monitorz", z); Block block = player.worldObj.getBlock(x, y, z); String name = "<invalid>"; if (block != null && !block.isAir(world, x, y, z)) { name = BlockInfo.getReadableName(block, world.getBlockMetadata(x, y, z)); } tagCompound.setString("monitorname", name); if (world.isRemote) { Logging.message(player, "Counter module is set to block '" + name + "'"); } } else { tagCompound.removeTag("dim"); tagCompound.removeTag("monitorx"); tagCompound.removeTag("monitory"); tagCompound.removeTag("monitorz"); tagCompound.removeTag("monitorname"); if (world.isRemote) { Logging.message(player, "Counter module is cleared"); } } stack.setTagCompound(tagCompound); return true; }
BlockPos getHorizon(World world, BlockPos pos) { if (!world.getChunkProvider().chunkExists(pos.getX() >> 4, pos.getZ() >> 4)) { return null; } BlockPos horizon = world.getHorizon(pos); Block block = world.getBlockState(horizon.down()).getBlock(); // This stuff is probably no longer needed but to lazy to test the code without it atm while (block instanceof BlockLeavesVC || block instanceof BlockLogVC || block instanceof BlockVineVC || block.isAir(world, pos)) { horizon = horizon.down(); block = world.getBlockState(horizon).getBlock(); if (horizon.getY() < 100) return null; } return horizon; }
/** * Equivalent code to the creative pick block * * @param target The client target vector * @param player The player trying to pick * @return the stack expected for the creative pick button */ private static ItemStack getItemFromPointedAt(MovingObjectPosition target, EntityPlayer player) { if (target != null) { if (target.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK) { BlockPos pos = target.getBlockPos(); World world = player.getEntityWorld(); Block block = world.getBlockState(pos).getBlock(); if (block.isAir(world, pos)) { return null; } return block.getPickBlock(target, world, pos); } else { if (target.typeOfHit != MovingObjectPosition.MovingObjectType.ENTITY || target.entityHit == null || !player.capabilities.isCreativeMode) { return null; } return target.entityHit.getPickedResult(target); } } return null; }
private int getTopBlock(World world, int x, int z) { Chunk chunk = world.getChunkFromBlockCoords(x, z); int y = chunk.getTopFilledSegment() + 15; int trimmedX = x & 15; int trimmedZ = z & 15; for (; y > 0; --y) { Block block = chunk.getBlock(trimmedX, y, trimmedZ); if (block.isAir(world, x, y, z)) { continue; } if (block instanceof BlockStaticLiquid) { return y; } if (block instanceof BlockFluidBase) { return y; } if (block instanceof IFluidBlock) { return y; } if (!block.getMaterial().blocksMovement()) { continue; } if (block instanceof BlockFlower) { continue; } return y - 1; } return -1; }
private void updateStorageList() { SyncedValueList<InvBlockInfo> inventories = tileEntity.getInventories(); if (inventories.getClientVersion() != clientVersion) { clientVersion = inventories.getClientVersion(); storageList.removeChildren(); for (InvBlockInfo blockInfo : inventories) { Coordinate c = blockInfo.getCoordinate(); Block block = mc.theWorld.getBlock(c.getX(), c.getY(), c.getZ()); int meta = mc.theWorld.getBlockMetadata(c.getX(), c.getY(), c.getZ()); String displayName; if (block == null || block.isAir(mc.theWorld, c.getX(), c.getY(), c.getZ())) { displayName = "[REMOVED]"; block = null; } else { displayName = BlockInfo.getReadableName(block, meta); } Panel panel = new Panel(mc, this).setLayout(new HorizontalLayout()); panel.addChild(new BlockRender(mc, this).setRenderItem(block)); panel.addChild( new Label(mc, this) .setText(displayName) .setHorizontalAlignment(HorizontalAlignment.ALIGH_LEFT) .setDesiredWidth(90)); panel.addChild(new Label(mc, this).setDynamic(true).setText(c.toString())); storageList.addChild(panel); } } storageList.clearHilightedRows(); Set<Coordinate> coordinates = fromServer_coordinates; int i = 0; for (InvBlockInfo blockInfo : inventories) { Coordinate c = blockInfo.getCoordinate(); if (coordinates.contains(c)) { storageList.addHilightedRow(i); } i++; } }
/** * Checks a line of blocks in the world from the first coordinate to triplet to the second, * returning the distance (in blocks) before a non-air, non-leaf block is encountered and/or the * end is encountered. */ private int checkBlockLine(int[] par1ArrayOfInteger, int[] par2ArrayOfInteger) { int[] var3 = new int[] {0, 0, 0}; byte var4 = 0; byte var5; for (var5 = 0; var4 < 3; ++var4) { var3[var4] = par2ArrayOfInteger[var4] - par1ArrayOfInteger[var4]; if (Math.abs(var3[var4]) > Math.abs(var3[var5])) var5 = var4; } if (var3[var5] == 0) { return -1; } else { byte var6 = OTHER_COORD_PAIRS[var5]; byte var7 = OTHER_COORD_PAIRS[var5 + 3]; byte var8; if (var3[var5] > 0) var8 = 1; else var8 = -1; double var9 = (double) var3[var6] / (double) var3[var5]; double var11 = (double) var3[var7] / (double) var3[var5]; int[] var13 = new int[] {0, 0, 0}; int var14 = 0; int var15; for (var15 = var3[var5] + var8; var14 != var15; var14 += var8) { var13[var5] = par1ArrayOfInteger[var5] + var14; var13[var6] = MathHelper.floor_double(par1ArrayOfInteger[var6] + var14 * var9); var13[var7] = MathHelper.floor_double(par1ArrayOfInteger[var7] + var14 * var11); Block var16 = this.worldObj.getBlock(var13[0], var13[1], var13[2]); if (!var16.isAir(worldObj, var13[0], var13[1], var13[2]) && (var16 != TFCBlocks.leaves || var16 != TFCBlocks.leaves2) && var16 != TFCBlocks.vine) break; } return var14 == var15 ? -1 : Math.abs(var14); } }
public static void removeBlockWithDrops( SpellContext context, EntityPlayer player, World world, ItemStack tool, BlockPos pos, boolean particles) { if (!world.isBlockLoaded(pos) || context.positionBroken != null && pos.equals(context.positionBroken.getBlockPos())) return; int harvestLevel = ConfigHandler.cadHarvestLevel; IBlockState state = world.getBlockState(pos); Block block = state.getBlock(); if (!world.isRemote && block != null && !block.isAir(world, pos) && !(block instanceof BlockLiquid) && block.getPlayerRelativeBlockHardness(player, world, pos) > 0) { int neededHarvestLevel = block.getHarvestLevel(state); if (neededHarvestLevel > harvestLevel) return; BreakEvent event = new BreakEvent(world, pos, state, player); MinecraftForge.EVENT_BUS.post(event); if (!event.isCanceled()) { if (!player.capabilities.isCreativeMode) { block.onBlockHarvested(world, pos, state, player); if (block.removedByPlayer(world, pos, player, true)) { block.onBlockDestroyedByPlayer(world, pos, state); block.harvestBlock(world, player, pos, state, world.getTileEntity(pos)); } } else world.setBlockToAir(pos); } if (particles) world.playAuxSFX(2001, pos, Block.getStateId(state)); } }
@Override public boolean generate(World world, Random rand, int x, int y, int z) { Block block; do { block = world.getBlock(x, y, z); if (!(block.isLeaves(world, x, y, z) || block.isAir(world, x, y, z))) { break; } --y; } while (y > 0); Block block1 = world.getBlock(x, y, z); if (TFC_Core.isSoil(block1)) { ++y; this.setBlockAndNotifyAdequately(world, x, y, z, TFCBlocks.logNatural, this.meta); for (int l = y; l <= y + 2; ++l) { int i1 = l - y; int j1 = 2 - i1; for (int k1 = x - j1; k1 <= x + j1; ++k1) { int l1 = k1 - x; for (int i2 = z - j1; i2 <= z + j1; ++i2) { int j2 = i2 - z; if ((Math.abs(l1) != j1 || Math.abs(j2) != j1 || rand.nextInt(2) != 0) && world.getBlock(k1, l, i2).canBeReplacedByLeaves(world, k1, l, i2)) { this.setBlockAndNotifyAdequately(world, k1, l, i2, TFCBlocks.leaves, this.meta); } } } } } return true; }
@Override public void onUpdate() { super.onUpdate(); if (supertile.getWorld().isRemote || redstoneSignal > 0) return; if (ticksExisted % 10 == 0) { IBlockState filter = getUnderlyingBlock(); boolean scanned = false; List<BlockPos> validPositions = new ArrayList<>(); int rangePlace = getRange(); int rangePlaceY = getRangeY(); BlockPos pos = supertile.getPos(); List<EntityItem> items = supertile .getWorld() .getEntitiesWithinAABB( EntityItem.class, new AxisAlignedBB( supertile.getPos().add(-RANGE, -RANGE_Y, -RANGE), supertile.getPos().add(RANGE + 1, RANGE_Y + 1, RANGE + 1))); int slowdown = getSlowdownFactor(); for (EntityItem item : items) { int age; try { age = (int) MethodHandles.itemAge_getter.invokeExact(item); } catch (Throwable t) { continue; } if (age < (60 + slowdown) || item.isDead) continue; ItemStack stack = item.getEntityItem(); Item stackItem = stack.getItem(); if (stackItem instanceof ItemBlock || stackItem instanceof ItemBlockSpecial || stackItem instanceof ItemRedstone || stackItem instanceof IFlowerPlaceable) { if (!scanned) { for (BlockPos pos_ : BlockPos.getAllInBox( pos.add(-rangePlace, -rangePlaceY, -rangePlace), pos.add(rangePlace, rangePlaceY, rangePlace))) { IBlockState stateAbove = supertile.getWorld().getBlockState(pos_.up()); Block blockAbove = stateAbove.getBlock(); BlockPos up = pos_.up(); if (filter == supertile.getWorld().getBlockState(pos_) && (blockAbove.isAir(stateAbove, supertile.getWorld(), up) || blockAbove.isReplaceable(supertile.getWorld(), up))) validPositions.add(up); } scanned = true; } if (!validPositions.isEmpty()) { BlockPos coords = validPositions.get(supertile.getWorld().rand.nextInt(validPositions.size())); IBlockState stateToPlace = null; if (stackItem instanceof IFlowerPlaceable) stateToPlace = ((IFlowerPlaceable) stackItem).getBlockToPlaceByFlower(stack, this, coords); if (stackItem instanceof ItemBlock) stateToPlace = ((ItemBlock) stackItem) .block.getStateFromMeta(stackItem.getMetadata(stack.getItemDamage())); else if (stackItem instanceof ItemBlockSpecial) stateToPlace = ((Block) ReflectionHelper.getPrivateValue( ItemBlockSpecial.class, (ItemBlockSpecial) stackItem, LibObfuscation.REED_ITEM)) .getDefaultState(); else if (stackItem instanceof ItemRedstone) stateToPlace = Blocks.REDSTONE_WIRE.getDefaultState(); if (stateToPlace != null) { if (stateToPlace.getBlock().canPlaceBlockAt(supertile.getWorld(), coords)) { supertile.getWorld().setBlockState(coords, stateToPlace, 1 | 2); if (ConfigHandler.blockBreakParticles) supertile.getWorld().playEvent(2001, coords, Block.getStateId(stateToPlace)); validPositions.remove(coords); TileEntity tile = supertile.getWorld().getTileEntity(coords); if (tile != null && tile instanceof ISubTileContainer) { ISubTileContainer container = (ISubTileContainer) tile; String subtileName = ItemBlockSpecialFlower.getType(stack); container.setSubTile(subtileName); SubTileEntity subtile = container.getSubTile(); subtile.onBlockPlacedBy( supertile.getWorld(), coords, supertile.getWorld().getBlockState(coords), null, stack); } if (stackItem instanceof IFlowerPlaceable) ((IFlowerPlaceable) stackItem).onBlockPlacedByFlower(stack, this, coords); stack.stackSize--; if (stack.stackSize <= 0) item.setDead(); if (mana > 1) mana--; return; } } } } } } }
public static StorageChunk copyWorldBB(World world, AxisAlignedBB bb) { int actualMinX = (int) bb.maxX, actualMinY = (int) bb.maxY, actualMinZ = (int) bb.maxZ, actualMaxX = (int) bb.minX, actualMaxY = (int) bb.minY, actualMaxZ = (int) bb.minZ; // Try to fit to smallest bounds for (int x = (int) bb.minX; x <= bb.maxX; x++) { for (int z = (int) bb.minZ; z <= bb.maxZ; z++) { for (int y = (int) bb.minY; y <= bb.maxY; y++) { Block block = world.getBlock(x, y, z); if (!block.isAir(world, x, y, z)) { if (x < actualMinX) actualMinX = x; if (y < actualMinY) actualMinY = y; if (z < actualMinZ) actualMinZ = z; if (x > actualMaxX) actualMaxX = x; if (y > actualMaxY) actualMaxY = y; if (z > actualMaxZ) actualMaxZ = z; } } } } bb.setBounds(actualMinX, actualMinY, actualMinZ, actualMaxX, actualMaxY, actualMaxZ); StorageChunk ret = new StorageChunk( (actualMaxX - actualMinX + 1), (actualMaxY - actualMinY + 1), (actualMaxZ - actualMinZ + 1)); // Iterate though the bounds given storing blocks/meta/tiles for (int x = actualMinX; x <= actualMaxX; x++) { for (int z = actualMinZ; z <= actualMaxZ; z++) { for (int y = actualMinY; y <= actualMaxY; y++) { ret.blocks[x - actualMinX][y - actualMinY][z - actualMinZ] = world.getBlock(x, y, z); ret.metas[x - actualMinX][y - actualMinY][z - actualMinZ] = (short) world.getBlockMetadata(x, y, z); TileEntity entity = world.getTileEntity(x, y, z); if (entity != null) { NBTTagCompound nbt = new NBTTagCompound(); entity.writeToNBT(nbt); // Transform tileEntity coords nbt.setInteger("x", nbt.getInteger("x") - actualMinX); nbt.setInteger("y", nbt.getInteger("y") - actualMinY); nbt.setInteger("z", nbt.getInteger("z") - actualMinZ); TileEntity newTile = TileEntity.createAndLoadEntity(nbt); newTile.setWorldObj(world); if (isUsableBlock(newTile)) { ret.usableTiles.add(newTile); } ret.tileEntities.add(newTile); } } } } return ret; }
public boolean generate( World p_76484_1_, Random p_76484_2_, int p_76484_3_, int p_76484_4_, int p_76484_5_) { int l = p_76484_2_.nextInt(2); if (this.mushroomType >= 0) { l = this.mushroomType; } int i1 = p_76484_2_.nextInt(3) + 4; boolean flag = true; if (p_76484_4_ >= 1 && p_76484_4_ + i1 + 1 < 256) { int k1; int l1; for (int j1 = p_76484_4_; j1 <= p_76484_4_ + 1 + i1; ++j1) { byte b0 = 3; if (j1 <= p_76484_4_ + 3) { b0 = 0; } for (k1 = p_76484_3_ - b0; k1 <= p_76484_3_ + b0 && flag; ++k1) { for (l1 = p_76484_5_ - b0; l1 <= p_76484_5_ + b0 && flag; ++l1) { if (j1 >= 0 && j1 < 256) { Block block = p_76484_1_.getBlock(k1, j1, l1); if (!block.isAir(p_76484_1_, k1, j1, l1) && !block.isLeaves(p_76484_1_, k1, j1, l1)) { flag = false; } } else { flag = false; } } } } if (!flag) { return false; } else { Block block1 = p_76484_1_.getBlock(p_76484_3_, p_76484_4_ - 1, p_76484_5_); if (block1 != Blocks.dirt && block1 != Blocks.grass && block1 != EnhancedBiomesBlocks.dirtEB && block1 != EnhancedBiomesBlocks.grassEB && block1 != Blocks.mycelium) { return false; } else { int k2 = p_76484_4_ + i1; if (l == 1) { k2 = p_76484_4_ + i1 - 3; } for (k1 = k2; k1 <= p_76484_4_ + i1; ++k1) { l1 = 1; if (k1 < p_76484_4_ + i1) { ++l1; } if (l == 0) { l1 = 3; } for (int l2 = p_76484_3_ - l1; l2 <= p_76484_3_ + l1; ++l2) { for (int i2 = p_76484_5_ - l1; i2 <= p_76484_5_ + l1; ++i2) { int j2 = 5; if (l2 == p_76484_3_ - l1) { --j2; } if (l2 == p_76484_3_ + l1) { ++j2; } if (i2 == p_76484_5_ - l1) { j2 -= 3; } if (i2 == p_76484_5_ + l1) { j2 += 3; } if (l == 0 || k1 < p_76484_4_ + i1) { if ((l2 == p_76484_3_ - l1 || l2 == p_76484_3_ + l1) && (i2 == p_76484_5_ - l1 || i2 == p_76484_5_ + l1)) { continue; } if (l2 == p_76484_3_ - (l1 - 1) && i2 == p_76484_5_ - l1) { j2 = 1; } if (l2 == p_76484_3_ - l1 && i2 == p_76484_5_ - (l1 - 1)) { j2 = 1; } if (l2 == p_76484_3_ + (l1 - 1) && i2 == p_76484_5_ - l1) { j2 = 3; } if (l2 == p_76484_3_ + l1 && i2 == p_76484_5_ - (l1 - 1)) { j2 = 3; } if (l2 == p_76484_3_ - (l1 - 1) && i2 == p_76484_5_ + l1) { j2 = 7; } if (l2 == p_76484_3_ - l1 && i2 == p_76484_5_ + (l1 - 1)) { j2 = 7; } if (l2 == p_76484_3_ + (l1 - 1) && i2 == p_76484_5_ + l1) { j2 = 9; } if (l2 == p_76484_3_ + l1 && i2 == p_76484_5_ + (l1 - 1)) { j2 = 9; } } if (j2 == 5 && k1 < p_76484_4_ + i1) { j2 = 0; } if ((j2 != 0 || p_76484_4_ >= p_76484_4_ + i1 - 1) && p_76484_1_ .getBlock(l2, k1, i2) .canBeReplacedByLeaves(p_76484_1_, l2, k1, i2)) { this.setBlockAndNotifyAdequately( p_76484_1_, l2, k1, i2, Block.getBlockById(Block.getIdFromBlock(Blocks.brown_mushroom_block) + l), j2); } } } } for (k1 = 0; k1 < i1; ++k1) { Block block2 = p_76484_1_.getBlock(p_76484_3_, p_76484_4_ + k1, p_76484_5_); if (block2.canBeReplacedByLeaves(p_76484_1_, p_76484_3_, p_76484_4_ + k1, p_76484_5_)) { this.setBlockAndNotifyAdequately( p_76484_1_, p_76484_3_, p_76484_4_ + k1, p_76484_5_, Block.getBlockById(Block.getIdFromBlock(Blocks.brown_mushroom_block) + l), 10); } } return true; } } } else { return false; } }
public boolean generate(World par1World, Random par2Random, int par3, int par4, int par5) { int l = par2Random.nextInt(2); if (this.mushroomType >= 0) { l = this.mushroomType; } int i1 = par2Random.nextInt(3) + 4; boolean flag = true; if (par4 >= 1 && par4 + i1 + 1 < 256) { int k1; int l1; for (int j1 = par4; j1 <= par4 + 1 + i1; ++j1) { byte b0 = 3; if (j1 <= par4 + 3) { b0 = 0; } for (k1 = par3 - b0; k1 <= par3 + b0 && flag; ++k1) { for (l1 = par5 - b0; l1 <= par5 + b0 && flag; ++l1) { if (j1 >= 0 && j1 < 256) { Block block = par1World.getBlock(k1, j1, l1); if (!block.isAir(par1World, k1, j1, l1) && !block.isLeaves(par1World, k1, j1, l1)) { flag = false; } } else { flag = false; } } } } if (!flag) { return false; } else { Block block1 = par1World.getBlock(par3, par4 - 1, par5); if (block1 != Blocks.dirt && block1 != Blocks.grass && block1 != Blocks.mycelium) { return false; } else { int k2 = par4 + i1; if (l == 1) { k2 = par4 + i1 - 3; } for (k1 = k2; k1 <= par4 + i1; ++k1) { l1 = 1; if (k1 < par4 + i1) { ++l1; } if (l == 0) { l1 = 3; } for (int l2 = par3 - l1; l2 <= par3 + l1; ++l2) { for (int i2 = par5 - l1; i2 <= par5 + l1; ++i2) { int j2 = 5; if (l2 == par3 - l1) { --j2; } if (l2 == par3 + l1) { ++j2; } if (i2 == par5 - l1) { j2 -= 3; } if (i2 == par5 + l1) { j2 += 3; } if (l == 0 || k1 < par4 + i1) { if ((l2 == par3 - l1 || l2 == par3 + l1) && (i2 == par5 - l1 || i2 == par5 + l1)) { continue; } if (l2 == par3 - (l1 - 1) && i2 == par5 - l1) { j2 = 1; } if (l2 == par3 - l1 && i2 == par5 - (l1 - 1)) { j2 = 1; } if (l2 == par3 + (l1 - 1) && i2 == par5 - l1) { j2 = 3; } if (l2 == par3 + l1 && i2 == par5 - (l1 - 1)) { j2 = 3; } if (l2 == par3 - (l1 - 1) && i2 == par5 + l1) { j2 = 7; } if (l2 == par3 - l1 && i2 == par5 + (l1 - 1)) { j2 = 7; } if (l2 == par3 + (l1 - 1) && i2 == par5 + l1) { j2 = 9; } if (l2 == par3 + l1 && i2 == par5 + (l1 - 1)) { j2 = 9; } } if (j2 == 5 && k1 < par4 + i1) { j2 = 0; } if ((j2 != 0 || par4 >= par4 + i1 - 1) && par1World .getBlock(l2, k1, i2) .canBeReplacedByLeaves(par1World, l2, k1, i2)) { this.setBlockAndNotifyAdequately( par1World, l2, k1, i2, Block.getBlockById(Block.getIdFromBlock(Blocks.brown_mushroom_block) + l), j2); } } } } for (k1 = 0; k1 < i1; ++k1) { Block block2 = par1World.getBlock(par3, par4 + k1, par5); if (block2.canBeReplacedByLeaves(par1World, par3, par4 + k1, par5)) { this.setBlockAndNotifyAdequately( par1World, par3, par4 + k1, par5, Block.getBlockById(Block.getIdFromBlock(Blocks.brown_mushroom_block) + l), 10); } } return true; } } } else { return false; } }
protected void updateAITasks() { int i; if (this.func_82212_n() > 0) { i = this.func_82212_n() - 1; if (i <= 0) { this.worldObj.newExplosion( this, this.posX, this.posY + (double) this.getEyeHeight(), this.posZ, 7.0F, false, this.worldObj.getGameRules().getGameRuleBooleanValue("mobGriefing")); this.worldObj.playBroadcastSound( 1013, (int) this.posX, (int) this.posY, (int) this.posZ, 0); } this.func_82215_s(i); if (this.ticksExisted % 10 == 0) { this.heal(10.0F); } } else { super.updateAITasks(); int i1; for (i = 1; i < 3; ++i) { if (this.ticksExisted >= this.field_82223_h[i - 1]) { this.field_82223_h[i - 1] = this.ticksExisted + 10 + this.rand.nextInt(10); if (this.worldObj.difficultySetting == EnumDifficulty.NORMAL || this.worldObj.difficultySetting == EnumDifficulty.HARD) { int k2 = i - 1; int l2 = this.field_82224_i[i - 1]; this.field_82224_i[k2] = this.field_82224_i[i - 1] + 1; if (l2 > 15) { float f = 10.0F; float f1 = 5.0F; double d0 = MathHelper.getRandomDoubleInRange( this.rand, this.posX - (double) f, this.posX + (double) f); double d1 = MathHelper.getRandomDoubleInRange( this.rand, this.posY - (double) f1, this.posY + (double) f1); double d2 = MathHelper.getRandomDoubleInRange( this.rand, this.posZ - (double) f, this.posZ + (double) f); this.func_82209_a(i + 1, d0, d1, d2, true); this.field_82224_i[i - 1] = 0; } } i1 = this.getWatchedTargetId(i); if (i1 > 0) { Entity entity = this.worldObj.getEntityByID(i1); if (entity != null && entity.isEntityAlive() && this.getDistanceSqToEntity(entity) <= 900.0D && this.canEntityBeSeen(entity)) { this.func_82216_a(i + 1, (EntityLivingBase) entity); this.field_82223_h[i - 1] = this.ticksExisted + 40 + this.rand.nextInt(20); this.field_82224_i[i - 1] = 0; } else { this.func_82211_c(i, 0); } } else { List list = this.worldObj.selectEntitiesWithinAABB( EntityLivingBase.class, this.boundingBox.expand(20.0D, 8.0D, 20.0D), attackEntitySelector); for (int k1 = 0; k1 < 10 && !list.isEmpty(); ++k1) { EntityLivingBase entitylivingbase = (EntityLivingBase) list.get(this.rand.nextInt(list.size())); if (entitylivingbase != this && entitylivingbase.isEntityAlive() && this.canEntityBeSeen(entitylivingbase)) { if (entitylivingbase instanceof EntityPlayer) { if (!((EntityPlayer) entitylivingbase).capabilities.disableDamage) { this.func_82211_c(i, entitylivingbase.getEntityId()); } } else { this.func_82211_c(i, entitylivingbase.getEntityId()); } break; } list.remove(entitylivingbase); } } } } if (this.getAttackTarget() != null) { this.func_82211_c(0, this.getAttackTarget().getEntityId()); } else { this.func_82211_c(0, 0); } if (this.field_82222_j > 0) { --this.field_82222_j; if (this.field_82222_j == 0 && this.worldObj.getGameRules().getGameRuleBooleanValue("mobGriefing")) { i = MathHelper.floor_double(this.posY); i1 = MathHelper.floor_double(this.posX); int j1 = MathHelper.floor_double(this.posZ); boolean flag = false; for (int l1 = -1; l1 <= 1; ++l1) { for (int i2 = -1; i2 <= 1; ++i2) { for (int j = 0; j <= 3; ++j) { int j2 = i1 + l1; int k = i + j; int l = j1 + i2; Block block = this.worldObj.getBlock(j2, k, l); if (!block.isAir(worldObj, j2, k, l) && block.canEntityDestroy(worldObj, j2, k, l, this)) { flag = this.worldObj.func_147480_a(j2, k, l, true) || flag; } } } } if (flag) { this.worldObj.playAuxSFXAtEntity( (EntityPlayer) null, 1012, (int) this.posX, (int) this.posY, (int) this.posZ, 0); } } } if (this.ticksExisted % 20 == 0) { this.heal(1.0F); } } }
@Override @SuppressWarnings("unchecked") public void onUpdate() { super.onUpdate(); if (this.ticksExisted > 400) { if (this.isHot) { this.isHot = false; this.setHot(this.isHot); } } else if (!this.worldObj.isRemote) { this.setHot(this.isHot); } if (this.prevRotationPitch == 0.0F && this.prevRotationYaw == 0.0F) { float f = MathHelper.sqrt_double(this.motionX * this.motionX + this.motionZ * this.motionZ); this.prevRotationYaw = this.rotationYaw = (float) (Math.atan2(this.motionX, this.motionZ) * 180.0D / Math.PI); this.prevRotationPitch = this.rotationPitch = (float) (Math.atan2(this.motionY, f) * 180.0D / Math.PI); } BlockPos pos = new BlockPos(this.xTile, this.yTile, this.zTile); Block block = this.worldObj.getBlockState(pos).getBlock(); if (!block.isAir(this.worldObj, pos)) { block.setBlockBoundsBasedOnState(this.worldObj, pos); AxisAlignedBB axisalignedbb = block.getCollisionBoundingBox(this.worldObj, pos, this.worldObj.getBlockState(pos)); if (axisalignedbb != null && axisalignedbb.isVecInside(new Vec3(this.posX, this.posY, this.posZ))) { this.inGround = true; } } if (this.inGround) { Block j = this.worldObj.getBlockState(pos).getBlock(); int k = j.getMetaFromState(this.worldObj.getBlockState(pos)); if (j == this.inTile && k == this.inData) { ++this.ticksInGround; if (this.ticksInGround == 1200) { this.setDead(); } } else { this.inGround = false; this.motionX *= this.rand.nextFloat() * 0.2F; this.motionY *= this.rand.nextFloat() * 0.2F; this.motionZ *= this.rand.nextFloat() * 0.2F; this.ticksInGround = 0; this.ticksInAir = 0; } } else { ++this.ticksInAir; Vec3 vec3 = new Vec3(this.posX, this.posY, this.posZ); Vec3 vec31 = new Vec3(this.posX + this.motionX, this.posY + this.motionY, this.posZ + this.motionZ); MovingObjectPosition movingobjectposition = this.worldObj.rayTraceBlocks(vec3, vec31, false, true, false); vec3 = new Vec3(this.posX, this.posY, this.posZ); vec31 = new Vec3(this.posX + this.motionX, this.posY + this.motionY, this.posZ + this.motionZ); if (movingobjectposition != null) { vec31 = new Vec3( movingobjectposition.hitVec.xCoord, movingobjectposition.hitVec.yCoord, movingobjectposition.hitVec.zCoord); } this.rotationPitch += 1F; Entity entity = null; List<Entity> list = this.worldObj.getEntitiesWithinAABBExcludingEntity( this, this.getEntityBoundingBox() .addCoord(this.motionX, this.motionY, this.motionZ) .expand(1.0D, 1.0D, 1.0D)); double d0 = 0.0D; int l; float f1; for (l = 0; l < list.size(); ++l) { Entity entity1 = list.get(l); if (entity1.canBeCollidedWith() && (entity1 != this.shootingEntity || this.ticksInAir >= 5)) { f1 = 0.3F; AxisAlignedBB axisalignedbb1 = entity1.getEntityBoundingBox().expand(f1, f1, f1); MovingObjectPosition movingobjectposition1 = axisalignedbb1.calculateIntercept(vec3, vec31); if (movingobjectposition1 != null) { double d1 = vec3.distanceTo(movingobjectposition1.hitVec); if (d1 < d0 || d0 == 0.0D) { entity = entity1; d0 = d1; } } } } if (entity != null) { movingobjectposition = new MovingObjectPosition(entity); } if (movingobjectposition != null && movingobjectposition.entityHit != null && movingobjectposition.entityHit instanceof EntityPlayer) { EntityPlayer entityplayer = (EntityPlayer) movingobjectposition.entityHit; if (entityplayer.capabilities.disableDamage || this.shootingEntity instanceof EntityPlayer && !((EntityPlayer) this.shootingEntity).canAttackPlayer(entityplayer)) { movingobjectposition = null; } } float f2; float f3; double damage = ConfigManagerCore.hardMode ? 3.2D : 1.6D; if (movingobjectposition != null) { if (movingobjectposition.entityHit != null) { f2 = MathHelper.sqrt_double( this.motionX * this.motionX + this.motionY * this.motionY + this.motionZ * this.motionZ); int i1 = MathHelper.ceiling_double_int(f2 * damage); DamageSource damagesource = null; if (this.shootingEntity == null) { damagesource = new EntityDamageSourceIndirect("meteorChunk", this, this).setProjectile(); } else { damagesource = new EntityDamageSourceIndirect("meteorChunk", this, this.shootingEntity) .setProjectile(); } if (this.isBurning() && !(movingobjectposition.entityHit instanceof EntityEnderman)) { movingobjectposition.entityHit.setFire(2); } if (movingobjectposition.entityHit.attackEntityFrom(damagesource, i1)) { if (movingobjectposition.entityHit instanceof EntityLivingBase) { EntityLivingBase entitylivingbase = (EntityLivingBase) movingobjectposition.entityHit; if (!this.worldObj.isRemote) { entitylivingbase.setArrowCountInEntity( entitylivingbase.getArrowCountInEntity() + 1); } if (this.knockbackStrength > 0) { f3 = MathHelper.sqrt_double( this.motionX * this.motionX + this.motionZ * this.motionZ); if (f3 > 0.0F) { movingobjectposition.entityHit.addVelocity( this.motionX * this.knockbackStrength * 0.6000000238418579D / f3, 0.1D, this.motionZ * this.knockbackStrength * 0.6000000238418579D / f3); } } if (this.shootingEntity != null) { EnchantmentHelper.applyThornEnchantments(entitylivingbase, this.shootingEntity); EnchantmentHelper.applyArthropodEnchantments( (EntityLivingBase) this.shootingEntity, entitylivingbase); } if (this.shootingEntity != null && movingobjectposition.entityHit != this.shootingEntity && movingobjectposition.entityHit instanceof EntityPlayer && this.shootingEntity instanceof EntityPlayerMP) { ((EntityPlayerMP) this.shootingEntity) .playerNetServerHandler.sendPacket(new S2BPacketChangeGameState(6, 0.0F)); } } if (!(movingobjectposition.entityHit instanceof EntityEnderman)) { this.setDead(); } } else { this.motionX *= -0.10000000149011612D; this.motionY *= -0.10000000149011612D; this.motionZ *= -0.10000000149011612D; this.rotationYaw += 180.0F; this.prevRotationYaw += 180.0F; this.ticksInAir = 0; } } else { this.xTile = movingobjectposition.getBlockPos().getX(); this.yTile = movingobjectposition.getBlockPos().getY(); this.zTile = movingobjectposition.getBlockPos().getZ(); IBlockState state = this.worldObj.getBlockState(movingobjectposition.getBlockPos()); this.inTile = state.getBlock(); this.inData = this.inTile.getMetaFromState(state); this.motionX = (float) (movingobjectposition.hitVec.xCoord - this.posX); this.motionY = (float) (movingobjectposition.hitVec.yCoord - this.posY); this.motionZ = (float) (movingobjectposition.hitVec.zCoord - this.posZ); f2 = MathHelper.sqrt_double( this.motionX * this.motionX + this.motionY * this.motionY + this.motionZ * this.motionZ); this.posX -= this.motionX / f2 * 0.05000000074505806D; this.posY -= this.motionY / f2 * 0.05000000074505806D; this.posZ -= this.motionZ / f2 * 0.05000000074505806D; this.inGround = true; if (!this.inTile.isAir(this.worldObj, movingobjectposition.getBlockPos())) { this.inTile.onEntityCollidedWithBlock( this.worldObj, movingobjectposition.getBlockPos(), this); } } } this.posX += this.motionX; this.posY += this.motionY; this.posZ += this.motionZ; f2 = MathHelper.sqrt_double(this.motionX * this.motionX + this.motionZ * this.motionZ); if (!this.onGround) { this.rotationPitch += 10; this.rotationYaw += 2; } float f4 = 0.99F; f1 = 0.05F; if (this.isInWater()) { for (int j1 = 0; j1 < 4; ++j1) { f3 = 0.25F; this.worldObj.spawnParticle( EnumParticleTypes.WATER_BUBBLE, this.posX - this.motionX * f3, this.posY - this.motionY * f3, this.posZ - this.motionZ * f3, this.motionX, this.motionY, this.motionZ); } f4 = 0.8F; } this.motionX *= f4; this.motionY *= f4; this.motionZ *= f4; this.motionY -= WorldUtil.getGravityForEntity(this); this.setPosition(this.posX, this.posY, this.posZ); this.doBlockCollisions(); } }
// public static ArrayListMultimap<ChunkCoordinates, AxisAlignedBB> additionalBlockBounds = // ArrayListMultimap.create(); // public static void addAdditionalBlockBounds(ChunkCoordinates cc, AxisAlignedBB aabb) // { // for(AxisAlignedBB aabb1 : additionalBlockBounds.get(cc)) // if(aabb1.toString().equals(aabb.toString())) // return; // additionalBlockBounds.put(cc, aabb); // } @SubscribeEvent() public void renderAdditionalBlockBounds(DrawBlockHighlightEvent event) { if (event.subID == 0 && event.target.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK) { float f1 = 0.002F; double d0 = event.player.lastTickPosX + (event.player.posX - event.player.lastTickPosX) * (double) event.partialTicks; double d1 = event.player.lastTickPosY + (event.player.posY - event.player.lastTickPosY) * (double) event.partialTicks; double d2 = event.player.lastTickPosZ + (event.player.posZ - event.player.lastTickPosZ) * (double) event.partialTicks; // if(additionalBlockBounds.containsKey(new // ChunkCoordinates(event.target.blockX,event.target.blockY,event.target.blockZ))) if (event.player.worldObj.getBlock( event.target.blockX, event.target.blockY, event.target.blockZ) instanceof IEBlockInterfaces.ICustomBoundingboxes) { ChunkCoordinates cc = new ChunkCoordinates(event.target.blockX, event.target.blockY, event.target.blockZ); IEBlockInterfaces.ICustomBoundingboxes block = (IEBlockInterfaces.ICustomBoundingboxes) event.player.worldObj.getBlock( event.target.blockX, event.target.blockY, event.target.blockZ); Set<AxisAlignedBB> set = block.addCustomSelectionBoxesToList( event.player.worldObj, cc.posX, cc.posY, cc.posZ, event.player); if (!set.isEmpty()) { // // if(!(event.player.worldObj.getTileEntity(event.target.blockX,event.target.blockY,event.target.blockZ) instanceof IEBlockInterfaces.ICustomBoundingboxes)) // { // additionalBlockBounds.removeAll(cc); // return; // } GL11.glEnable(GL11.GL_BLEND); OpenGlHelper.glBlendFunc(770, 771, 1, 0); GL11.glColor4f(0.0F, 0.0F, 0.0F, 0.4F); GL11.glLineWidth(2.0F); GL11.glDisable(GL11.GL_TEXTURE_2D); GL11.glDepthMask(false); for (AxisAlignedBB aabb : set) // for(AxisAlignedBB aabb : additionalBlockBounds.get(cc)) if (aabb != null) RenderGlobal.drawOutlinedBoundingBox( aabb.getOffsetBoundingBox(cc.posX, cc.posY, cc.posZ) .expand((double) f1, (double) f1, (double) f1) .getOffsetBoundingBox(-d0, -d1, -d2), -1); GL11.glDepthMask(true); GL11.glEnable(GL11.GL_TEXTURE_2D); GL11.glDisable(GL11.GL_BLEND); event.setCanceled(true); } } ItemStack stack = event.player.getCurrentEquippedItem(); World world = event.player.worldObj; if (stack != null && stack.getItem() instanceof ItemDrill && ((ItemDrill) stack.getItem()) .isEffective( world .getBlock(event.target.blockX, event.target.blockY, event.target.blockZ) .getMaterial())) { ItemStack head = ((ItemDrill) stack.getItem()).getHead(stack); if (head != null) { int side = event.target.sideHit; int diameter = ((IDrillHead) head.getItem()).getMiningSize(head) + ((ItemDrill) stack.getItem()).getUpgrades(stack).getInteger("size"); int depth = ((IDrillHead) head.getItem()).getMiningDepth(head) + ((ItemDrill) stack.getItem()).getUpgrades(stack).getInteger("depth"); int startX = event.target.blockX; int startY = event.target.blockY; int startZ = event.target.blockZ; if (diameter % 2 == 0) // even numbers { float hx = (float) event.target.hitVec.xCoord - event.target.blockX; float hy = (float) event.target.hitVec.yCoord - event.target.blockY; float hz = (float) event.target.hitVec.zCoord - event.target.blockZ; if ((side < 2 && hx < .5) || (side < 4 && hx < .5)) startX -= diameter / 2; if (side > 1 && hy < .5) startY -= diameter / 2; if ((side < 2 && hz < .5) || (side > 3 && hz < .5)) startZ -= diameter / 2; } else // odd numbers { startX -= (side == 4 || side == 5 ? 0 : diameter / 2); startY -= (side == 0 || side == 1 ? 0 : diameter / 2); startZ -= (side == 2 || side == 3 ? 0 : diameter / 2); } GL11.glColor4f(0.1F, 0.1F, 0.1F, 0.4F); GL11.glLineWidth(1F); GL11.glDisable(GL11.GL_TEXTURE_2D); // AxisAlignedBB aabb = AxisAlignedBB.getBoundingBox(startX,startY,startZ, // startX+(side==4||side==5?1:diameter),startY+(side==0||side==1?1:diameter),startZ+(side==2||side==3?1: diameter)); // RenderGlobal.drawOutlinedBoundingBox(aabb.expand((double)f1, (double)f1, // (double)f1).getOffsetBoundingBox(-d0, -d1, -d2), -1); for (int dd = 0; dd < depth; dd++) for (int dw = 0; dw < diameter; dw++) for (int dh = 0; dh < diameter; dh++) { int x = startX + (side == 4 || side == 5 ? dd : dw); int y = startY + (side == 0 || side == 1 ? dd : dh); int z = startZ + (side == 0 || side == 1 ? dh : side == 4 || side == 5 ? dw : dd); Block block = event.player.worldObj.getBlock(x, y, z); if (block != null && !block.isAir(world, x, y, z) && block.getPlayerRelativeBlockHardness(event.player, world, x, y, z) != 0) { if (!((ItemDrill) stack.getItem()) .canBreakExtraBlock( world, block, x, y, z, world.getBlockMetadata(x, y, z), event.player, stack, head, false)) continue; AxisAlignedBB aabb = block.getSelectedBoundingBoxFromPool(event.player.worldObj, x, y, z); if (aabb != null) { RenderGlobal.drawOutlinedBoundingBox( aabb.expand((double) f1, (double) f1, (double) f1) .getOffsetBoundingBox(-d0, -d1, -d2), -1); } } } GL11.glDepthMask(true); GL11.glEnable(GL11.GL_TEXTURE_2D); GL11.glDisable(GL11.GL_BLEND); } } } }
public boolean generate( World p_76484_1_, Random p_76484_2_, int p_76484_3_, int p_76484_4_, int p_76484_5_) { int l = p_76484_2_.nextInt(height * 2) + height * 2; int i1 = height + p_76484_2_.nextInt(height); int j1 = l - i1; int k1 = 2 + p_76484_2_.nextInt(2); boolean flag = true; if (p_76484_4_ >= 1 && p_76484_4_ + l + 1 <= 256) { int i2; int l3; for (int l1 = p_76484_4_; l1 <= p_76484_4_ + 1 + l && flag; ++l1) { boolean flag1 = true; if (l1 - p_76484_4_ < i1) { l3 = 0; } else { l3 = k1; } for (i2 = p_76484_3_ - l3; i2 <= p_76484_3_ + l3 && flag; ++i2) { for (int j2 = p_76484_5_ - l3; j2 <= p_76484_5_ + l3 && flag; ++j2) { if (l1 >= 0 && l1 < 256) { Block block = p_76484_1_.getBlock(i2, l1, j2); if (!block.isAir(p_76484_1_, i2, l1, j2) && !block.isLeaves(p_76484_1_, i2, l1, j2) && block != Blocks.snow_layer) { flag = false; } } else { flag = false; } } } } if (!flag) { return false; } else { Block block1 = p_76484_1_.getBlock(p_76484_3_, p_76484_4_ - 1, p_76484_5_); boolean isSoil = block1.canSustainPlant( p_76484_1_, p_76484_3_, p_76484_4_ - 1, p_76484_5_, ForgeDirection.UP, (BlockSapling) Blocks.sapling); if (isSoil && p_76484_4_ < 256 - l - 1) { block1.onPlantGrow( p_76484_1_, p_76484_3_, p_76484_4_ - 1, p_76484_5_, p_76484_3_, p_76484_4_, p_76484_5_); l3 = p_76484_2_.nextInt(2); i2 = 1; byte b0 = 0; int k2; int i4; for (i4 = 0; i4 <= j1; ++i4) { k2 = p_76484_4_ + l - i4; for (int l2 = p_76484_3_ - l3; l2 <= p_76484_3_ + l3; ++l2) { int i3 = l2 - p_76484_3_; for (int j3 = p_76484_5_ - l3; j3 <= p_76484_5_ + l3; ++j3) { int k3 = j3 - p_76484_5_; if ((Math.abs(i3) != l3 || Math.abs(k3) != l3 || l3 <= 0) && p_76484_1_ .getBlock(l2, k2, j3) .canBeReplacedByLeaves(p_76484_1_, l2, k2, j3)) { p_76484_1_.setBlock(l2, k2, j3, Blocks.leaves, metadata, 0); } } } if (l3 >= i2) { l3 = b0; b0 = 1; ++i2; if (i2 > k1) { i2 = k1; } } else { ++l3; } } i4 = p_76484_2_.nextInt(3); for (k2 = 0; k2 < l - i4; ++k2) { Block block2 = p_76484_1_.getBlock(p_76484_3_, p_76484_4_ + k2, p_76484_5_); if (block2.isAir(p_76484_1_, p_76484_3_, p_76484_4_ + k2, p_76484_5_) || block2.isLeaves(p_76484_1_, p_76484_3_, p_76484_4_ + k2, p_76484_5_) || block2 == Blocks.snow_layer) { p_76484_1_.setBlock(p_76484_3_, p_76484_4_ + k2, p_76484_5_, Blocks.log, 0, 0); } } if (height > 4) { createTrunk(p_76484_1_, p_76484_2_, p_76484_3_, p_76484_4_, p_76484_5_); } return true; } else { return false; } } } else { return false; } }