Minecraft Forums

package de.medved356.EatMore.Biome;

import de.medved356.EatMore.Tree.WorldGenCherryTree;
import net.minecraft.init.Blocks;
import net.minecraft.world.biome.BiomeGenBase;

public class BiomeGenFruit extends BiomeGenBase{


private Class<WorldGenCherryTree> worldGeneratorCherryTrees;

public BiomeGenFruit(int id){
super (id);
this.worldGeneratorCherryTrees = WorldGenCherryTree.class;
this.theBiomeDecorator.treesPerChunk = 5;
this.theBiomeDecorator.grassPerChunk = 2;
this.topBlock = Blocks.grass;


}

}

package de.medved356.EatMore.Tree;

import java.util.Random;

import de.medved356.EatMore.EatMore;
import de.medved356.EatMore.Blocks.CherrySapling;
import net.minecraft.block.Block;
import net.minecraft.block.BlockSapling;
import net.minecraft.block.material.Material;
import net.minecraft.init.Blocks;
import net.minecraft.util.Direction;
import net.minecraft.world.World;
import net.minecraft.world.gen.feature.WorldGenAbstractTree;
import net.minecraft.world.gen.feature.WorldGenTrees;
import net.minecraftforge.common.util.ForgeDirection;

public class WorldGenCherryTree extends WorldGenAbstractTree
{
private final int minTreeHeight;
private final int randomTreeHeight;


private final boolean vinesGrow;
private final Block wood;
private final Block leaves;

private final int metaWood;
private final int metaLeaves;
private static final String __OBFID = "CL_00000438";

public WorldGenCherryTree(Block wood, Block leaves, int metaWood , int metaLeaves)
{
this(wood , leaves,metaWood,metaLeaves ,false,4, 3,false );
}

public WorldGenCherryTree(Block wood, Block leaves, int metawood, int metaLeaves, boolean doBlockNotify,int minTreeHeight,int randomTreeHeight,boolean vinesGrow )
{
super(doBlockNotify);
this.wood = wood;
this.leaves = leaves;

this.minTreeHeight = minTreeHeight;
this.randomTreeHeight = randomTreeHeight;

this.metaWood = metawood;
this.metaLeaves = metaLeaves;
this.vinesGrow = vinesGrow;
}

public boolean generate(World par1World, Random par2Random, int par3, int par4, int par5)
{
int l = par2Random.nextInt(3) + this.minTreeHeight;
boolean flag = true;

if (par4 >= 1 && par4 + l + 1 <= 256)
{
byte b0;
int k1;
Block block;

for (int i1 = par4; i1 <= par4 + 1 + l; ++i1)
{
b0 = 1;

if (i1 == par4)
{
b0 = 0;
}

if (i1 >= par4 + 1 + l - 2)
{
b0 = 2;
}

for (int j1 = par3 - b0; j1 <= par3 + b0 && flag; ++j1)
{
for (k1 = par5 - b0; k1 <= par5 + b0 && flag; ++k1)
{
if (i1 >= 0 && i1 < 256)
{
block = par1World.getBlock(j1, i1, k1);

if (!this.isReplaceable(par1World, j1, i1, k1))
{
flag = false;
}
}
else
{
flag = false;
}
}
}
}

if (!flag)
{
return false;
}
else
{
Block block2 = par1World.getBlock(par3, par4 - 1, par5);

boolean isSoil = block2.canSustainPlant(par1World, par3, par4 - 1, par5, ForgeDirection.UP, (CherrySapling)EatMore.CherrySapling);
if (isSoil && par4 < 256 - l - 1)
{
block2.onPlantGrow(par1World, par3, par4 - 1, par5, par3, par4, par5);
b0 = 3;
byte b1 = 0;
int l1;
int i2;
int j2;
int i3;

for (k1 = par4 - b0 + l; k1 <= par4 + l; ++k1)
{
i3 = k1 - (par4 + l);
l1 = b1 + 1 - i3 / 2;

for (i2 = par3 - l1; i2 <= par3 + l1; ++i2)
{
j2 = i2 - par3;

for (int k2 = par5 - l1; k2 <= par5 + l1; ++k2)
{
int l2 = k2 - par5;

if (Math.abs(j2) != l1 || Math.abs(l2) != l1 || par2Random.nextInt(2) != 0 && i3 != 0)
{
Block block1 = par1World.getBlock(i2, k1, k2);

if (block1.isAir(par1World, i2, k1, k2) || block1.isLeaves(par1World, i2, k1, k2))
{
this.setBlockAndNotifyAdequately(par1World, i2, k1, k2,EatMore.blockLeaves, this.metaLeaves);
}
}
}
}
}

for (k1 = 0; k1 < l; ++k1)
{
block = par1World.getBlock(par3, par4 + k1, par5);

if (block.isAir(par1World, par3, par4 + k1, par5) || block.isLeaves(par1World, par3, par4 + k1, par5))
{
this.setBlockAndNotifyAdequately(par1World, par3, par4 + k1, par5, EatMore.CherryLog, this.metaWood);

if (this.vinesGrow && k1 > 0)
{
if (par2Random.nextInt(3) > 0 && par1World.isAirBlock(par3 - 1, par4 + k1, par5))
{
this.setBlockAndNotifyAdequately(par1World, par3 - 1, par4 + k1, par5, Blocks.vine, 8);
}

if (par2Random.nextInt(3) > 0 && par1World.isAirBlock(par3 + 1, par4 + k1, par5))
{
this.setBlockAndNotifyAdequately(par1World, par3 + 1, par4 + k1, par5, Blocks.vine, 2);
}

if (par2Random.nextInt(3) > 0 && par1World.isAirBlock(par3, par4 + k1, par5 - 1))
{
this.setBlockAndNotifyAdequately(par1World, par3, par4 + k1, par5 - 1, Blocks.vine, 1);
}

if (par2Random.nextInt(3) > 0 && par1World.isAirBlock(par3, par4 + k1, par5 + 1))
{
this.setBlockAndNotifyAdequately(par1World, par3, par4 + k1, par5 + 1, Blocks.vine, 4);
}
}
}
}

if (this.vinesGrow)
{
for (k1 = par4 - 3 + l; k1 <= par4 + l; ++k1)
{
i3 = k1 - (par4 + l);
l1 = 2 - i3 / 2;

for (i2 = par3 - l1; i2 <= par3 + l1; ++i2)
{
for (j2 = par5 - l1; j2 <= par5 + l1; ++j2)
{
if (par1World.getBlock(i2, k1, j2).isLeaves(par1World, i2, k1, j2))
{
if (par2Random.nextInt(4) == 0 && par1World.getBlock(i2 - 1, k1, j2).isAir(par1World, i2 - 1, k1, j2))
{
this.growVines(par1World, i2 - 1, k1, j2, 8);
}

if (par2Random.nextInt(4) == 0 && par1World.getBlock(i2 + 1, k1, j2).isAir(par1World, i2 + 1, k1, j2))
{
this.growVines(par1World, i2 + 1, k1, j2, 2);
}

if (par2Random.nextInt(4) == 0 && par1World.getBlock(i2, k1, j2 - 1).isAir(par1World, i2, k1, j2 - 1))
{
this.growVines(par1World, i2, k1, j2 - 1, 1);
}

if (par2Random.nextInt(4) == 0 && par1World.getBlock(i2, k1, j2 + 1).isAir(par1World, i2, k1, j2 + 1))
{
this.growVines(par1World, i2, k1, j2 + 1, 4);
}
}
}
}
}

if (par2Random.nextInt(5) == 0 && l > 5)
{
for (k1 = 0; k1 < 2; ++k1)
{
for (i3 = 0; i3 < 4; ++i3)
{
if (par2Random.nextInt(4 - k1) == 0)
{
l1 = par2Random.nextInt(3);
this.setBlockAndNotifyAdequately(par1World, par3 + Direction.offsetX[Direction.rotateOpposite[i3]], par4 + l - 5 + k1, par5 + Direction.offsetZ[Direction.rotateOpposite[i3]], Blocks.cocoa, l1 << 2 | i3);
}
}
}
}
}

return true;
}
else
{
return false;
}
}
}
else
{
return false;
}
}

/**
* Grows vines downward from the given block for a given length. Args: World, x, starty, z, vine-length
*/
private void growVines(World par1World, int par2, int par3, int par4, int par5)
{
this.setBlockAndNotifyAdequately(par1World, par2, par3, par4, Blocks.vine, par5);
int i1 = 4;

while (true)
{
--par3;

if (par1World.getBlock(par2, par3, par4).isAir(par1World, par2, par3, par4) || i1 <= 0)
{
return;
}

this.setBlockAndNotifyAdequately(par1World, par2, par3, par4, Blocks.vine, par5);
--i1;
}
}

package de.medved356.EatMore.Tree;

import java.util.Random;

import net.minecraft.block.Block;
import net.minecraft.world.World;
import net.minecraft.world.chunk.IChunkProvider;
import net.minecraft.world.gen.feature.WorldGenAbstractTree;
import net.minecraft.world.gen.feature.WorldGenMinable;
import net.minecraft.world.gen.feature.WorldGenTrees;
import cpw.mods.fml.common.IWorldGenerator;
import de.medved356.EatMore.EatMore;
import net.minecraft.*;

public class WorldGenerationofCherry implements IWorldGenerator {

@Override
public void generate(Random random, int chunkX, int chunkZ, World world,
IChunkProvider chunkGenerator, IChunkProvider chunkProvider) {
switch(world.provider.dimensionId){
case 0 :
//Generate our surface world
generateOverWorld(world, random, chunkX*16, chunkZ*16);
case 1 :
//Generate our surface world
generateEnd(world, random, chunkX*16, chunkZ*16);
}

}

private void generateSurface(World world, Random random, int x, int z) {
}

private void generateOverWorld(World world, Random random, int x, int z) {
this.addTreeSpawn(world, random, x, z, EatMore.CherryLog, EatMore.blockLeaves, 0, 0, false, 5, 10, false, 20);
}

private void generateEnd(World world, Random random, int x, int z) {

}

private void addOreSpawn(Block block, World world, Random random, int blockXPos, int blockZPos, int maxX, int maxZ, int maxVeinSize, int chanceToSpawn, int minY, int maxY) {
for(int i = 0; i < chanceToSpawn; i++) {
int posX = blockXPos + random.nextInt(maxX);
int posY = minY + random.nextInt(maxY-minY);
int posZ = blockZPos + random.nextInt(maxZ);

(new WorldGenMinable(block, maxVeinSize)).generate(world, random, posX, posY, posZ);
}
}

private void addWorldOreSpawn(Block block, World world, Random random, int blockXPos, int blockZPos, int maxX, int maxZ, int maxVeinSize, int chanceToSpawn, int minY, int maxY) {
for(int i = 0; i < chanceToSpawn; i++) {
int posX = blockXPos + random.nextInt(maxX);
int posY = minY + random.nextInt(maxY-minY);
int posZ = blockZPos + random.nextInt(maxZ);

(new WorldGenMinable(block, maxVeinSize)).generate(world, random, posX, posY, posZ);

}
}

private void addTreeSpawn(World world, Random random, int blockXPos, int blockZPos, Block wood, Block leaves, int metaWood, int metaLeaves, boolean doBlockNotify, int minTreeHeight, int randomTreeHeight, boolean vinesGrow, int chanceToSpawn) {
for(int i = 10; i < chanceToSpawn; i++) {

for (int j = 0; j < i; ++j)
{
int k = blockXPos + random.nextInt(16) + 8;

int l = blockZPos + random.nextInt(16) + 8;

WorldGenAbstractTree worldgenabstracttree = new WorldGenCherryTree(leaves, leaves, metaWood, metaLeaves, doBlockNotify, minTreeHeight, randomTreeHeight, vinesGrow);

worldgenabstracttree.setScale(1.0D, 1.0D, 1.0D);

if (worldgenabstracttree.generate(world, random, k, i, l))
{
worldgenabstracttree.func_150524_b(world, random, k, i, l);
}random, posX, randPosY, posZ);

}
}
}
}