From e1d46f1bc72d89f72feebd77a89326690c84bf35 Mon Sep 17 00:00:00 2001 From: Matt Caughey Date: Sat, 11 May 2013 03:44:32 -0400 Subject: [PATCH] Added big tree variants of the red and orange trees to the Seasonal Forest. --- .../biomes/BiomeGenSeasonalForest.java | 4 +- .../biomesoplenty/blocks/BlockBOPFoliage.java | 2 +- .../worldgen/WorldGenAutumn2Big.java | 518 ++++++++++++++++++ .../worldgen/WorldGenMapleBig.java | 518 ++++++++++++++++++ .../worldgen/WorldGenPromisedWillowTree.java | 4 +- .../worldgen/WorldGenReedBOP.java | 2 +- 6 files changed, 1043 insertions(+), 5 deletions(-) create mode 100644 src/minecraft/biomesoplenty/worldgen/WorldGenAutumn2Big.java create mode 100644 src/minecraft/biomesoplenty/worldgen/WorldGenMapleBig.java diff --git a/src/minecraft/biomesoplenty/biomes/BiomeGenSeasonalForest.java b/src/minecraft/biomesoplenty/biomes/BiomeGenSeasonalForest.java index 58a9742f3..667119356 100644 --- a/src/minecraft/biomesoplenty/biomes/BiomeGenSeasonalForest.java +++ b/src/minecraft/biomesoplenty/biomes/BiomeGenSeasonalForest.java @@ -6,8 +6,10 @@ import biomesoplenty.api.Blocks; import biomesoplenty.configuration.BOPBlocks; import biomesoplenty.worldgen.WorldGenAutumn; import biomesoplenty.worldgen.WorldGenAutumn2; +import biomesoplenty.worldgen.WorldGenAutumn2Big; import biomesoplenty.worldgen.WorldGenDeadTree2; import biomesoplenty.worldgen.WorldGenMaple; +import biomesoplenty.worldgen.WorldGenMapleBig; import net.minecraft.entity.passive.EntityWolf; import net.minecraft.item.ItemStack; @@ -47,7 +49,7 @@ public class BiomeGenSeasonalForest extends BiomeGenBase */ public WorldGenerator getRandomWorldGenForTrees(Random par1Random) { - return (WorldGenerator)(par1Random.nextInt(2) == 0 ? new WorldGenAutumn2(false) : (par1Random.nextInt(3) == 0 ? new WorldGenAutumn(false) : (par1Random.nextInt(3) == 0 ? new WorldGenMaple(false) : (par1Random.nextInt(5) == 0 ? new WorldGenDeadTree2(false) : this.worldGeneratorTrees)))); + return (WorldGenerator)(par1Random.nextInt(2) == 0 ? new WorldGenAutumn2(false) : (par1Random.nextInt(3) == 0 ? new WorldGenAutumn(false) : (par1Random.nextInt(6) == 0 ? new WorldGenAutumn2Big(false) : (par1Random.nextInt(6) == 0 ? new WorldGenMapleBig(false) : (par1Random.nextInt(3) == 0 ? new WorldGenMaple(false) : (par1Random.nextInt(5) == 0 ? new WorldGenDeadTree2(false) : (par1Random.nextInt(6) == 0 ? this.worldGeneratorBigTree : this.worldGeneratorTrees))))))); } /** diff --git a/src/minecraft/biomesoplenty/blocks/BlockBOPFoliage.java b/src/minecraft/biomesoplenty/blocks/BlockBOPFoliage.java index 3479b61c9..219ebc886 100644 --- a/src/minecraft/biomesoplenty/blocks/BlockBOPFoliage.java +++ b/src/minecraft/biomesoplenty/blocks/BlockBOPFoliage.java @@ -171,7 +171,7 @@ public class BlockBOPFoliage extends BlockFlower implements IShearable int meta = par1World.getBlockMetadata(x, y, z); if (!par1World.isRemote && meta == 7 && par5Entity instanceof EntityLiving) - ((EntityLiving)par5Entity).addPotionEffect(new PotionEffect(Potion.poison.id, 200)); + ((EntityLiving)par5Entity).addPotionEffect(new PotionEffect(Potion.poison.id, 100)); } @Override diff --git a/src/minecraft/biomesoplenty/worldgen/WorldGenAutumn2Big.java b/src/minecraft/biomesoplenty/worldgen/WorldGenAutumn2Big.java new file mode 100644 index 000000000..0e384eef6 --- /dev/null +++ b/src/minecraft/biomesoplenty/worldgen/WorldGenAutumn2Big.java @@ -0,0 +1,518 @@ +package biomesoplenty.worldgen; + +import java.util.Random; + +import biomesoplenty.api.Blocks; +import biomesoplenty.configuration.BOPBlocks; + +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraft.util.MathHelper; +import net.minecraft.world.World; +import net.minecraft.world.gen.feature.WorldGenerator; + +public class WorldGenAutumn2Big extends WorldGenerator +{ + /** + * Contains three sets of two values that provide complimentary indices for a given 'major' index - 1 and 2 for 0, 0 + * and 2 for 1, and 0 and 1 for 2. + */ + static final byte[] otherCoordPairs = new byte[] {(byte)2, (byte)0, (byte)0, (byte)1, (byte)2, (byte)1}; + + /** random seed for GenBigTree */ + Random rand = new Random(); + + /** Reference to the World object. */ + World worldObj; + int[] basePos = new int[] {0, 0, 0}; + int heightLimit = 0; + int height; + double heightAttenuation = 0.618D; + double branchDensity = 1.0D; + double branchSlope = 0.381D; + double scaleWidth = 1.0D; + double leafDensity = 1.0D; + + /** + * Currently always 1, can be set to 2 in the class constructor to generate a double-sized tree trunk for big trees. + */ + int trunkSize = 1; + + /** + * Sets the limit of the random value used to initialize the height limit. + */ + int heightLimitLimit = 12; + + /** + * Sets the distance limit for how far away the generator will populate leaves from the base leaf node. + */ + int leafDistanceLimit = 4; + + /** Contains a list of a points at which to generate groups of leaves. */ + int[][] leafNodes; + + public WorldGenAutumn2Big(boolean par1) + { + super(par1); + } + + /** + * Generates a list of leaf nodes for the tree, to be populated by generateLeaves. + */ + void generateLeafNodeList() + { + this.height = (int)((double)this.heightLimit * this.heightAttenuation); + + if (this.height >= this.heightLimit) + { + this.height = this.heightLimit - 1; + } + + int var1 = (int)(1.382D + Math.pow(this.leafDensity * (double)this.heightLimit / 13.0D, 2.0D)); + + if (var1 < 1) + { + var1 = 1; + } + + int[][] var2 = new int[var1 * this.heightLimit][4]; + int var3 = this.basePos[1] + this.heightLimit - this.leafDistanceLimit; + int var4 = 1; + int var5 = this.basePos[1] + this.height; + int var6 = var3 - this.basePos[1]; + var2[0][0] = this.basePos[0]; + var2[0][1] = var3; + var2[0][2] = this.basePos[2]; + var2[0][3] = var5; + --var3; + + while (var6 >= 0) + { + int var7 = 0; + float var8 = this.layerSize(var6); + + if (var8 < 0.0F) + { + --var3; + --var6; + } + else + { + for (double var9 = 0.5D; var7 < var1; ++var7) + { + double var11 = this.scaleWidth * (double)var8 * ((double)this.rand.nextFloat() + 0.328D); + double var13 = (double)this.rand.nextFloat() * 2.0D * Math.PI; + int var15 = MathHelper.floor_double(var11 * Math.sin(var13) + (double)this.basePos[0] + var9); + int var16 = MathHelper.floor_double(var11 * Math.cos(var13) + (double)this.basePos[2] + var9); + int[] var17 = new int[] {var15, var3, var16}; + int[] var18 = new int[] {var15, var3 + this.leafDistanceLimit, var16}; + + if (this.checkBlockLine(var17, var18) == -1) + { + int[] var19 = new int[] {this.basePos[0], this.basePos[1], this.basePos[2]}; + double var20 = Math.sqrt(Math.pow((double)Math.abs(this.basePos[0] - var17[0]), 2.0D) + Math.pow((double)Math.abs(this.basePos[2] - var17[2]), 2.0D)); + double var22 = var20 * this.branchSlope; + + if ((double)var17[1] - var22 > (double)var5) + { + var19[1] = var5; + } + else + { + var19[1] = (int)((double)var17[1] - var22); + } + + if (this.checkBlockLine(var19, var17) == -1) + { + var2[var4][0] = var15; + var2[var4][1] = var3; + var2[var4][2] = var16; + var2[var4][3] = var19[1]; + ++var4; + } + } + } + + --var3; + --var6; + } + } + + this.leafNodes = new int[var4][4]; + System.arraycopy(var2, 0, this.leafNodes, 0, var4); + } + + void genTreeLayer(int par1, int par2, int par3, float par4, byte par5, int par6) + { + int var7 = (int)((double)par4 + 0.618D); + byte var8 = otherCoordPairs[par5]; + byte var9 = otherCoordPairs[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.pow((double)Math.abs(var12) + 0.5D, 2.0D) + Math.pow((double)Math.abs(var13) + 0.5D, 2.0D); + + if (var15 > (double)(par4 * par4)) + { + ++var13; + } + else + { + var11[var9] = var10[var9] + var13; + int var14 = this.worldObj.getBlockId(var11[0], var11[1], var11[2]); + + if (var14 != 0 && var14 != Blocks.leaves1.get().blockID) + { + ++var13; + } + else + { + this.setBlockAndMetadata(this.worldObj, var11[0], var11[1], var11[2], par6, 7); + ++var13; + } + } + } + } + } + + /** + * Gets the rough size of a layer of the tree. + */ + float layerSize(int par1) + { + if ((double)par1 < (double)((float)this.heightLimit) * 0.3D) + { + return -1.618F; + } + else + { + float var2 = (float)this.heightLimit / 2.0F; + float var3 = (float)this.heightLimit / 2.0F - (float)par1; + float var4; + + if (var3 == 0.0F) + { + var4 = var2; + } + else if (Math.abs(var3) >= var2) + { + var4 = 0.0F; + } + else + { + var4 = (float)Math.sqrt(Math.pow((double)Math.abs(var2), 2.0D) - Math.pow((double)Math.abs(var3), 2.0D)); + } + + var4 *= 0.5F; + return var4; + } + } + + float leafSize(int par1) + { + return par1 >= 0 && par1 < this.leafDistanceLimit ? (par1 != 0 && par1 != this.leafDistanceLimit - 1 ? 3.0F : 2.0F) : -1.0F; + } + + /** + * Generates the leaves surrounding an individual entry in the leafNodes list. + */ + void generateLeafNode(int par1, int par2, int par3) + { + int var4 = par2; + + for (int var5 = par2 + this.leafDistanceLimit; var4 < var5; ++var4) + { + float var6 = this.leafSize(var4 - par2); + this.genTreeLayer(par1, var4, par3, var6, (byte)1, Blocks.leaves1.get().blockID); + } + } + + /** + * Places a line of the specified block ID into the world from the first coordinate triplet to the second. + */ + void placeBlockLine(int[] par1ArrayOfInteger, int[] par2ArrayOfInteger, int par3) + { + int[] var4 = new int[] {0, 0, 0}; + byte var5 = 0; + byte var6; + + for (var6 = 0; var5 < 3; ++var5) + { + var4[var5] = par2ArrayOfInteger[var5] - par1ArrayOfInteger[var5]; + + if (Math.abs(var4[var5]) > Math.abs(var4[var6])) + { + var6 = var5; + } + } + + if (var4[var6] != 0) + { + byte var7 = otherCoordPairs[var6]; + byte var8 = otherCoordPairs[var6 + 3]; + byte var9; + + if (var4[var6] > 0) + { + var9 = 1; + } + else + { + var9 = -1; + } + + double var10 = (double)var4[var7] / (double)var4[var6]; + double var12 = (double)var4[var8] / (double)var4[var6]; + int[] var14 = new int[] {0, 0, 0}; + int var15 = 0; + + for (int var16 = var4[var6] + var9; var15 != var16; var15 += var9) + { + var14[var6] = MathHelper.floor_double((double)(par1ArrayOfInteger[var6] + var15) + 0.5D); + var14[var7] = MathHelper.floor_double((double)par1ArrayOfInteger[var7] + (double)var15 * var10 + 0.5D); + var14[var8] = MathHelper.floor_double((double)par1ArrayOfInteger[var8] + (double)var15 * var12 + 0.5D); + byte var17 = 0; + int var18 = Math.abs(var14[0] - par1ArrayOfInteger[0]); + int var19 = Math.abs(var14[2] - par1ArrayOfInteger[2]); + int var20 = Math.max(var18, var19); + + if (var20 > 0) + { + if (var18 == var20) + { + var17 = 4; + } + else if (var19 == var20) + { + var17 = 8; + } + } + + this.setBlockAndMetadata(this.worldObj, var14[0], var14[1], var14[2], par3, var17); + } + } + } + + /** + * Generates the leaf portion of the tree as specified by the leafNodes list. + */ + void generateLeaves() + { + int var1 = 0; + + for (int var2 = this.leafNodes.length; var1 < var2; ++var1) + { + int var3 = this.leafNodes[var1][0]; + int var4 = this.leafNodes[var1][1]; + int var5 = this.leafNodes[var1][2]; + this.generateLeafNode(var3, var4, var5); + } + } + + /** + * Indicates whether or not a leaf node requires additional wood to be added to preserve integrity. + */ + boolean leafNodeNeedsBase(int par1) + { + return (double)par1 >= (double)this.heightLimit * 0.2D; + } + + /** + * Places the trunk for the big tree that is being generated. Able to generate double-sized trunks by changing a + * field that is always 1 to 2. + */ + void generateTrunk() + { + int var1 = this.basePos[0]; + int var2 = this.basePos[1]; + int var3 = this.basePos[1] + this.height; + int var4 = this.basePos[2]; + int[] var5 = new int[] {var1, var2, var4}; + int[] var6 = new int[] {var1, var3, var4}; + this.placeBlockLine(var5, var6, Block.wood.blockID); + + if (this.trunkSize == 2) + { + ++var5[0]; + ++var6[0]; + this.placeBlockLine(var5, var6, Block.wood.blockID); + ++var5[2]; + ++var6[2]; + this.placeBlockLine(var5, var6, Block.wood.blockID); + var5[0] += -1; + var6[0] += -1; + this.placeBlockLine(var5, var6, Block.wood.blockID); + } + } + + /** + * Generates additional wood blocks to fill out the bases of different leaf nodes that would otherwise degrade. + */ + void generateLeafNodeBases() + { + int var1 = 0; + int var2 = this.leafNodes.length; + + for (int[] var3 = new int[] {this.basePos[0], this.basePos[1], this.basePos[2]}; var1 < var2; ++var1) + { + int[] var4 = this.leafNodes[var1]; + int[] var5 = new int[] {var4[0], var4[1], var4[2]}; + var3[1] = var4[3]; + int var6 = var3[1] - this.basePos[1]; + + if (this.leafNodeNeedsBase(var6)) + { + this.placeBlockLine(var3, var5, Block.wood.blockID); + } + } + } + + /** + * 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. + */ + 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 = otherCoordPairs[var5]; + byte var7 = otherCoordPairs[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((double)par1ArrayOfInteger[var6] + (double)var14 * var9); + var13[var7] = MathHelper.floor_double((double)par1ArrayOfInteger[var7] + (double)var14 * var11); + int var16 = this.worldObj.getBlockId(var13[0], var13[1], var13[2]); + + if (var16 != 0 && var16 != Blocks.leaves1.get().blockID) + { + break; + } + } + + return var14 == var15 ? -1 : Math.abs(var14); + } + } + + /** + * Returns a boolean indicating whether or not the current location for the tree, spanning basePos to to the height + * limit, is valid. + */ + boolean validTreeLocation() + { + int[] var1 = new int[] {this.basePos[0], this.basePos[1], this.basePos[2]}; + int[] var2 = new int[] {this.basePos[0], this.basePos[1] + this.heightLimit - 1, this.basePos[2]}; + int var3 = this.worldObj.getBlockId(this.basePos[0], this.basePos[1] - 1, this.basePos[2]); + + if (var3 != 2 && var3 != 3) + { + return false; + } + else + { + int var4 = this.checkBlockLine(var1, var2); + + if (var4 == -1) + { + return true; + } + else if (var4 < 6) + { + return false; + } + else + { + this.heightLimit = var4; + return true; + } + } + } + + /** + * Rescales the generator settings, only used in WorldGenBigTree + */ + public void setScale(double par1, double par3, double par5) + { + this.heightLimitLimit = (int)(par1 * 12.0D); + + if (par1 > 0.5D) + { + this.leafDistanceLimit = 5; + } + + this.scaleWidth = par3; + this.leafDensity = par5; + } + + public boolean generate(World par1World, Random par2Random, int par3, int par4, int par5) + { + this.worldObj = par1World; + long var6 = par2Random.nextLong(); + this.rand.setSeed(var6); + this.basePos[0] = par3; + this.basePos[1] = par4; + this.basePos[2] = par5; + + if (this.heightLimit == 0) + { + this.heightLimit = 5 + this.rand.nextInt(this.heightLimitLimit); + } + + if (!this.validTreeLocation()) + { + return false; + } + else + { + this.generateLeafNodeList(); + this.generateLeaves(); + this.generateTrunk(); + this.generateLeafNodeBases(); + return true; + } + } +} diff --git a/src/minecraft/biomesoplenty/worldgen/WorldGenMapleBig.java b/src/minecraft/biomesoplenty/worldgen/WorldGenMapleBig.java new file mode 100644 index 000000000..d83ee895a --- /dev/null +++ b/src/minecraft/biomesoplenty/worldgen/WorldGenMapleBig.java @@ -0,0 +1,518 @@ +package biomesoplenty.worldgen; + +import java.util.Random; + +import biomesoplenty.api.Blocks; +import biomesoplenty.configuration.BOPBlocks; + +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraft.util.MathHelper; +import net.minecraft.world.World; +import net.minecraft.world.gen.feature.WorldGenerator; + +public class WorldGenMapleBig extends WorldGenerator +{ + /** + * Contains three sets of two values that provide complimentary indices for a given 'major' index - 1 and 2 for 0, 0 + * and 2 for 1, and 0 and 1 for 2. + */ + static final byte[] otherCoordPairs = new byte[] {(byte)2, (byte)0, (byte)0, (byte)1, (byte)2, (byte)1}; + + /** random seed for GenBigTree */ + Random rand = new Random(); + + /** Reference to the World object. */ + World worldObj; + int[] basePos = new int[] {0, 0, 0}; + int heightLimit = 0; + int height; + double heightAttenuation = 0.618D; + double branchDensity = 1.0D; + double branchSlope = 0.381D; + double scaleWidth = 1.0D; + double leafDensity = 1.0D; + + /** + * Currently always 1, can be set to 2 in the class constructor to generate a double-sized tree trunk for big trees. + */ + int trunkSize = 1; + + /** + * Sets the limit of the random value used to initialize the height limit. + */ + int heightLimitLimit = 12; + + /** + * Sets the distance limit for how far away the generator will populate leaves from the base leaf node. + */ + int leafDistanceLimit = 4; + + /** Contains a list of a points at which to generate groups of leaves. */ + int[][] leafNodes; + + public WorldGenMapleBig(boolean par1) + { + super(par1); + } + + /** + * Generates a list of leaf nodes for the tree, to be populated by generateLeaves. + */ + void generateLeafNodeList() + { + this.height = (int)((double)this.heightLimit * this.heightAttenuation); + + if (this.height >= this.heightLimit) + { + this.height = this.heightLimit - 1; + } + + int var1 = (int)(1.382D + Math.pow(this.leafDensity * (double)this.heightLimit / 13.0D, 2.0D)); + + if (var1 < 1) + { + var1 = 1; + } + + int[][] var2 = new int[var1 * this.heightLimit][4]; + int var3 = this.basePos[1] + this.heightLimit - this.leafDistanceLimit; + int var4 = 1; + int var5 = this.basePos[1] + this.height; + int var6 = var3 - this.basePos[1]; + var2[0][0] = this.basePos[0]; + var2[0][1] = var3; + var2[0][2] = this.basePos[2]; + var2[0][3] = var5; + --var3; + + while (var6 >= 0) + { + int var7 = 0; + float var8 = this.layerSize(var6); + + if (var8 < 0.0F) + { + --var3; + --var6; + } + else + { + for (double var9 = 0.5D; var7 < var1; ++var7) + { + double var11 = this.scaleWidth * (double)var8 * ((double)this.rand.nextFloat() + 0.328D); + double var13 = (double)this.rand.nextFloat() * 2.0D * Math.PI; + int var15 = MathHelper.floor_double(var11 * Math.sin(var13) + (double)this.basePos[0] + var9); + int var16 = MathHelper.floor_double(var11 * Math.cos(var13) + (double)this.basePos[2] + var9); + int[] var17 = new int[] {var15, var3, var16}; + int[] var18 = new int[] {var15, var3 + this.leafDistanceLimit, var16}; + + if (this.checkBlockLine(var17, var18) == -1) + { + int[] var19 = new int[] {this.basePos[0], this.basePos[1], this.basePos[2]}; + double var20 = Math.sqrt(Math.pow((double)Math.abs(this.basePos[0] - var17[0]), 2.0D) + Math.pow((double)Math.abs(this.basePos[2] - var17[2]), 2.0D)); + double var22 = var20 * this.branchSlope; + + if ((double)var17[1] - var22 > (double)var5) + { + var19[1] = var5; + } + else + { + var19[1] = (int)((double)var17[1] - var22); + } + + if (this.checkBlockLine(var19, var17) == -1) + { + var2[var4][0] = var15; + var2[var4][1] = var3; + var2[var4][2] = var16; + var2[var4][3] = var19[1]; + ++var4; + } + } + } + + --var3; + --var6; + } + } + + this.leafNodes = new int[var4][4]; + System.arraycopy(var2, 0, this.leafNodes, 0, var4); + } + + void genTreeLayer(int par1, int par2, int par3, float par4, byte par5, int par6) + { + int var7 = (int)((double)par4 + 0.618D); + byte var8 = otherCoordPairs[par5]; + byte var9 = otherCoordPairs[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.pow((double)Math.abs(var12) + 0.5D, 2.0D) + Math.pow((double)Math.abs(var13) + 0.5D, 2.0D); + + if (var15 > (double)(par4 * par4)) + { + ++var13; + } + else + { + var11[var9] = var10[var9] + var13; + int var14 = this.worldObj.getBlockId(var11[0], var11[1], var11[2]); + + if (var14 != 0 && var14 != Blocks.leaves2.get().blockID) + { + ++var13; + } + else + { + this.setBlockAndMetadata(this.worldObj, var11[0], var11[1], var11[2], par6, 2); + ++var13; + } + } + } + } + } + + /** + * Gets the rough size of a layer of the tree. + */ + float layerSize(int par1) + { + if ((double)par1 < (double)((float)this.heightLimit) * 0.3D) + { + return -1.618F; + } + else + { + float var2 = (float)this.heightLimit / 2.0F; + float var3 = (float)this.heightLimit / 2.0F - (float)par1; + float var4; + + if (var3 == 0.0F) + { + var4 = var2; + } + else if (Math.abs(var3) >= var2) + { + var4 = 0.0F; + } + else + { + var4 = (float)Math.sqrt(Math.pow((double)Math.abs(var2), 2.0D) - Math.pow((double)Math.abs(var3), 2.0D)); + } + + var4 *= 0.5F; + return var4; + } + } + + float leafSize(int par1) + { + return par1 >= 0 && par1 < this.leafDistanceLimit ? (par1 != 0 && par1 != this.leafDistanceLimit - 1 ? 3.0F : 2.0F) : -1.0F; + } + + /** + * Generates the leaves surrounding an individual entry in the leafNodes list. + */ + void generateLeafNode(int par1, int par2, int par3) + { + int var4 = par2; + + for (int var5 = par2 + this.leafDistanceLimit; var4 < var5; ++var4) + { + float var6 = this.leafSize(var4 - par2); + this.genTreeLayer(par1, var4, par3, var6, (byte)1, Blocks.leaves2.get().blockID); + } + } + + /** + * Places a line of the specified block ID into the world from the first coordinate triplet to the second. + */ + void placeBlockLine(int[] par1ArrayOfInteger, int[] par2ArrayOfInteger, int par3) + { + int[] var4 = new int[] {0, 0, 0}; + byte var5 = 0; + byte var6; + + for (var6 = 0; var5 < 3; ++var5) + { + var4[var5] = par2ArrayOfInteger[var5] - par1ArrayOfInteger[var5]; + + if (Math.abs(var4[var5]) > Math.abs(var4[var6])) + { + var6 = var5; + } + } + + if (var4[var6] != 0) + { + byte var7 = otherCoordPairs[var6]; + byte var8 = otherCoordPairs[var6 + 3]; + byte var9; + + if (var4[var6] > 0) + { + var9 = 1; + } + else + { + var9 = -1; + } + + double var10 = (double)var4[var7] / (double)var4[var6]; + double var12 = (double)var4[var8] / (double)var4[var6]; + int[] var14 = new int[] {0, 0, 0}; + int var15 = 0; + + for (int var16 = var4[var6] + var9; var15 != var16; var15 += var9) + { + var14[var6] = MathHelper.floor_double((double)(par1ArrayOfInteger[var6] + var15) + 0.5D); + var14[var7] = MathHelper.floor_double((double)par1ArrayOfInteger[var7] + (double)var15 * var10 + 0.5D); + var14[var8] = MathHelper.floor_double((double)par1ArrayOfInteger[var8] + (double)var15 * var12 + 0.5D); + byte var17 = 0; + int var18 = Math.abs(var14[0] - par1ArrayOfInteger[0]); + int var19 = Math.abs(var14[2] - par1ArrayOfInteger[2]); + int var20 = Math.max(var18, var19); + + if (var20 > 0) + { + if (var18 == var20) + { + var17 = 4; + } + else if (var19 == var20) + { + var17 = 8; + } + } + + this.setBlockAndMetadata(this.worldObj, var14[0], var14[1], var14[2], par3, var17); + } + } + } + + /** + * Generates the leaf portion of the tree as specified by the leafNodes list. + */ + void generateLeaves() + { + int var1 = 0; + + for (int var2 = this.leafNodes.length; var1 < var2; ++var1) + { + int var3 = this.leafNodes[var1][0]; + int var4 = this.leafNodes[var1][1]; + int var5 = this.leafNodes[var1][2]; + this.generateLeafNode(var3, var4, var5); + } + } + + /** + * Indicates whether or not a leaf node requires additional wood to be added to preserve integrity. + */ + boolean leafNodeNeedsBase(int par1) + { + return (double)par1 >= (double)this.heightLimit * 0.2D; + } + + /** + * Places the trunk for the big tree that is being generated. Able to generate double-sized trunks by changing a + * field that is always 1 to 2. + */ + void generateTrunk() + { + int var1 = this.basePos[0]; + int var2 = this.basePos[1]; + int var3 = this.basePos[1] + this.height; + int var4 = this.basePos[2]; + int[] var5 = new int[] {var1, var2, var4}; + int[] var6 = new int[] {var1, var3, var4}; + this.placeBlockLine(var5, var6, Block.wood.blockID); + + if (this.trunkSize == 2) + { + ++var5[0]; + ++var6[0]; + this.placeBlockLine(var5, var6, Block.wood.blockID); + ++var5[2]; + ++var6[2]; + this.placeBlockLine(var5, var6, Block.wood.blockID); + var5[0] += -1; + var6[0] += -1; + this.placeBlockLine(var5, var6, Block.wood.blockID); + } + } + + /** + * Generates additional wood blocks to fill out the bases of different leaf nodes that would otherwise degrade. + */ + void generateLeafNodeBases() + { + int var1 = 0; + int var2 = this.leafNodes.length; + + for (int[] var3 = new int[] {this.basePos[0], this.basePos[1], this.basePos[2]}; var1 < var2; ++var1) + { + int[] var4 = this.leafNodes[var1]; + int[] var5 = new int[] {var4[0], var4[1], var4[2]}; + var3[1] = var4[3]; + int var6 = var3[1] - this.basePos[1]; + + if (this.leafNodeNeedsBase(var6)) + { + this.placeBlockLine(var3, var5, Block.wood.blockID); + } + } + } + + /** + * 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. + */ + 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 = otherCoordPairs[var5]; + byte var7 = otherCoordPairs[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((double)par1ArrayOfInteger[var6] + (double)var14 * var9); + var13[var7] = MathHelper.floor_double((double)par1ArrayOfInteger[var7] + (double)var14 * var11); + int var16 = this.worldObj.getBlockId(var13[0], var13[1], var13[2]); + + if (var16 != 0 && var16 != Blocks.leaves2.get().blockID) + { + break; + } + } + + return var14 == var15 ? -1 : Math.abs(var14); + } + } + + /** + * Returns a boolean indicating whether or not the current location for the tree, spanning basePos to to the height + * limit, is valid. + */ + boolean validTreeLocation() + { + int[] var1 = new int[] {this.basePos[0], this.basePos[1], this.basePos[2]}; + int[] var2 = new int[] {this.basePos[0], this.basePos[1] + this.heightLimit - 1, this.basePos[2]}; + int var3 = this.worldObj.getBlockId(this.basePos[0], this.basePos[1] - 1, this.basePos[2]); + + if (var3 != 2 && var3 != 3) + { + return false; + } + else + { + int var4 = this.checkBlockLine(var1, var2); + + if (var4 == -1) + { + return true; + } + else if (var4 < 6) + { + return false; + } + else + { + this.heightLimit = var4; + return true; + } + } + } + + /** + * Rescales the generator settings, only used in WorldGenBigTree + */ + public void setScale(double par1, double par3, double par5) + { + this.heightLimitLimit = (int)(par1 * 12.0D); + + if (par1 > 0.5D) + { + this.leafDistanceLimit = 5; + } + + this.scaleWidth = par3; + this.leafDensity = par5; + } + + public boolean generate(World par1World, Random par2Random, int par3, int par4, int par5) + { + this.worldObj = par1World; + long var6 = par2Random.nextLong(); + this.rand.setSeed(var6); + this.basePos[0] = par3; + this.basePos[1] = par4; + this.basePos[2] = par5; + + if (this.heightLimit == 0) + { + this.heightLimit = 5 + this.rand.nextInt(this.heightLimitLimit); + } + + if (!this.validTreeLocation()) + { + return false; + } + else + { + this.generateLeafNodeList(); + this.generateLeaves(); + this.generateTrunk(); + this.generateLeafNodeBases(); + return true; + } + } +} diff --git a/src/minecraft/biomesoplenty/worldgen/WorldGenPromisedWillowTree.java b/src/minecraft/biomesoplenty/worldgen/WorldGenPromisedWillowTree.java index d1981508b..9e02f7ac8 100644 --- a/src/minecraft/biomesoplenty/worldgen/WorldGenPromisedWillowTree.java +++ b/src/minecraft/biomesoplenty/worldgen/WorldGenPromisedWillowTree.java @@ -80,9 +80,9 @@ public class WorldGenPromisedWillowTree extends WorldGenerator { var8 = par1World.getBlockId(par3, par4 - 1, par5); - if ((var8 == Blocks.holyGrass.get().blockID || var8 == Blocks.holyStone.get().blockID) && par4 < 128 - var6 - 1) + if ((var8 == Blocks.holyGrass.get().blockID || var8 == Blocks.holyDirt.get().blockID) && par4 < 128 - var6 - 1) { - this.setBlock(par1World, par3, par4 - 1, par5, Blocks.holyStone.get().blockID); + this.setBlock(par1World, par3, par4 - 1, par5, Blocks.holyDirt.get().blockID); int var13; int var16; diff --git a/src/minecraft/biomesoplenty/worldgen/WorldGenReedBOP.java b/src/minecraft/biomesoplenty/worldgen/WorldGenReedBOP.java index a5c88d8a4..a45fc43f7 100644 --- a/src/minecraft/biomesoplenty/worldgen/WorldGenReedBOP.java +++ b/src/minecraft/biomesoplenty/worldgen/WorldGenReedBOP.java @@ -21,7 +21,7 @@ public class WorldGenReedBOP extends WorldGenerator if (par1World.isAirBlock(i1, par4, k1)) { - int l1 = 2 + par2Random.nextInt(par2Random.nextInt(2) + 1); + int l1 = 1 + par2Random.nextInt(par2Random.nextInt(3) + 1); if (Blocks.plants.get().canBlockStay(par1World, i1, j1, k1)) {