etc
/
BiomesOPlenty
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Improvements to various biomes, removed koru and desert sprouts, removed lava lakes from the redwood forest and wasteland, added advancements

This commit is contained in:
Forstride 2019-01-05 00:55:05 -05:00
parent 130ba3e77b
commit f146efb1ee
43 changed files with 1170 additions and 734 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/main/java/biomesoplenty/api/enums/BOPFoliage.java
View File

@ -12,7 +12,7 @@ import net.minecraft.util.IStringSerializable;
public enum BOPFoliage implements IStringSerializable, IPagedVariants
{
SHORTGRASS, BUSH, BERRYBUSH, KORU, DEVILWEED, DUNEGRASS, DESERTSPROUTS, DESERTGRASS, DEADGRASS, SPECTRALFERN, BARLEY;
SHORTGRASS, BUSH, BERRYBUSH, BARLEY, DUNEGRASS, DESERTGRASS, DEADGRASS, DEVILWEED, SPECTRALFERN;
@Override
public String getName() {

32
src/main/java/biomesoplenty/common/biome/overworld/BiomeGenBayou.java
View File

@ -10,9 +10,7 @@ package biomesoplenty.common.biome.overworld;
import java.util.Random;
import biomesoplenty.api.biome.BOPBiomes;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.block.BlockQueries;
import biomesoplenty.api.block.IBlockPosQuery;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPFoliage;
@ -22,17 +20,20 @@ import biomesoplenty.api.enums.BOPWoods;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPCoral;
import biomesoplenty.common.block.BlockBOPDoublePlant;
import biomesoplenty.common.block.BlockBOPLeaves;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import biomesoplenty.common.util.block.BlockQuery;
import biomesoplenty.common.world.generator.GeneratorColumns;
import biomesoplenty.common.world.generator.GeneratorDoubleFlora;
import biomesoplenty.common.world.generator.GeneratorFlora;
import biomesoplenty.common.world.generator.GeneratorGrass;
import biomesoplenty.common.world.generator.GeneratorSplatter;
import biomesoplenty.common.world.generator.GeneratorWaterside;
import biomesoplenty.common.world.generator.GeneratorWeighted;
import biomesoplenty.common.world.generator.tree.GeneratorBasicTree;
import biomesoplenty.common.world.generator.tree.GeneratorBayouTree;
import biomesoplenty.common.world.generator.tree.GeneratorBigTree;
import net.minecraft.block.BlockDoublePlant;
import net.minecraft.block.BlockOldLeaf;
import net.minecraft.block.BlockTallGrass;
import net.minecraft.entity.monster.EntitySlime;
import net.minecraft.init.Blocks;
@ -45,7 +46,7 @@ public class BiomeGenBayou extends BOPOverworldBiome
public BiomeGenBayou()
{
super("bayou", new PropsBuilder("Bayou").withGuiColour(0x7DAD51).withTemperature(0.95F).withRainfall(0.9F).withWaterColor(0xFFD932));
super("bayou", new PropsBuilder("Bayou").withGuiColour(0x7DAD51).withTemperature(0.95F).withRainfall(0.9F).withWaterColor(0xB7FF32));
// terrain
this.terrainSettings.avgHeight(62).heightVariation(6, 3).octaves(1, 1, 1, 1, 0, 0).sidewaysNoise(0.0F);
@ -69,10 +70,11 @@ public class BiomeGenBayou extends BOPOverworldBiome
this.addGenerator("mud_splatter", GeneratorStage.SAND, (new GeneratorSplatter.Builder()).amountPerChunk(0.2F).replace(emptyGrassOrDirt).with(BOPBlocks.mud.getDefaultState()).create());
// trees & logs
GeneratorWeighted treeGenerator = new GeneratorWeighted(8);
GeneratorWeighted treeGenerator = new GeneratorWeighted(8.0F);
this.addGenerator("trees", GeneratorStage.TREE, treeGenerator);
treeGenerator.add("willow", 3, (new GeneratorBayouTree.Builder()).log(BOPWoods.WILLOW).leaves(BOPTrees.WILLOW).minHeight(6).maxHeight(12).minLeavesRadius(1).leavesGradient(2).create());
treeGenerator.add("willow_large", 1, (new GeneratorBayouTree.Builder()).log(BOPWoods.WILLOW).leaves(BOPTrees.WILLOW).minHeight(10).maxHeight(18).minLeavesRadius(2).leavesGradient(3).create());
treeGenerator.add("willow", 4, (new GeneratorBasicTree.Builder()).log(BOPWoods.WILLOW).leaves(BlockBOPLeaves.paging.getVariantState(BOPTrees.WILLOW).withProperty(BlockOldLeaf.CHECK_DECAY, Boolean.valueOf(false))).minHeight(6).maxHeight(12).maxLeavesRadius(1).vine(BOPBlocks.willow_vine.getDefaultState()).leavesOffset(0).create());
treeGenerator.add("willow_decaying", 2, (new GeneratorBigTree.Builder()).log(BOPWoods.WILLOW).leaves(BlockBOPLeaves.paging.getVariantState(BOPTrees.WILLOW).withProperty(BlockOldLeaf.CHECK_DECAY, Boolean.valueOf(false))).foliageHeight(1).maxHeight(16).create());
treeGenerator.add("cypress", 3, (new GeneratorBayouTree.Builder()).log(BOPWoods.WILLOW).leaves(BlockBOPLeaves.paging.getVariantState(BOPTrees.WILLOW).withProperty(BlockOldLeaf.CHECK_DECAY, Boolean.valueOf(false))).minHeight(12).maxHeight(20).maxLeavesRadius(1).vine(BOPBlocks.willow_vine.getDefaultState()).leavesOffset(0).create());
// grasses
GeneratorWeighted grassGenerator = new GeneratorWeighted(2.0F);
@ -80,17 +82,17 @@ public class BiomeGenBayou extends BOPOverworldBiome
grassGenerator.add("shortgrass", 1, (new GeneratorGrass.Builder()).with(BOPFoliage.SHORTGRASS).create());
grassGenerator.add("tallgrass", 2, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.GRASS).create());
grassGenerator.add("doublegrass", 1, (new GeneratorDoubleFlora.Builder()).with(BlockDoublePlant.EnumPlantType.GRASS).create());
grassGenerator.add("fern", 2, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.FERN).create());
// other plants
this.addGenerator("koru", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.3F).with(BOPFoliage.KORU).create());
this.addGenerator("cattail", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(6.0F).with(BOPPlants.CATTAIL).create());
this.addGenerator("double_cattail", GeneratorStage.FLOWERS, (new GeneratorDoubleFlora.Builder()).amountPerChunk(8.0F).with(BlockBOPDoublePlant.DoublePlantType.TALL_CATTAIL).create());
this.addGenerator("sugar_cane", GeneratorStage.FLOWERS,(new GeneratorColumns.Builder()).amountPerChunk(3.0F).generationAttempts(24).placeOn(BlockQueries.litFertileWaterside).with(Blocks.REEDS.getDefaultState()).minHeight(1).maxHeight(3).create());
this.addGenerator("cattail", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(1.0F).with(BOPPlants.CATTAIL).create());
this.addGenerator("double_cattail", GeneratorStage.FLOWERS, (new GeneratorDoubleFlora.Builder()).amountPerChunk(0.5F).with(BlockBOPDoublePlant.DoublePlantType.TALL_CATTAIL).create());
this.addGenerator("double_fern", GeneratorStage.FLOWERS, (new GeneratorDoubleFlora.Builder()).amountPerChunk(0.75F).with(BlockDoublePlant.EnumPlantType.FERN).create());
// water plants
this.addGenerator("lily", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(2.5F).with(Blocks.WATERLILY.getDefaultState()).create());
this.addGenerator("lily", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(2.0F).with(Blocks.WATERLILY.getDefaultState()).create());
this.addGenerator("algae", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(4.0F).replace(Blocks.WATER).with(BOPBlocks.coral.getDefaultState().withProperty(BlockBOPCoral.VARIANT, BlockBOPCoral.CoralType.ALGAE)).scatterYMethod(ScatterYMethod.AT_GROUND).create());
this.addGenerator("water_reeds", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.8F).with(BOPPlants.REED).generationAttempts(32).create());
this.addGenerator("water_reeds", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.75F).with(BOPPlants.REED).generationAttempts(32).create());
this.addGenerator("watergrass", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(2.0F).with(BOPPlants.WATERGRASS).generationAttempts(32).create());
// shrooms
@ -114,12 +116,12 @@ public class BiomeGenBayou extends BOPOverworldBiome
@Override
public int getGrassColorAtPos(BlockPos pos)
{
return getModdedBiomeGrassColor(0x7DAD51);
return getModdedBiomeGrassColor(0x6FAA50);
}
@Override
public int getFoliageColorAtPos(BlockPos pos)
{
return getModdedBiomeFoliageColor(0x9DDD66);
return getModdedBiomeFoliageColor(0x8BDB67);
}
}

1
src/main/java/biomesoplenty/common/biome/overworld/BiomeGenBog.java
View File

@ -94,7 +94,6 @@ public class BiomeGenBog extends BOPOverworldBiome
grassGenerator.add("tallgrass", 1, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.GRASS).create());
// other plants
this.addGenerator("koru", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).with(BOPFoliage.KORU).create());
this.addGenerator("bushes", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(3.0F).with(BOPFoliage.BUSH).create());
this.addGenerator("leaf_piles", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.2F).placeOn(BlockQueries.fertile).with(BlockBOPFlatPlant.PlantType.LEAFPILE).create());
this.addGenerator("dead_leaf_piles", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).placeOn(BlockQueries.fertile).with(BlockBOPFlatPlant.PlantType.DEADLEAFPILE).create());

3
src/main/java/biomesoplenty/common/biome/overworld/BiomeGenBrushland.java
View File

@ -56,7 +56,7 @@ public class BiomeGenBrushland extends BOPOverworldBiome
this.addGenerator("sand", GeneratorStage.SAND_PASS2, (new GeneratorWaterside.Builder()).amountPerChunk(4).maxRadius(7).with(Blocks.SAND.getDefaultState()).create());
// trees & logs
GeneratorWeighted treeGenerator = new GeneratorWeighted(2.5F);
GeneratorWeighted treeGenerator = new GeneratorWeighted(3.5F);
this.addGenerator("trees", GeneratorStage.TREE, treeGenerator);
treeGenerator.add("dead_tree", 1, (new GeneratorBigTree.Builder()).minHeight(7).maxHeight(12).foliageHeight(0).foliageDensity(0.5D).log(BOPWoods.DEAD).leaves(Blocks.AIR.getDefaultState()).create());
treeGenerator.add("brush_twiglet", 18, (new GeneratorTwigletTree.Builder()).minHeight(1).maxHeight(4).log(BlockPlanks.EnumType.ACACIA).leaves(BOPTrees.DEAD).create());
@ -72,7 +72,6 @@ public class BiomeGenBrushland extends BOPOverworldBiome
this.addGenerator("cacti", GeneratorStage.FLOWERS,(new GeneratorColumns.Builder()).amountPerChunk(0.2F).generationAttempts(24).placeOn(this.topBlock).with(Blocks.CACTUS.getDefaultState()).minHeight(1).maxHeight(2).create());
this.addGenerator("tiny_cacti", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.4F).with(BOPPlants.TINYCACTUS).create());
this.addGenerator("desertgrass", GeneratorStage.GRASS, (new GeneratorGrass.Builder()).amountPerChunk(2.0F).with(BOPFoliage.DESERTGRASS).generationAttempts(8).create());
this.addGenerator("desert_sprouts", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.25F).with(BOPFoliage.DESERTSPROUTS).generationAttempts(8).create());
this.addGenerator("thorns", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(1.0F).with(BOPPlants.THORN).create());
this.addGenerator("dead_bushes", GeneratorStage.FLOWERS, (new GeneratorFlora.Builder()).amountPerChunk(1.75F).with(Blocks.DEADBUSH.getDefaultState()).create());
}

2
src/main/java/biomesoplenty/common/biome/overworld/BiomeGenCherryBlossomGrove.java
View File

@ -65,7 +65,7 @@ public class BiomeGenCherryBlossomGrove extends BOPOverworldBiome
treeGenerator.add("pink_cherry", 2, (new GeneratorBasicTree.Builder()).log(BOPWoods.CHERRY).leaves(BOPTrees.PINK_CHERRY).create());
treeGenerator.add("white_cherry", 1, (new GeneratorBasicTree.Builder()).log(BOPWoods.CHERRY).leaves(BOPTrees.WHITE_CHERRY).create());
treeGenerator.add("large_pink_cherry", 4, (new GeneratorBigTree.Builder()).log(BOPWoods.CHERRY).leaves(BOPTrees.PINK_CHERRY).create());
treeGenerator.add("large_white_cherry", 3, (new GeneratorBigTree.Builder()).log(BOPWoods.CHERRY).leaves(BOPTrees.WHITE_CHERRY).create());
treeGenerator.add("large_white_cherry", 2, (new GeneratorBigTree.Builder()).log(BOPWoods.CHERRY).leaves(BOPTrees.WHITE_CHERRY).create());
// other plants
this.addGenerator("flax", GeneratorStage.FLOWERS,(new GeneratorDoubleFlora.Builder()).amountPerChunk(0.2F).with(BlockBOPDoublePlant.DoublePlantType.FLAX).generationAttempts(6).create());

3
src/main/java/biomesoplenty/common/biome/overworld/BiomeGenDeadSwamp.java
View File

@ -66,9 +66,6 @@ public class BiomeGenDeadSwamp extends BOPOverworldBiome
this.addGenerator("trees", GeneratorStage.TREE, treeGenerator);
treeGenerator.add("dying_tree", 3, (new GeneratorBigTree.Builder()).minHeight(5).maxHeight(12).foliageHeight(1).log(BOPWoods.DEAD).leaves(BOPTrees.DEAD).create());
treeGenerator.add("dead_tree", 1, (new GeneratorBigTree.Builder()).minHeight(5).maxHeight(12).foliageHeight(0).foliageDensity(0.5D).log(BOPWoods.DEAD).leaves(Blocks.AIR.getDefaultState()).create());
// other plants
this.addGenerator("koru", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).with(BOPFoliage.KORU).create());
// water plants
this.addGenerator("water_reeds", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BOPPlants.REED).generationAttempts(32).create());

1
src/main/java/biomesoplenty/common/biome/overworld/BiomeGenFen.java
View File

@ -82,7 +82,6 @@ public class BiomeGenFen extends BOPOverworldBiome
// other plants
this.addGenerator("cattail", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.25F).with(BOPPlants.CATTAIL).create());
this.addGenerator("double_cattail", GeneratorStage.FLOWERS,(new GeneratorDoubleFlora.Builder()).amountPerChunk(0.25F).with(BlockBOPDoublePlant.DoublePlantType.TALL_CATTAIL).create());
this.addGenerator("koru", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).with(BOPFoliage.KORU).create());
this.addGenerator("dead_leaf_piles", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(1.5F).placeOn(BlockQueries.fertile).with(BlockBOPFlatPlant.PlantType.DEADLEAFPILE).generationAttempts(64).create());
// water plants

3
src/main/java/biomesoplenty/common/biome/overworld/BiomeGenGrove.java
View File

@ -11,6 +11,7 @@ package biomesoplenty.common.biome.overworld;
import biomesoplenty.api.block.BlockQueries;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPFoliage;
import biomesoplenty.api.enums.BOPTrees;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPFlatPlant;
import biomesoplenty.common.world.generator.GeneratorDoubleFlora;
@ -49,7 +50,7 @@ public class BiomeGenGrove extends BOPOverworldBiome
// trees
GeneratorWeighted treeGenerator = new GeneratorWeighted(3.5F);
this.addGenerator("trees", GeneratorStage.TREE, treeGenerator);
treeGenerator.add("oak_tree", 1, (new GeneratorBigTree.Builder()).minHeight(11).maxHeight(15).foliageHeight(2).create());
treeGenerator.add("oak_tree", 1, (new GeneratorBigTree.Builder()).minHeight(11).maxHeight(15).altLeaves(BOPTrees.FLOWERING).foliageHeight(2).create());
treeGenerator.add("dark_poplar", 5, (new GeneratorProfileTree.Builder()).minHeight(9).maxHeight(15).log(BlockPlanks.EnumType.DARK_OAK).leaves(BlockPlanks.EnumType.DARK_OAK).profile(GeneratorProfileTree.TreeProfile.POPLAR).create());
treeGenerator.add("poplar", 5, (new GeneratorProfileTree.Builder()).minHeight(9).maxHeight(18).log(BlockPlanks.EnumType.BIRCH).leaves(BlockPlanks.EnumType.BIRCH).profile(GeneratorProfileTree.TreeProfile.POPLAR).create());
treeGenerator.add("bush", 8, (new GeneratorBush.Builder()).maxHeight(2).create());

1
src/main/java/biomesoplenty/common/biome/overworld/BiomeGenHighlandMoor.java
View File

@ -77,7 +77,6 @@ public class BiomeGenHighlandMoor extends BOPOverworldBiome
this.addGenerator("red_mushrooms", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.3F).generationAttempts(16).with(Blocks.RED_MUSHROOM.getDefaultState()).create());
// other plants
this.addGenerator("koru", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.7F).with(BOPFoliage.KORU).create());
this.addGenerator("flax", GeneratorStage.FLOWERS,(new GeneratorDoubleFlora.Builder()).amountPerChunk(0.75F).with(BlockBOPDoublePlant.DoublePlantType.FLAX).generationAttempts(6).create());
this.addGenerator("algae", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(5.0F).replace(Blocks.WATER).with(BOPBlocks.coral.getDefaultState().withProperty(BlockBOPCoral.VARIANT, BlockBOPCoral.CoralType.ALGAE)).scatterYMethod(ScatterYMethod.AT_GROUND).create());

1
src/main/java/biomesoplenty/common/biome/overworld/BiomeGenLushSwamp.java
View File

@ -86,7 +86,6 @@ public class BiomeGenLushSwamp extends BOPOverworldBiome
flowerGenerator.add("poppy", 1, (new GeneratorFlora.Builder().with(BlockFlower.EnumFlowerType.POPPY).create()));
// other plants
this.addGenerator("koru", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.3F).with(BOPFoliage.KORU).create());
this.addGenerator("cattail", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.2F).with(BOPPlants.CATTAIL).create());
this.addGenerator("double_cattail", GeneratorStage.FLOWERS, (new GeneratorDoubleFlora.Builder()).amountPerChunk(0.1F).with(BlockBOPDoublePlant.DoublePlantType.TALL_CATTAIL).create());
this.addGenerator("leaf_piles", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).placeOn(BlockQueries.fertile).with(BlockBOPFlatPlant.PlantType.LEAFPILE).create());

2
src/main/java/biomesoplenty/common/biome/overworld/BiomeGenMapleWoods.java
View File

@ -70,6 +70,6 @@ public class BiomeGenMapleWoods extends BOPOverworldBiome
this.addGenerator("dead_leaf_piles", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(3.0F).placeOn(BlockQueries.fertile).with(BlockBOPFlatPlant.PlantType.DEADLEAFPILE).create());
// water plants
this.addGenerator("water_reeds", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(2.0F).with(BOPPlants.REED).generationAttempts(32).create());
this.addGenerator("water_reeds", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(1.5F).with(BOPPlants.REED).generationAttempts(32).create());
}
}

3
src/main/java/biomesoplenty/common/biome/overworld/BiomeGenMire.java
View File

@ -83,9 +83,6 @@ public class BiomeGenMire extends BOPOverworldBiome
grassGenerator.add("shortgrass", 5, (new GeneratorGrass.Builder()).with(BOPFoliage.SHORTGRASS).create());
grassGenerator.add("tallgrass", 1, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.GRASS).create());
// other plants
this.addGenerator("koru", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.3F).with(BOPFoliage.KORU).create());
// water plants
this.addGenerator("algae", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.1F).replace(Blocks.WATER).with(BOPBlocks.coral.getDefaultState().withProperty(BlockBOPCoral.VARIANT, BlockBOPCoral.CoralType.ALGAE)).scatterYMethod(ScatterYMethod.AT_GROUND).create());
this.addGenerator("water_reeds", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BOPPlants.REED).generationAttempts(32).create());

1
src/main/java/biomesoplenty/common/biome/overworld/BiomeGenOasis.java
View File

@ -59,7 +59,6 @@ public class BiomeGenOasis extends BOPOverworldBiome
// other plants
this.addGenerator("dunegrass", GeneratorStage.GRASS, (new GeneratorGrass.Builder()).amountPerChunk(10.0F).with(BOPFoliage.DUNEGRASS).placeOn(BlockQueries.litDry).generationAttempts(8).create());
this.addGenerator("desert_sprouts", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(5.0F).with(BOPFoliage.DESERTSPROUTS).generationAttempts(8).create());
this.addGenerator("desertgrass", GeneratorStage.GRASS, (new GeneratorGrass.Builder()).amountPerChunk(1.0F).with(BOPFoliage.DESERTGRASS).generationAttempts(8).create());
this.addGenerator("tiny_cacti", GeneratorStage.FLOWERS, (new GeneratorFlora.Builder()).amountPerChunk(0.2F).with(BOPPlants.TINYCACTUS).generationAttempts(8).create());
this.addGenerator("sugar_cane", GeneratorStage.FLOWERS,(new GeneratorColumns.Builder()).amountPerChunk(2.0F).generationAttempts(24).placeOn(BlockQueries.litDryWaterside).with(Blocks.REEDS.getDefaultState()).minHeight(1).maxHeight(3).create());

17
src/main/java/biomesoplenty/common/biome/overworld/BiomeGenRainforest.java
View File

@ -1,11 +1,9 @@
package biomesoplenty.common.biome.overworld;
import biomesoplenty.api.biome.BOPBiomes;
import biomesoplenty.api.block.BlockQueries;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPFlowers;
import biomesoplenty.api.enums.BOPFoliage;
import biomesoplenty.api.enums.BOPPlants;
import biomesoplenty.api.enums.BOPTrees;
import biomesoplenty.api.enums.BOPWoods;
import biomesoplenty.api.generation.GeneratorStage;
@ -25,12 +23,13 @@ import net.minecraft.block.BlockOldLeaf;
import net.minecraft.block.BlockPlanks;
import net.minecraft.block.BlockTallGrass;
import net.minecraft.init.Blocks;
import net.minecraft.util.math.BlockPos;
public class BiomeGenRainforest extends BOPOverworldBiome
{
public BiomeGenRainforest()
{
super("rainforest", new PropsBuilder("Rainforest").withGuiColour(0x14E26F).withTemperature(0.85F).withRainfall(1.2F));
super("rainforest", new PropsBuilder("Rainforest").withGuiColour(0x14E26F).withTemperature(0.85F).withRainfall(1.5F));
// terrain
this.terrainSettings.avgHeight(75).heightVariation(45, 60).sidewaysNoise(0.3D);
@ -79,4 +78,16 @@ public class BiomeGenRainforest extends BOPOverworldBiome
// gem
this.addGenerator("emerald", GeneratorStage.SAND, (new GeneratorOreSingle.Builder()).amountPerChunk(12).with(Blocks.EMERALD_ORE.getDefaultState()).create());
}
@Override
public int getGrassColorAtPos(BlockPos pos)
{
return getModdedBiomeGrassColor(0x21D357);
}
@Override
public int getFoliageColorAtPos(BlockPos pos)
{
return getModdedBiomeFoliageColor(0x1DE064);
}
}

3
src/main/java/biomesoplenty/common/biome/overworld/BiomeGenWasteland.java
View File

@ -72,9 +72,6 @@ public class BiomeGenWasteland extends BOPOverworldBiome
GeneratorWeighted flowerGenerator = new GeneratorWeighted(0.05F);
this.addGenerator("flowers", GeneratorStage.FLOWERS, flowerGenerator);
flowerGenerator.add("wilted_lily", 1, (new GeneratorFlora.Builder()).with(BOPFlowers.WILTED_LILY).create());
// lakes
this.addGenerator("lakes", GeneratorStage.SAND, (new GeneratorLakes.Builder()).amountPerChunk(0.05F).waterLakeForBiome(this).create());
}
@Override

1
src/main/java/biomesoplenty/common/biome/overworld/BiomeGenWetland.java
View File

@ -88,7 +88,6 @@ public class BiomeGenWetland extends BOPOverworldBiome
flowerGenerator.add("poppy", 1, (new GeneratorFlora.Builder().with(BlockFlower.EnumFlowerType.POPPY).create()));
// other plants
this.addGenerator("koru", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.3F).with(BOPFoliage.KORU).create());
this.addGenerator("cattail", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(8.0F).with(BOPPlants.CATTAIL).create());
this.addGenerator("double_cattail", GeneratorStage.FLOWERS, (new GeneratorDoubleFlora.Builder()).amountPerChunk(10.0F).with(BlockBOPDoublePlant.DoublePlantType.TALL_CATTAIL).create());
this.addGenerator("leaf_piles", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).placeOn(BlockQueries.fertile).with(BlockBOPFlatPlant.PlantType.LEAFPILE).create());

3
src/main/java/biomesoplenty/common/biome/overworld/BiomeGenXericShrubland.java
View File

@ -78,9 +78,8 @@ public class BiomeGenXericShrubland extends BOPOverworldBiome
flowerGenerator.add("wildflower", 4, (new GeneratorFlora.Builder()).with(BOPFlowers.WILDFLOWER).create());
// other plants
this.addGenerator("dunegrass", GeneratorStage.GRASS, (new GeneratorGrass.Builder()).amountPerChunk(10.0F).with(BOPFoliage.DUNEGRASS).placeOn(this.topBlock).generationAttempts(8).create());
this.addGenerator("dunegrass", GeneratorStage.GRASS, (new GeneratorGrass.Builder()).amountPerChunk(12.5F).with(BOPFoliage.DUNEGRASS).placeOn(this.topBlock).generationAttempts(8).create());
this.addGenerator("desertgrass", GeneratorStage.GRASS, (new GeneratorGrass.Builder()).amountPerChunk(2.0F).with(BOPFoliage.DESERTGRASS).generationAttempts(8).create());
this.addGenerator("desert_sprouts", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(4.0F).with(BOPFoliage.DESERTSPROUTS).generationAttempts(8).create());
this.addGenerator("dead_bushes", GeneratorStage.FLOWERS, (new GeneratorFlora.Builder()).amountPerChunk(0.75F).with(Blocks.DEADBUSH.getDefaultState()).create());
}

3
src/main/java/biomesoplenty/common/biome/vanilla/BiomeExtMesa.java
View File

@ -14,7 +14,6 @@ public class BiomeExtMesa extends ExtendedBiomeWrapper
super(Biomes.MESA);
// other plants
this.addGenerator("desertgrass", GeneratorStage.GRASS, (new GeneratorGrass.Builder()).amountPerChunk(0.3F).with(BOPFoliage.DESERTGRASS).generationAttempts(8).create());
this.addGenerator("tiny_cacti", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).with(BOPPlants.TINYCACTUS).generationAttempts(16).create());
this.addGenerator("desertgrass", GeneratorStage.GRASS, (new GeneratorGrass.Builder()).amountPerChunk(0.3F).with(BOPFoliage.DESERTGRASS).generationAttempts(8).create());
}
}

3
src/main/java/biomesoplenty/common/biome/vanilla/BiomeExtMesaPlateau.java
View File

@ -14,7 +14,6 @@ public class BiomeExtMesaPlateau extends ExtendedBiomeWrapper
super(Biomes.MESA_CLEAR_ROCK);
// other plants
this.addGenerator("desertgrass", GeneratorStage.GRASS, (new GeneratorGrass.Builder()).amountPerChunk(0.3F).with(BOPFoliage.DESERTGRASS).generationAttempts(8).create());
this.addGenerator("tiny_cacti", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).with(BOPPlants.TINYCACTUS).generationAttempts(16).create());
this.addGenerator("desertgrass", GeneratorStage.GRASS, (new GeneratorGrass.Builder()).amountPerChunk(0.3F).with(BOPFoliage.DESERTGRASS).generationAttempts(8).create());
}
}

1
src/main/java/biomesoplenty/common/biome/vanilla/BiomeExtSwampland.java
View File

@ -43,7 +43,6 @@ public class BiomeExtSwampland extends ExtendedBiomeWrapper
// other plants
this.addGenerator("cattail", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(6.0F).with(BOPPlants.CATTAIL).create());
this.addGenerator("double_cattail", GeneratorStage.FLOWERS,(new GeneratorDoubleFlora.Builder()).amountPerChunk(8.0F).with(BlockBOPDoublePlant.DoublePlantType.TALL_CATTAIL).create());
this.addGenerator("koru", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(1.2F).with(BOPFoliage.KORU).create());
// shrooms
this.addGenerator("toadstools", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.4F).generationAttempts(16).with(BlockBOPMushroom.MushroomType.TOADSTOOL).create());

6
src/main/java/biomesoplenty/common/block/BlockBOPFoliage.java
View File

@ -111,7 +111,7 @@ public class BlockBOPFoliage extends BlockBOPDecoration implements IShearable, I
{
case BUSH: case BERRYBUSH:
return ColoringType.LIKE_LEAVES;
case SHORTGRASS: case KORU: case DEVILWEED:
case SHORTGRASS: case DEVILWEED:
return ColoringType.LIKE_GRASS;
default:
return ColoringType.PLAIN;
@ -254,7 +254,7 @@ public class BlockBOPFoliage extends BlockBOPDecoration implements IShearable, I
BOPFoliage plant = (BOPFoliage) state.getValue(this.variantProperty);
switch (plant)
{
case SHORTGRASS: case DESERTGRASS: case DESERTSPROUTS:
case SHORTGRASS: case DESERTGRASS:
return new AxisAlignedBB(0.09999999403953552D, 0.0D, 0.09999999403953552D, 0.8999999761581421D, 0.4000000357627869D, 0.8999999761581421D);
default:
return new AxisAlignedBB(0.09999999403953552D, 0.0D, 0.09999999403953552D, 0.8999999761581421D, 0.800000011920929D, 0.8999999761581421D);
@ -271,8 +271,6 @@ public class BlockBOPFoliage extends BlockBOPDecoration implements IShearable, I
{
case DEADGRASS: case DESERTGRASS:
return BlockQueries.litDry.matches(world, pos.down()) || BlockQueries.sustainsNether.matches(world, pos.down());
case DESERTSPROUTS:
return BlockQueries.litDry.matches(world, pos.down()) || BlockQueries.litFertile.matches(world, pos.down());
case DUNEGRASS:
return BlockQueries.litSand.matches(world, pos.down());
case SPECTRALFERN:

3
src/main/java/biomesoplenty/common/block/BlockBOPSapling.java
View File

@ -18,7 +18,6 @@ import biomesoplenty.common.item.ItemBOPSapling;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import biomesoplenty.common.util.block.VariantPagingHelper;
import biomesoplenty.common.world.generator.tree.GeneratorBasicTree;
import biomesoplenty.common.world.generator.tree.GeneratorBigTree;
import biomesoplenty.common.world.generator.tree.GeneratorMahoganyTree;
import biomesoplenty.common.world.generator.tree.GeneratorPalmTree;
import biomesoplenty.common.world.generator.tree.GeneratorRedwoodTree;
@ -203,7 +202,7 @@ public class BlockBOPSapling extends BlockBOPDecoration implements IGrowable, IP
case PALM:
return new GeneratorPalmTree.Builder().log(BOPWoods.PALM).leaves(BlockBOPLeaves.paging.getVariantState(BOPTrees.PALM).withProperty(BlockOldLeaf.DECAYABLE, Boolean.valueOf(false))).updateNeighbours(true).create();
case REDWOOD:
return new GeneratorRedwoodTree.Builder().create();
return new GeneratorRedwoodTree.Builder().log(BOPWoods.REDWOOD).leaves(BOPTrees.REDWOOD).minHeight(10).maxHeight(30).trunkWidth(1).create();
case WILLOW:
return new GeneratorBasicTree.Builder().log(BOPWoods.WILLOW).leaves(BlockBOPLeaves.paging.getVariantState(BOPTrees.WILLOW).withProperty(BlockOldLeaf.CHECK_DECAY, Boolean.valueOf(false))).minHeight(8).maxHeight(12).maxLeavesRadius(2).vine(BOPBlocks.willow_vine.getDefaultState()).leavesOffset(0).updateNeighbours(true).create();
case MAHOGANY:

4
src/main/java/biomesoplenty/common/init/ModGenerators.java
View File

@ -36,10 +36,8 @@ import biomesoplenty.common.world.generator.tree.GeneratorBush;
import biomesoplenty.common.world.generator.tree.GeneratorMahoganyTree;
import biomesoplenty.common.world.generator.tree.GeneratorMegaJungleTree;
import biomesoplenty.common.world.generator.tree.GeneratorPalmTree;
import biomesoplenty.common.world.generator.tree.GeneratorPineTree;
import biomesoplenty.common.world.generator.tree.GeneratorProfileTree;
import biomesoplenty.common.world.generator.tree.GeneratorRedwoodTree;
import biomesoplenty.common.world.generator.tree.GeneratorRedwoodTreeThin;
import biomesoplenty.common.world.generator.tree.GeneratorTaigaTree;
import biomesoplenty.common.world.generator.tree.GeneratorTwigletTree;
@ -54,7 +52,6 @@ public class ModGenerators
registerGenerator("big_tree", GeneratorBigTree.class, new GeneratorBigTree.Builder());
registerGenerator("bush", GeneratorBush.class, new GeneratorBush.Builder());
registerGenerator("twiglet_tree", GeneratorTwigletTree.class, new GeneratorTwigletTree.Builder());
registerGenerator("pine_tree", GeneratorPineTree.class, new GeneratorPineTree.Builder());
registerGenerator("bulb_tree", GeneratorBulbTree.class, new GeneratorBulbTree.Builder());
registerGenerator("mega_jungle_tree", GeneratorMegaJungleTree.class, new GeneratorMegaJungleTree.Builder());
registerGenerator("bayou_tree", GeneratorBayouTree.class, new GeneratorBayouTree.Builder());
@ -76,7 +73,6 @@ public class ModGenerators
registerGenerator("crystals", GeneratorCrystals.class, new GeneratorCrystals.Builder());
registerGenerator("spike", GeneratorSpike.class, new GeneratorSpike.Builder());
registerGenerator("redwood_tree", GeneratorRedwoodTree.class, new GeneratorRedwoodTree.Builder());
registerGenerator("redwood_tree_thin", GeneratorRedwoodTreeThin.class, new GeneratorRedwoodTreeThin.Builder());
registerGenerator("mahogany_tree", GeneratorMahoganyTree.class, new GeneratorMahoganyTree.Builder());
registerGenerator("palm_tree", GeneratorPalmTree.class, new GeneratorPalmTree.Builder());
}

3
src/main/java/biomesoplenty/common/world/ChunkGeneratorOverworldBOP.java
View File

@ -26,6 +26,7 @@ import java.util.List;
import java.util.Map;
import java.util.Random;
import biomesoplenty.api.biome.BOPBiomes;
import biomesoplenty.common.biome.overworld.BOPOverworldBiome;
import biomesoplenty.common.util.biome.BiomeUtils;
import net.minecraft.block.BlockFalling;
@ -541,7 +542,7 @@ public class ChunkGeneratorOverworldBOP implements IChunkGenerator
}
// add lava lakes
if (!hasVillageGenerated && this.rand.nextInt(this.settings.lavaLakeChance / 10) == 0 && this.settings.useLavaLakes && TerrainGen.populate(this, world, rand, chunkX, chunkZ, hasVillageGenerated, LAVA))
if (!hasVillageGenerated && (BOPBiomes.redwood_forest.isPresent() && Biome != BOPBiomes.redwood_forest.get()) && (BOPBiomes.redwood_forest_edge.isPresent() && Biome != BOPBiomes.redwood_forest_edge.get()) && (BOPBiomes.wasteland.isPresent() && Biome != BOPBiomes.wasteland.get()) && this.rand.nextInt(this.settings.lavaLakeChance / 10) == 0 && this.settings.useLavaLakes && TerrainGen.populate(this, world, rand, chunkX, chunkZ, hasVillageGenerated, LAVA))
{
target = decorateStart.add(this.rand.nextInt(16), this.rand.nextInt(248) + 8, this.rand.nextInt(16));
if (target.getY() < 63 || this.rand.nextInt(this.settings.lavaLakeChance / 8) == 0)

515
src/main/java/biomesoplenty/common/world/generator/tree/GeneratorBayouTree.java
View File

@ -7,9 +7,11 @@
******************************************************************************/
package biomesoplenty.common.world.generator.tree;
import java.util.Random;
import biomesoplenty.api.block.BOPBlocks;
import org.apache.commons.lang3.tuple.Pair;
import biomesoplenty.api.block.BlockQueries;
import biomesoplenty.api.block.IBlockPosQuery;
import biomesoplenty.api.config.IConfigObj;
@ -17,9 +19,14 @@ import biomesoplenty.common.util.biome.GeneratorUtils;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import biomesoplenty.common.util.block.BlockQuery;
import biomesoplenty.common.util.block.BlockQuery.BlockQueryBlock;
import biomesoplenty.common.util.block.BlockQuery.BlockQueryMaterial;
import biomesoplenty.common.util.block.BlockQuery.BlockQueryParseException;
import biomesoplenty.common.util.block.BlockQuery.BlockQueryState;
import biomesoplenty.common.world.generator.GeneratorSpike;
import net.minecraft.block.Block;
import net.minecraft.block.BlockCocoa;
import net.minecraft.block.BlockVine;
import net.minecraft.block.material.Material;
import net.minecraft.block.state.IBlockState;
import net.minecraft.init.Blocks;
import net.minecraft.util.EnumFacing;
@ -28,267 +35,363 @@ import net.minecraft.world.World;
public class GeneratorBayouTree extends GeneratorTreeBase
{
public static class Builder extends GeneratorTreeBase.InnerBuilder<Builder, GeneratorBayouTree> implements IGeneratorBuilder<GeneratorBayouTree>
{
protected int minLeavesRadius;
protected int leavesGradient;
protected int vineAttempts;
protected int maxVineLength;
protected IBlockPosQuery rootsReplace;
public Builder minLeavesRadius(int a) {this.minLeavesRadius = a; return this.self();}
public Builder leavesGradient(int a) {this.leavesGradient = a; return this.self();}
public Builder vineAttempts(int a) {this.vineAttempts = a; return this.self();}
public Builder maxVineLength(int a) {this.maxVineLength = a; return this.self();}
public Builder rootsReplace(IBlockPosQuery a) {this.replace = a; return this.self();}
public Builder rootsReplace(String a) throws BlockQueryParseException {this.replace = BlockQuery.parseQueryString(a); return this.self();}
public Builder rootsReplace(Block a) {this.replace = new BlockQueryBlock(a); return this.self();}
public Builder rootsReplace(IBlockState a) {this.replace = new BlockQueryState(a); return this.self();}
public static class Builder extends GeneratorBayouTree.InnerBuilder<Builder, GeneratorBayouTree> implements IGeneratorBuilder<GeneratorBayouTree>
{
public Builder()
{
// defaults
this.amountPerChunk = 1.0F;
this.placeOn = BlockQueries.fertile;
this.replace = BlockQueries.airOrLeaves;
this.rootsReplace = BlockQueries.rootsCanDigThrough;
this.replace = new BlockQueryMaterial(Material.AIR, Material.LEAVES, Material.VINE, Material.WATER);
this.log = Blocks.LOG.getDefaultState();
this.leaves = Blocks.LEAVES.getDefaultState();
this.vine = BOPBlocks.willow_vine.getDefaultState();
this.vine = null;
this.hanging = null;
this.trunkFruit = null;
this.altLeaves = null;
this.minHeight = 8;
this.maxHeight = 18;
this.minLeavesRadius = 2;
this.leavesGradient = 4;
this.vineAttempts = 20;
this.maxVineLength = 20;
this.scatterYMethod = ScatterYMethod.AT_SURFACE;
this.minHeight = 4;
this.maxHeight = 7;
this.updateNeighbours = false;
this.leafLayers = 4;
this.leavesOffset = 1;
this.maxLeavesRadius = 1;
this.leavesLayerHeight = 2;
this.placeVinesOn = BlockQueries.air;
this.hangingChance = 0.0F;
this.scatterYMethod = ScatterYMethod.AT_GROUND;
}
@Override
public GeneratorBayouTree create()
{
return new GeneratorBayouTree(this.amountPerChunk, this.placeOn, this.replace, this.log, this.leaves, this.vine, this.hanging, this.trunkFruit, this.altLeaves, this.minHeight, this.maxHeight, this.minLeavesRadius, this.leavesGradient, this.vineAttempts, this.maxVineLength, this.rootsReplace, this.scatterYMethod);
return new GeneratorBayouTree(this.amountPerChunk, this.placeOn, this.replace, this.log, this.leaves, this.vine, this.hanging, this.trunkFruit, this.altLeaves, this.minHeight, this.maxHeight, this.updateNeighbours, this.leafLayers, this.leavesOffset, this.maxLeavesRadius, this.leavesLayerHeight, this.placeVinesOn, this.hangingChance, this.scatterYMethod);
}
}
private int minLeavesRadius;
private int leavesGradient;
private int vineAttempts;
private int maxVineLength;
private IBlockPosQuery rootsReplace;
protected static abstract class InnerBuilder<T extends InnerBuilder<T, G>, G extends GeneratorBayouTree> extends GeneratorTreeBase.InnerBuilder<T, G>
{
protected int leafLayers;
protected int leavesOffset;
protected int maxLeavesRadius;
protected int leavesLayerHeight;
protected IBlockPosQuery placeVinesOn;
protected float hangingChance;
public T leafLayers(int a) {this.leafLayers = a; return this.self();}
public T leavesOffset(int a) {this.leavesOffset = a; return this.self();}
public T leavesLayerHeight(int a) {this.leavesLayerHeight = a; return this.self();}
public T maxLeavesRadius(int a) {this.maxLeavesRadius = a; return this.self();}
public T placeVinesOn(IBlockPosQuery a) {this.placeVinesOn = a; return this.self();}
public T placeVinesOn(String a) throws BlockQueryParseException {this.placeVinesOn = BlockQuery.parseQueryString(a); return this.self();}
public T placeVinesOn(Block a) {this.placeVinesOn = new BlockQueryBlock(a); return this.self();}
public T placeVinesOn(IBlockState a) {this.placeVinesOn = new BlockQueryState(a); return this.self();}
public T placeVinesOn(Material... a) {this.placeVinesOn = new BlockQueryMaterial(a); return this.self();}
public T hangingChance(float a) {this.hangingChance = a; return this.self();}
}
public GeneratorBayouTree(float amountPerChunk, IBlockPosQuery placeOn, IBlockPosQuery replace, IBlockState log, IBlockState leaves, IBlockState vine, IBlockState hanging, IBlockState trunkFruit, IBlockState altLeaves, int minHeight, int maxHeight, int minLeavesRadius, int leavesGradient, int vineAttempts, int maxVineLength, IBlockPosQuery rootsReplace, ScatterYMethod scatterYMethod)
protected boolean updateNeighbours;
protected int leafLayers;
protected int leavesOffset;
protected int maxLeavesRadius;
protected int leavesLayerHeight;
protected IBlockPosQuery placeVinesOn;
protected float hangingChance;
public GeneratorBayouTree(float amountPerChunk, IBlockPosQuery placeOn, IBlockPosQuery replace, IBlockState log, IBlockState leaves, IBlockState vine, IBlockState hanging, IBlockState trunkFruit, IBlockState altLeaves, int minHeight, int maxHeight, boolean updateNeighbours, int leafLayers, int leavesOffset, int maxLeavesRadius, int leavesLayerHeight, IBlockPosQuery placeVinesOn, float hangingChance, ScatterYMethod scatterYMethod)
{
super(amountPerChunk, placeOn, replace, log, leaves, vine, hanging, trunkFruit, altLeaves, minHeight, maxHeight, scatterYMethod);
this.minLeavesRadius = minLeavesRadius;
this.leavesGradient = leavesGradient;
this.vineAttempts = vineAttempts;
this.maxVineLength = maxVineLength;
this.rootsReplace = rootsReplace;
this.updateNeighbours = updateNeighbours;
this.leavesOffset = leavesOffset;
this.leafLayers = leafLayers;
this.maxLeavesRadius = maxLeavesRadius;
this.leavesLayerHeight = leavesLayerHeight;
this.placeVinesOn = placeVinesOn;
this.hangingChance = hangingChance;
}
@Override
public BlockPos getScatterY(World world, Random random, int x, int z)
public boolean generate(World world, Random random, BlockPos pos)
{
// always at ground (sometimes underwater)
return GeneratorUtils.ScatterYMethod.AT_GROUND.getBlockPos(world, random, x, z);
}
public boolean setRoot(World world, BlockPos pos)
{
if (this.rootsReplace.matches(world, pos))
int height = random.nextInt(this.maxHeight - this.minHeight) + this.minHeight;
boolean hasSpace = true;
//Generate only if we are above the lowest bedrock level (1) and reach less than the world height
//There must be a gap of 1 between the top leaf block and the world height
if (pos.getY() >= 1 && pos.getY() + height + 1 <= 256)
{
world.setBlockState(pos, this.log, 2);
return true;
}
return false;
}
public boolean checkRootViable(World world, BlockPos pos, int rootHeight, EnumFacing direction)
{
// a viable root has an path which roots can dig through from trunk to some fertile ground
pos = pos.offset(direction).up(rootHeight - 1);
for (int i = 0; i < rootHeight; i++)
{
if (!this.rootsReplace.matches(world, pos)) {return false;}
pos = pos.down();
if (this.placeOn.matches(world, pos)) {return true;}
}
return false;
}
public boolean checkSpace(World world, BlockPos pos, int rootHeight, int middleHeight, int height)
{
// we want at least 2 of the roots to be viable
int rootsOk = 0;
for (EnumFacing direction : EnumFacing.Plane.HORIZONTAL)
{
if (this.checkRootViable(world, pos, rootHeight, direction)) {rootsOk++;}
}
if (rootsOk < 2) {return false;}
// check there's some space for the trunk and leaves too
for (int y = rootHeight; y <= height; y++)
{
// require 1x1 for the trunk, 3x3 for the leaves
int radius = (y <= (rootHeight + middleHeight) ? 0 : 1);
for (int x = -radius; x <= radius; x++)
int radius;
for (int y = pos.getY(); y <= pos.getY() + 1 + height; y++)
{
for (int z = -radius; z <= radius; z++)
radius = 1;
//Don't check for space on the first level, if we are a sapling then there will
//already be a block here (the sapling itself)
if (y == pos.getY())
{
BlockPos pos1 = pos.add(x, y, z);
// note, there may be a sapling on the first layer - make sure this.replace matches it!
if (pos1.getY() >= 255 || !this.replace.matches(world, pos1))
radius = 0;
}
//At and above the top log block, require a radius of 2 to be empty
if (y >= pos.getY() + 1 + height - 2)
{
radius = 2;
}
for (int x = pos.getX() - radius; x <= pos.getX() + radius && hasSpace; ++x)
{
for (int z = pos.getZ() - radius; z <= pos.getZ() + radius && hasSpace; ++z)
{
return false;
if (y < 0 || y > 256)
{
hasSpace = false;
}
}
}
}
}
return true;
}
public void generateTop(World world, Random random, BlockPos pos, int topHeight)
{
for (int y = 0; y < topHeight; y++)
{
int radius = Math.min(3, this.minLeavesRadius + (topHeight - y) / this.leavesGradient);
for (int x = -radius; x <= radius; ++x)
if (!hasSpace)
{
for (int z = -radius; z <= radius; ++z)
return false;
}
else
{
BlockPos soilPos = pos.down();
Block soil = world.getBlockState(soilPos).getBlock();
if (this.placeOn.matches(world, soilPos) && pos.getY() < 256 - height - 1)
{
// too far away and the leaves will decay
int dist = Math.abs(x) + Math.abs(z);
if (dist < 4 || (dist == 4 && random.nextInt(2) == 0))
soil.onPlantGrow(world.getBlockState(soilPos), world, soilPos, pos);
int leavesLayers = (this.leafLayers - 1);
//Generates leaves at the top of the tree, going one block above the top log (<= rather than <)
for (int y = pos.getY() + height - leavesLayers; y <= pos.getY() + height; y++)
{
this.setLeaves(world, pos.add(x, y, z));
//Determines the distance from the top of the tree as a negative number
int currentLayer = y - (pos.getY() + height);
//Uses integer division truncation (-3 / 2 = -1, -2 / 2 = -1) to reduce
//the radius closer to the top of the tree. (2, 2, 1, 1)
int leavesRadius = this.maxLeavesRadius - currentLayer / this.leavesLayerHeight;
for (int x = pos.getX() - leavesRadius; x <= pos.getX() + leavesRadius; x++)
{
int xDiff = x - pos.getX();
for (int z = pos.getZ() - leavesRadius; z <= pos.getZ() + leavesRadius; ++z)
{
int zDiff = z - pos.getZ();
//Randomly prevent the generation of leaves on the corners of each layer
//If the layer is the top layer, never generate the corners
if (Math.abs(xDiff) != leavesRadius || Math.abs(zDiff) != leavesRadius || random.nextInt(2) != 0 && currentLayer != 0)
{
BlockPos leavesPos = new BlockPos(x, y, z);
if (this.replace.matches(world, leavesPos))
{
if (this.altLeaves != null)
{
if (random.nextInt(4) == 0)
{
this.setBlockAndNotifyAdequately(world, leavesPos, this.altLeaves);
}
else
{
this.setBlockAndNotifyAdequately(world, leavesPos, this.leaves);
}
}
else
{
this.setBlockAndNotifyAdequately(world, leavesPos, this.leaves);
}
}
}
}
}
}
this.generateTrunk(world, pos, height);
if (this.vine != null)
{
for (int y = pos.getY() - leavesLayers + height; y <= pos.getY() + height; y++)
{
//Determines the distance from the top of the tree as a negative number
int currentLayer = y - (pos.getY() + height);
//Uses integer division truncation (-3 / 2 = -1, -2 / 2 = -1) to reduce
//the radius closer to the top of the tree. (3, 3, 2, 2)
int leavesRadius = (this.maxLeavesRadius + this.leavesOffset) - currentLayer / this.leavesLayerHeight;
for (int x = pos.getX() - leavesRadius; x <= pos.getX() + leavesRadius; x++)
{
for (int z = pos.getZ() - leavesRadius; z <= pos.getZ() + leavesRadius; z++)
{
BlockPos blockpos3 = new BlockPos(x, y, z);
//Surround leaves on the edge of the tree with vines and extend them downwards
if (world.getBlockState(blockpos3).getBlock().isLeaves(world.getBlockState(blockpos3), world, blockpos3))
{
BlockPos westPos = blockpos3.west();
BlockPos eastPos = blockpos3.east();
BlockPos northPos = blockpos3.north();
BlockPos southPos = blockpos3.south();
if (random.nextInt(4) == 0 && this.placeVinesOn.matches(world, westPos))
{
this.extendVines(world, westPos, EnumFacing.EAST);
}
if (random.nextInt(4) == 0 && this.placeVinesOn.matches(world, eastPos))
{
this.extendVines(world, eastPos, EnumFacing.WEST);
}
if (random.nextInt(4) == 0 && this.placeVinesOn.matches(world, northPos))
{
this.extendVines(world, northPos, EnumFacing.SOUTH);
}
if (random.nextInt(4) == 0 && this.placeVinesOn.matches(world, southPos))
{
this.extendVines(world, southPos, EnumFacing.NORTH);
}
}
}
}
}
}
//Generate fruit or any other blocks that may hang off of the tree
if (this.hanging != null) this.generateHanging(world, pos, height);
if (this.trunkFruit != null)
{
if (random.nextInt(5) == 0 && height > 5)
{
for (int l3 = 0; l3 < 2; ++l3)
{
for (EnumFacing enumfacing : EnumFacing.Plane.HORIZONTAL)
{
if (random.nextInt(4 - l3) == 0)
{
EnumFacing enumfacing1 = enumfacing.getOpposite();
this.generateTrunkFruit(world, random.nextInt(3), pos.add(enumfacing1.getFrontOffsetX(), height - 5 + l3, enumfacing1.getFrontOffsetZ()), enumfacing);
}
}
}
}
}
return true;
}
else
{
return false;
}
}
if (y < topHeight - 1)
}
else
{
return false;
}
}
protected void generateTrunk(World world, BlockPos start, int height)
{
//Create the trunk from the bottom up, using < to ensure it is covered with one layer of leaves
for (int layer = 0; layer < height; ++layer)
{
BlockPos blockpos2 = start.up(layer);
if (this.replace.matches(world, blockpos2))
{
// add the trunk in the middle
this.setLog(world, pos.add(0, y, 0));
} else {
// add leaves on top for certain
this.setLeaves(world, pos.add(0, y, 0));
this.setBlockAndNotifyAdequately(world, start.up(layer), this.log);
}
}
}
public void generateRoots(World world, Random random, BlockPos pos, int rootHeight)
protected void generateHanging(World world, BlockPos start, int height)
{
for (int i = 0; i < rootHeight; i++)
//Generate below the bottom layer of leaves
int y = start.getY() + (height - this.leafLayers);
for (int x = start.getX() - (maxLeavesRadius + 1); x <= start.getX() + (maxLeavesRadius + 1); x++)
{
this.setRoot(world, pos.north());
this.setRoot(world, pos.east());
this.setRoot(world, pos.south());
this.setRoot(world, pos.west());
pos = pos.up();
}
this.setRoot(world, pos.down());
}
@Override
public boolean generate(World world, Random random, BlockPos startPos)
{
for (int z = start.getZ() - (maxLeavesRadius + 1); z <= start.getZ() + (maxLeavesRadius + 1); z++)
{
BlockPos hangingPos = new BlockPos(x, y, z);
if (!this.placeOn.matches(world, startPos.down()))
{
// Abandon if we can't place the tree on this block
return false;
}
// Choose heights
int height = GeneratorUtils.nextIntBetween(random, this.minHeight, this.maxHeight);
int topHeight = Math.min(6, GeneratorUtils.nextIntBetween(random, height / 5, height / 3));
int rootHeight = Math.min(5, GeneratorUtils.nextIntBetween(random, height / 4, height / 2));
int middleHeight = height - topHeight - rootHeight;
if (middleHeight < 1) {return false;}
// Start in the ground block
BlockPos pos = startPos.down();
if (!this.checkSpace(world, pos, rootHeight, middleHeight, height))
{
// Abandon if there isn't enough room
return false;
}
// Generate roots
this.generateRoots(world, random, pos, rootHeight);
pos = pos.up(rootHeight);
// Generate middle of tree (trunk only)
for(int i = 0; i < middleHeight; i++)
{
this.setLog(world, pos);
pos = pos.up();
}
// Generate the top of the tree
this.generateTop(world, random, pos, topHeight);
// Add vines
if (this.vine != null)
{
int maxLeavesRadius = this.minLeavesRadius + topHeight / this.leavesGradient;
this.addVines(world, random, startPos, height, maxLeavesRadius, this.vineAttempts);
}
return true;
}
protected void addVines(World world, Random rand, BlockPos startPos, int height, int leavesRadius, int generationAttempts)
{
for (int i = 0; i < generationAttempts; i++)
{
// choose a random direction
EnumFacing direction = EnumFacing.Plane.HORIZONTAL.random(rand);
EnumFacing back = direction.getOpposite();
EnumFacing sideways = direction.rotateY();
// choose a random starting point somewhere just outside the boundary of the tree
BlockPos pos = startPos.up(GeneratorUtils.nextIntBetween(rand, 2, height)).offset(direction, leavesRadius + 1).offset(sideways, GeneratorUtils.nextIntBetween(rand, -leavesRadius, leavesRadius));
// move back towards the center until we meet a leaf or log, then stick a vine on it
IBlockState state;
for (int l = 0; l < leavesRadius; l++)
{
state = world.getBlockState(pos.offset(back, 1 + l));
if (state == this.leaves || state == this.log) {
this.setVine(world, rand, pos.offset(back, l), back, this.maxVineLength);
break;
if (!world.isAirBlock(hangingPos.up()) && (world.isAirBlock(hangingPos)) && world.rand.nextFloat() <= this.hangingChance)
{
this.setHanging(world, hangingPos);
}
}
}
}
private void generateTrunkFruit(World world, int age, BlockPos pos, EnumFacing direction)
{
if (this.trunkFruit == Blocks.COCOA.getDefaultState())
{
this.setBlockAndNotifyAdequately(world, pos, this.trunkFruit.withProperty(BlockCocoa.AGE, Integer.valueOf(age)).withProperty(BlockCocoa.FACING, direction));
}
else
{
this.setBlockAndNotifyAdequately(world, pos, this.trunkFruit.withProperty(BlockCocoa.FACING, direction));
}
}
private IBlockState getVineStateForSide(EnumFacing side)
{
return this.vine.getBlock() instanceof BlockVine ? this.vine.withProperty(BlockVine.getPropertyFor(side), Boolean.valueOf(true)) : this.vine;
}
private void extendVines(World world, BlockPos pos, EnumFacing side)
{
IBlockState vineState = this.getVineStateForSide(side);
this.setBlockAndNotifyAdequately(world, pos, vineState);
int length = 4;
//Extend vine downwards for a maximum of 4 blocks
for (pos = pos.down(); this.placeVinesOn.matches(world, pos) && length > 0; length--)
{
this.setBlockAndNotifyAdequately(world, pos, vineState);
pos = pos.down();
}
}
public void setBlockAndNotifyAdequately(World world, BlockPos pos, IBlockState state)
{
if (this.updateNeighbours)
{
world.setBlockState(pos, state, 3);
}
else
{
world.setBlockState(pos, state, 2);
}
}
@Override
public void configure(IConfigObj conf)
{
{
this.amountPerChunk = conf.getFloat("amountPerChunk", this.amountPerChunk);
this.minHeight = conf.getInt("minHeight", this.minHeight);
this.minLeavesRadius = conf.getInt("minLeavesRadius", this.minLeavesRadius);
this.leavesGradient = conf.getInt("leavesGradient", this.leavesGradient);
this.vineAttempts = conf.getInt("vineAttempts", this.vineAttempts);
this.maxVineLength = conf.getInt("maxVineLength", this.maxVineLength);
this.placeOn = conf.getBlockPosQuery("placeOn", this.placeOn);
this.replace = conf.getBlockPosQuery("replace", this.replace);
this.rootsReplace = conf.getBlockPosQuery("rootsReplace", this.rootsReplace);
this.updateNeighbours = conf.getBool("updateNeighbours", this.updateNeighbours);
int minHeight = conf.getInt("minHeight", this.minHeight);
int maxHeight = conf.getInt("maxHeight", this.maxHeight);
Pair<Integer, Integer> heights = GeneratorUtils.validateMinMaxHeight(minHeight, maxHeight);
this.minHeight = heights.getLeft();
this.maxHeight = heights.getRight();
this.log = conf.getBlockState("logState", this.log);
this.leaves = conf.getBlockState("leavesState", this.leaves);
this.vine = conf.getBlockState("vinesState", this.vine);
this.vine = conf.getBlockState("vineState", this.vine);
this.hanging = conf.getBlockState("hangingState", this.hanging);
this.trunkFruit = conf.getBlockState("trunkFruitState", this.trunkFruit);
this.altLeaves = conf.getBlockState("altLeavesState", this.altLeaves);
this.hangingChance = conf.getFloat("hangingChance", this.hangingChance);
}
}
}

208
src/main/java/biomesoplenty/common/world/generator/tree/GeneratorPineTree.java
View File

@ -1,208 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.world.generator.tree;
import java.util.Random;
import biomesoplenty.api.block.BlockQueries;
import biomesoplenty.api.block.IBlockPosQuery;
import biomesoplenty.api.config.IConfigObj;
import biomesoplenty.common.util.biome.GeneratorUtils;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import net.minecraft.block.state.IBlockState;
import net.minecraft.init.Blocks;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
public class GeneratorPineTree extends GeneratorTreeBase
{
public static class Builder extends GeneratorTreeBase.InnerBuilder<Builder, GeneratorPineTree> implements IGeneratorBuilder<GeneratorPineTree>
{
public Builder()
{
this.amountPerChunk = 1.0F;
this.minHeight = 6;
this.maxHeight = 12;
this.placeOn = BlockQueries.fertile;
this.replace = BlockQueries.airOrLeaves;
this.log = Blocks.LOG.getDefaultState();
this.leaves = Blocks.LEAVES.getDefaultState();
this.vine = null;
this.hanging = hanging;
this.trunkFruit = null;
this.altLeaves = null;
this.scatterYMethod = ScatterYMethod.AT_SURFACE;
}
@Override
public GeneratorPineTree create() {
return new GeneratorPineTree(this.amountPerChunk, this.placeOn, this.replace, this.log, this.leaves, this.vine, this.hanging, this.trunkFruit, this.altLeaves, this.minHeight, this.maxHeight, this.scatterYMethod);
}
}
public GeneratorPineTree(float amountPerChunk, IBlockPosQuery placeOn, IBlockPosQuery replace, IBlockState log, IBlockState leaves, IBlockState vine, IBlockState hanging, IBlockState trunkFruit, IBlockState altLeaves, int minHeight, int maxHeight, ScatterYMethod scatterYMethod)
{
super(amountPerChunk, placeOn, replace, log, leaves, vine, hanging, trunkFruit, altLeaves, minHeight, maxHeight, scatterYMethod);
}
@Override
public boolean generate(World world, Random random, BlockPos pos)
{
// Move down until we reach the ground
while (pos.getY() > 1 && world.isAirBlock(pos) || world.getBlockState(pos).getBlock().isLeaves(world.getBlockState(pos), world, pos)) {pos = pos.down();}
if (!this.placeOn.matches(world, pos))
{
// Abandon if we can't place the tree on this block
return false;
}
// Choose heights
int height = GeneratorUtils.nextIntBetween(random, this.minHeight, this.maxHeight);
if (height < 6) {return false;}
int heightMinusTop = height - 3;
int numBranches = heightMinusTop / 3;
int baseHeight = heightMinusTop - (numBranches * 2);
// Move up to space above ground
pos = pos.up();
if (!this.checkSpace(world, pos, baseHeight, height))
{
// Abandon if there isn't enough room
return false;
}
// Generate bottom of tree (trunk only)
for(int i = 0; i < baseHeight; i++)
{
this.setLog(world, pos);
pos = pos.up();
}
// Generate middle of the tree - 2 steps at a time (trunk and leaves)
for(int i = 0; i < numBranches; i++)
{
this.generateLeafLayer(world, random, pos, i);
pos = pos.up(2);
}
// Generate top of tree
generateTop(world, pos);
return true;
}
public boolean checkSpace(World world, BlockPos pos, int baseHeight, int height)
{
for (int y = 0; y <= height; y++)
{
// require 3x3 for the leaves, 1x1 for the trunk
int radius = (y <= baseHeight ? 0 : 1);
for (int x = -radius; x <= radius; x++)
{
for (int z = -radius; z <= radius; z++)
{
BlockPos pos1 = pos.add(x, y, z);
// note, there may be a sapling on the first layer - make sure this.replace matches it!
if (pos1.getY() >= 255 || !this.replace.matches(world, pos1))
{
return false;
}
}
}
}
return true;
}
// generate the top of the tree (3 blocks)
public void generateTop(World world, BlockPos pos)
{
for(int x = -1; x <= 1; x++)
{
for(int z = -1; z <= 1; z++)
{
this.setLeaves(world, pos.add(x, 0, z));
}
}
this.setLog(world, pos);
pos = pos.up();
this.setLeaves(world, pos);
this.setLeaves(world, pos.north());
this.setLeaves(world, pos.east());
this.setLeaves(world, pos.south());
this.setLeaves(world, pos.west());
this.setLeaves(world, pos.up());
}
// generates a 'branch' of a leaf layer - extra leaves in the corner in the specified direction
public void generateBranch(World world, BlockPos pos, EnumFacing direction, boolean dropY, boolean dropCorner)
{
EnumFacing sideways = direction.rotateY();
if (dropY) {pos = pos.down();}
this.setLeaves(world, pos.offset(direction, 1).offset(sideways, 1));
this.setLeaves(world, pos.offset(direction, 2).offset(sideways, 1));
this.setLeaves(world, pos.offset(direction, 1).offset(sideways, 2));
this.setLeaves(world, pos.offset(direction, 2).offset(sideways, 2));
if (dropCorner)
{
this.setLeaves(world, pos.offset(direction, 2).offset(sideways, 2).down());
}
}
// generates a layer of leafs (2 blocks high)
public void generateLeafLayer(World world, Random rand, BlockPos pos, int leafLayerNum)
{
// middle 3x3 are always leaves
for(int x = -1; x <= 1; x++)
{
for(int z = -1; z <= 1; z++)
{
this.setLeaves(world, pos.add(x, 0, z));
}
}
// sometimes add leaves further out - alternate layers at right angles to each other
EnumFacing direction = (leafLayerNum % 2 == 0) ? EnumFacing.NORTH : EnumFacing.EAST;
boolean dropY = (rand.nextInt(2) == 0);
boolean dropCorner = (rand.nextInt(2) == 0);
if (rand.nextInt(2) == 0)
{
this.generateBranch(world, pos, direction, dropY, dropCorner);
}
if (rand.nextInt(2) == 0)
{
this.generateBranch(world, pos, direction.getOpposite(), dropY, dropCorner);
}
// add the trunk in the middle
this.setLog(world, pos);
this.setLog(world, pos.up());
}
@Override
public void configure(IConfigObj conf)
{
this.amountPerChunk = conf.getFloat("amountPerChunk", this.amountPerChunk);
this.minHeight = conf.getInt("minHeight", this.minHeight);
this.maxHeight = conf.getInt("minHeight", this.maxHeight);
this.placeOn = conf.getBlockPosQuery("placeOn", this.placeOn);
this.replace = conf.getBlockPosQuery("replace", this.replace);
this.log = conf.getBlockState("logState", this.log);
this.leaves = conf.getBlockState("leavesState", this.leaves);
}
}

202
src/main/java/biomesoplenty/common/world/generator/tree/GeneratorRedwoodTreeThin.java
View File

@ -1,202 +0,0 @@
/*******************************************************************************
* Copyright 2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.world.generator.tree;
import java.util.Random;
import biomesoplenty.api.block.BlockQueries;
import biomesoplenty.api.block.IBlockPosQuery;
import biomesoplenty.api.config.IConfigObj;
import biomesoplenty.api.enums.BOPTrees;
import biomesoplenty.api.enums.BOPWoods;
import biomesoplenty.common.block.BlockBOPLeaves;
import biomesoplenty.common.block.BlockBOPLog;
import biomesoplenty.common.util.biome.GeneratorUtils;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import biomesoplenty.common.world.generator.GeneratorSpike;
import net.minecraft.block.BlockOldLeaf;
import net.minecraft.block.state.IBlockState;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
public class GeneratorRedwoodTreeThin extends GeneratorTreeBase
{
public static class Builder extends GeneratorTreeBase.InnerBuilder<Builder, GeneratorRedwoodTreeThin> implements IGeneratorBuilder<GeneratorRedwoodTreeThin>
{
public Builder()
{
this.amountPerChunk = 1.0F;
this.minHeight = 30;
this.maxHeight = 50;
this.placeOn = BlockQueries.fertile;
this.replace = BlockQueries.replaceable;
this.log = BlockBOPLog.paging.getVariantState(BOPWoods.REDWOOD);
this.leaves = BlockBOPLeaves.paging.getVariantState(BOPTrees.REDWOOD).withProperty(BlockOldLeaf.CHECK_DECAY, Boolean.valueOf(false));
this.vine = null;
this.hanging = null;
this.trunkFruit = null;
this.altLeaves = null;
this.scatterYMethod = ScatterYMethod.AT_SURFACE;
}
@Override
public GeneratorRedwoodTreeThin create()
{
return new GeneratorRedwoodTreeThin(this.amountPerChunk, this.placeOn, this.replace, this.log, this.leaves, this.vine, this.hanging, this.trunkFruit, this.altLeaves, this.minHeight, this.maxHeight, this.scatterYMethod);
}
}
protected GeneratorRedwoodTreeThin(float amountPerChunk, IBlockPosQuery placeOn, IBlockPosQuery replace, IBlockState log, IBlockState leaves, IBlockState vine, IBlockState hanging, IBlockState trunkFruit, IBlockState altLeaves, int minHeight, int maxHeight, ScatterYMethod scatterYMethod)
{
super(amountPerChunk, placeOn, replace, log, leaves, vine, hanging, trunkFruit, altLeaves, minHeight, maxHeight, scatterYMethod);
}
public boolean canPlaceHere(World world, BlockPos pos, int height, int radius)
{
if (pos.getY() < 1 || pos.getY() + height > 255)
{
return false;
}
for (int y = pos.getY(); y <= pos.getY() + height; ++y)
{
for (int x = pos.getX() - radius; x <= pos.getX() + radius; ++x)
{
for (int z = pos.getZ() - radius; z <= pos.getZ() + radius; ++z)
{
if (y == pos.getY() && !this.placeOn.matches(world, new BlockPos(x, y - 1, z)))
{
return false;
}
if (!this.replace.matches(world, new BlockPos(x, y, z)))
{
return false;
}
}
}
}
return true;
}
public void generateTrunk(World world, Random random, BlockPos pos, int trunkHeight)
{
for (int i = 0; i < trunkHeight; i++)
{
this.setLog(world, pos);
pos = pos.up();
}
}
public void generateBranches(World world, Random rand, BlockPos pos, int length)
{
//Iterate over the possible directions
for (EnumFacing direction = EnumFacing.NORTH; direction.ordinal() < 5; direction = EnumFacing.values()[direction.ordinal() + 1])
{
EnumFacing.Axis axis = direction.getAxis();
EnumFacing sideways = direction.rotateY();
for (int i = 1; i <= length; i++)
{
BlockPos pos1 = pos.offset(direction, i);
this.setLog(world, pos1, axis);
}
}
}
public void generateLeafLayer(World world, Random rand, BlockPos pos, int leafLayerNum)
{
//Repeat in intervals of 6, 2 small radius, 4 large
int index = leafLayerNum % 7;
int leavesRadius;
//Alternate between a smaller radius and a larger radius
if (index < 2) leavesRadius = 1;
else leavesRadius = 2;
//This may break for larger radii however it will do for this purpose
double increment = 0.05D;
for (int radius = leavesRadius; radius >= 0; radius--)
{
for (double angle = 0.0F; angle <= Math.PI * 2; angle += increment)
{
BlockPos leavesPos = pos.add(Math.round(radius * Math.cos(angle)), 0, Math.round(radius * Math.sin(angle)));
if (radius < leavesRadius || index < 2 || rand.nextInt(4) == 0)
this.setLeaves(world, leavesPos);
}
}
}
@Override
public boolean generate(World world, Random random, BlockPos pos)
{
// Move down until we reach the ground
while (pos.getY() > 1 && world.isAirBlock(pos) || world.getBlockState(pos).getBlock().isLeaves(world.getBlockState(pos), world, pos)) {pos = pos.down();}
// Choose heights
int height = GeneratorUtils.nextIntBetween(random, this.minHeight, this.maxHeight);
if (height < 20) {return false;}
// Move up to space above ground
pos = pos.up();
GeneratorSpike spikeGenerator = (new GeneratorSpike.Builder().with(this.log).replace(BlockQueries.anything).minRadius(2).maxRadius(2).minHeight(2).maxHeight(4).create());
// check that there's room and if the blocks below are suitable
if (!spikeGenerator.canPlaceHere(world, pos, height, 2)) {return false;}
//Generate the base of the tree
spikeGenerator.generate(world, random, pos);
BlockPos trunkTop = pos;
//Move upwards until the block above this is air
for (; !world.isAirBlock(trunkTop.up()); trunkTop = trunkTop.up())
{
if (trunkTop.getY() >= 255)
{
return false;
}
}
int baseHeight = trunkTop.getY() - pos.getY();
int trunkHeight = height - baseHeight;
//Generate the trunk to 1 block below the height
this.generateTrunk(world, random, pos, height - 1);
//Generate the layers of leaves
for (int i = 0; i < trunkHeight * 0.75F; i++)
{
this.generateLeafLayer(world, random, pos.up(height - i), i);
}
GeneratorBush bushGenerator = new GeneratorBush.Builder().amountPerChunk(2F).log(this.log).leaves(this.leaves).placeOn(this.log).maxHeight(2).create();
//Add bushes around the base
for (int i = 0; i < 10; i++)
{
bushGenerator.generate(world, random, pos.add(random.nextInt(5) - 5, baseHeight, random.nextInt(5) - 5));
}
return true;
}
@Override
public void configure(IConfigObj conf)
{
this.amountPerChunk = conf.getFloat("amountPerChunk", this.amountPerChunk);
this.minHeight = conf.getInt("minHeight", this.minHeight);
this.maxHeight = conf.getInt("minHeight", this.maxHeight);
this.placeOn = conf.getBlockPosQuery("placeOn", this.placeOn);
this.replace = conf.getBlockPosQuery("replace", this.replace);
this.log = conf.getBlockState("logState", this.log);
this.leaves = conf.getBlockState("leavesState", this.leaves);
}
}

2
src/main/resources/assets/biomesoplenty/advancements/biomesoplenty/all_biomes.json
View File

@ -13,7 +13,7 @@
"show_toast": true,
"announce_to_chat": true
},
"parent": "biomesoplenty:biomesoplenty/root",
"parent": "biomesoplenty:biomesoplenty/nether_biomes",
"criteria": {
"alps": {
"trigger": "minecraft:location",

56
src/main/resources/assets/biomesoplenty/advancements/biomesoplenty/beach_island_biomes.json Normal file
View File

@ -0,0 +1,56 @@
{
"display": {
"icon": {
"item": "biomesoplenty:sapling_1",
"data": 3
},
"title": {
"translate": "advancements.biomesoplenty.beach_island_biomes.title"
},
"description": {
"translate": "advancements.biomesoplenty.beach_island_biomes.description"
},
"frame": "goal",
"show_toast": true,
"announce_to_chat": true
},
"parent": "biomesoplenty:biomesoplenty/root",
"criteria": {
"origin_island": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:origin_island"
}
},
"tropical_island": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:tropical_island"
}
},
"volcanic_island": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:volcanic_island"
}
},
"gravel_beach": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:gravel_beach"
}
},
"white_beach": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:white_beach"
}
},
"origin_beach": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:origin_beach"
}
}
}
}

104
src/main/resources/assets/biomesoplenty/advancements/biomesoplenty/evergreen_biomes.json Normal file
View File

@ -0,0 +1,104 @@
{
"display": {
"icon": {
"item": "biomesoplenty:sapling_0",
"data": 4
},
"title": {
"translate": "advancements.biomesoplenty.evergreen_biomes.title"
},
"description": {
"translate": "advancements.biomesoplenty.evergreen_biomes.description"
},
"frame": "goal",
"show_toast": true,
"announce_to_chat": true
},
"parent": "biomesoplenty:biomesoplenty/root",
"criteria": {
"boreal_forest": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:boreal_forest"
}
},
"coniferous_forest": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:coniferous_forest"
}
},
"dead_forest": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:dead_forest"
}
},
"maple_woods": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:maple_woods"
}
},
"meadow": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:meadow"
}
},
"redwood_forest": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:redwood_forest"
}
},
"seasonal_forest": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:seasonal_forest"
}
},
"shield": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:shield"
}
},
"snowy_coniferous_forest": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:snowy_coniferous_forest"
}
},
"temperate_rainforest": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:temperate_rainforest"
}
},
"wetland": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:wetland"
}
},
"flower_meadow": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:flower_meadow"
}
},
"alps_foothills": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:alps_foothills"
}
},
"redwood_forest_edge": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:redwood_forest_edge"
}
}
}
}

32
src/main/resources/assets/biomesoplenty/advancements/biomesoplenty/magic_biomes.json Normal file
View File

@ -0,0 +1,32 @@
{
"display": {
"icon": {
"item": "biomesoplenty:flower_0",
"data": 9
},
"title": {
"translate": "advancements.biomesoplenty.magic_biomes.title"
},
"description": {
"translate": "advancements.biomesoplenty.magic_biomes.description"
},
"frame": "goal",
"show_toast": true,
"announce_to_chat": true
},
"parent": "biomesoplenty:biomesoplenty/beach_island_biomes",
"criteria": {
"mystic_grove": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:mystic_grove"
}
},
"ominous_woods": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:ominous_woods"
}
}
}
}

50
src/main/resources/assets/biomesoplenty/advancements/biomesoplenty/nether_biomes.json Normal file
View File

@ -0,0 +1,50 @@
{
"display": {
"icon": {
"item": "biomesoplenty:bramble_plant",
"data": 0
},
"title": {
"translate": "advancements.biomesoplenty.nether_biomes.title"
},
"description": {
"translate": "advancements.biomesoplenty.nether_biomes.description"
},
"frame": "goal",
"show_toast": true,
"announce_to_chat": true
},
"parent": "biomesoplenty:biomesoplenty/wasteland_biome",
"criteria": {
"corrupted_sands": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:corrupted_sands"
}
},
"fungi_forest": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:fungi_forest"
}
},
"phantasmagoric_inferno": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:phantasmagoric_inferno"
}
},
"undergarden": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:undergarden"
}
},
"visceral_heap": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:visceral_heap"
}
}
}
}

483
src/main/resources/assets/biomesoplenty/advancements/biomesoplenty/root.json
View File

@ -1,7 +1,7 @@
{
"display": {
"icon": {
"item": "biomesoplenty:flower_0",
"item": "biomesoplenty:grass",
"data": 0
},
"title": {
@ -14,43 +14,472 @@
"show_toast": false,
"announce_to_chat": false
},
"criteria": {
"red_flower": {
"trigger": "minecraft:inventory_changed",
"criteria": {
"alps": {
"trigger": "minecraft:location",
"conditions": {
"items": [
{
"item": "minecraft:red_flower"
}
]
"biome": "biomesoplenty:alps"
}
},
"yellow_flower": {
"trigger": "minecraft:inventory_changed",
"bayou": {
"trigger": "minecraft:location",
"conditions": {
"items": [
{
"item": "minecraft:yellow_flower"
}
]
"biome": "biomesoplenty:bayou"
}
},
"bop_flower_0": {
"trigger": "minecraft:inventory_changed",
"bog": {
"trigger": "minecraft:location",
"conditions": {
"items": [
{
"item": "biomesoplenty:flower_0"
}
]
"biome": "biomesoplenty:bog"
}
},
"boreal_forest": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:boreal_forest"
}
},
"brushland": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:brushland"
}
},
"chaparral": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:chaparral"
}
},
"cherry_blossom_grove": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:cherry_blossom_grove"
}
},
"cold_desert": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:cold_desert"
}
},
"coniferous_forest": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:coniferous_forest"
}
},
"crag": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:crag"
}
},
"dead_forest": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:dead_forest"
}
},
"dead_swamp": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:dead_swamp"
}
},
"fen": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:fen"
}
},
"floodplains": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:floodplains"
}
},
"grassland": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:grassland"
}
},
"grove": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:grove"
}
},
"highland": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:highland"
}
},
"lavender_fields": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:lavender_fields"
}
},
"lush_swamp": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:lush_swamp"
}
},
"maple_woods": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:maple_woods"
}
},
"marsh": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:marsh"
}
},
"meadow": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:meadow"
}
},
"mystic_grove": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:mystic_grove"
}
},
"ominous_woods": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:ominous_woods"
}
},
"orchard": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:orchard"
}
},
"outback": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:outback"
}
},
"overgrown_cliffs": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:overgrown_cliffs"
}
},
"prairie": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:prairie"
}
},
"rainforest": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:rainforest"
}
},
"redwood_forest": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:redwood_forest"
}
},
"scrubland": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:scrubland"
}
},
"seasonal_forest": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:seasonal_forest"
}
},
"shield": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:shield"
}
},
"shrubland": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:shrubland"
}
},
"snowy_coniferous_forest": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:snowy_coniferous_forest"
}
},
"snowy_forest": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:snowy_forest"
}
},
"steppe": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:steppe"
}
},
"temperate_rainforest": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:temperate_rainforest"
}
},
"tropical_rainforest": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:tropical_rainforest"
}
},
"tundra": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:tundra"
}
},
"wasteland": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:wasteland"
}
},
"wetland": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:wetland"
}
},
"woodland": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:woodland"
}
},
"xeric_shrubland": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:xeric_shrubland"
}
},
"origin_island": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:origin_island"
}
},
"tropical_island": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:tropical_island"
}
},
"volcanic_island": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:volcanic_island"
}
},
"coral_reef": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:coral_reef"
}
},
"kelp_forest": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:kelp_forest"
}
},
"cold_tundra": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:cold_tundra"
}
},
"dead_plains": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:dead_plains"
}
},
"flower_meadow": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:flower_meadow"
}
},
"highland_moor": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:highland_moor"
}
},
"mire": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:mire"
}
},
"oasis": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:oasis"
}
},
"pasture": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:pasture"
}
},
"gravel_beach": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:gravel_beach"
}
},
"white_beach": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:white_beach"
}
},
"origin_beach": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:origin_beach"
}
},
"alps_foothills": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:alps_foothills"
}
},
"redwood_forest_edge": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:redwood_forest_edge"
}
},
"corrupted_sands": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:corrupted_sands"
}
},
"fungi_forest": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:fungi_forest"
}
},
"phantasmagoric_inferno": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:phantasmagoric_inferno"
}
},
"undergarden": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:undergarden"
}
},
"visceral_heap": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:visceral_heap"
}
}
},
},
"requirements": [
[
"red_flower",
"yellow_flower",
"bop_flower_0"
"alps",
"bayou",
"bog",
"boreal_forest",
"brushland",
"chaparral",
"cherry_blossom_grove",
"cold_desert",
"coniferous_forest",
"crag",
"dead_forest",
"dead_swamp",
"fen",
"floodplains",
"grassland",
"grove",
"highland",
"lavender_fields",
"lush_swamp",
"maple_woods",
"marsh",
"meadow",
"mystic_grove",
"ominous_woods",
"orchard",
"outback",
"overgrown_cliffs",
"prairie",
"rainforest",
"redwood_forest",
"scrubland",
"seasonal_forest",
"shield",
"shrubland",
"snowy_coniferous_forest",
"snowy_forest",
"steppe",
"temperate_rainforest",
"tropical_rainforest",
"tundra",
"wasteland",
"wetland",
"woodland",
"xeric_shrubland",
"origin_island",
"tropical_island",
"volcanic_island",
"coral_reef",
"kelp_forest",
"cold_tundra",
"dead_plains",
"flower_meadow",
"highland_moor",
"mire",
"oasis",
"pasture",
"gravel_beach",
"origin_beach",
"white_beach",
"alps_foothills",
"redwood_forest_edge",
"corrupted_sands",
"fungi_forest",
"phantasmagoric_inferno",
"undergarden",
"visceral_heap"
]
]
}

74
src/main/resources/assets/biomesoplenty/advancements/biomesoplenty/swamp_biomes.json Normal file
View File

@ -0,0 +1,74 @@
{
"display": {
"icon": {
"item": "biomesoplenty:plant_0",
"data": 2
},
"title": {
"translate": "advancements.biomesoplenty.swamp_biomes.title"
},
"description": {
"translate": "advancements.biomesoplenty.swamp_biomes.description"
},
"frame": "goal",
"show_toast": true,
"announce_to_chat": true
},
"parent": "biomesoplenty:biomesoplenty/evergreen_biomes",
"criteria": {
"bayou": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:bayou"
}
},
"bog": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:bog"
}
},
"dead_swamp": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:dead_swamp"
}
},
"fen": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:fen"
}
},
"lush_swamp": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:lush_swamp"
}
},
"marsh": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:marsh"
}
},
"wetland": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:wetland"
}
},
"highland_moor": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:highland_moor"
}
},
"mire": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:mire"
}
}
}
}

26
src/main/resources/assets/biomesoplenty/advancements/biomesoplenty/wasteland_biome.json Normal file
View File

@ -0,0 +1,26 @@
{
"display": {
"icon": {
"item": "biomesoplenty:flower_0",
"data": 11
},
"title": {
"translate": "advancements.biomesoplenty.wasteland_biome.title"
},
"description": {
"translate": "advancements.biomesoplenty.wasteland_biome.description"
},
"frame": "goal",
"show_toast": true,
"announce_to_chat": true
},
"parent": "biomesoplenty:biomesoplenty/root",
"criteria": {
"wasteland": {
"trigger": "minecraft:location",
"conditions": {
"biome": "biomesoplenty:wasteland"
}
}
}
}

8
src/main/resources/assets/biomesoplenty/blockstates/foliage_0.json
View File

@ -3,13 +3,11 @@
"variant=shortgrass": { "model": "biomesoplenty:shortgrass" },
"variant=bush": { "model": "biomesoplenty:bush" },
"variant=berrybush": { "model": "biomesoplenty:berrybush" },
"variant=koru": { "model": "biomesoplenty:koru" },
"variant=devilweed": { "model": "biomesoplenty:devilweed" },
"variant=barley": { "model": "biomesoplenty:barley" },
"variant=dunegrass": { "model": "biomesoplenty:dunegrass" },
"variant=desertsprouts": { "model": "biomesoplenty:desertsprouts" },
"variant=desertgrass": { "model": "biomesoplenty:desertgrass" },
"variant=deadgrass": { "model": "biomesoplenty:deadgrass" },
"variant=spectralfern": { "model": "biomesoplenty:spectralfern" },
"variant=barley": { "model": "biomesoplenty:barley" }
"variant=devilweed": { "model": "biomesoplenty:devilweed" },
"variant=spectralfern": { "model": "biomesoplenty:spectralfern" }
}
}

18
src/main/resources/assets/biomesoplenty/lang/en_US.lang
View File

@ -1,5 +1,17 @@
advancements.biomesoplenty.root.title=Biomes O' Plenty
advancements.biomesoplenty.root.description=The explorer's dream...
advancements.biomesoplenty.evergreen_biomes.title=To the Key of Evergreen
advancements.biomesoplenty.evergreen_biomes.description=Discover all biomes with evergreen trees in Biomes O' Plenty
advancements.biomesoplenty.swamp_biomes.title=Swamp Fever
advancements.biomesoplenty.swamp_biomes.description=Discover all swampy biomes in Biomes O' Plenty
advancements.biomesoplenty.beach_island_biomes.title=Sail Away
advancements.biomesoplenty.beach_island_biomes.description=Discover all beach and island biomes in Biomes O' Plenty
advancements.biomesoplenty.magic_biomes.title=Yin and Yang
advancements.biomesoplenty.magic_biomes.description=Discover both magic biomes in Biomes O' Plenty
advancements.biomesoplenty.wasteland_biome.title=Wasteland
advancements.biomesoplenty.wasteland_biome.description=Discover the Wasteland biome in Biomes O' Plenty
advancements.biomesoplenty.nether_biomes.title=Nether
advancements.biomesoplenty.nether_biomes.description=Discover all Nether biomes in Biomes O' Plenty
advancements.biomesoplenty.all_biomes.title=Wanderer
advancements.biomesoplenty.all_biomes.description=Discover every biome in Biomes O' Plenty
@ -120,14 +132,12 @@ tile.flower_0.burning_blossom.name=Burning Blossom
tile.foliage_0.shortgrass.name=Short Grass
tile.foliage_0.bush.name=Bush
tile.foliage_0.berrybush.name=Berry Bush
tile.foliage_0.koru.name=Koru
tile.foliage_0.devilweed.name=Devilweed
tile.foliage_0.barley.name=Barley
tile.foliage_0.dunegrass.name=Dune Grass
tile.foliage_0.desertsprouts.name=Desert Sprouts
tile.foliage_0.desertgrass.name=Desert Grass
tile.foliage_0.deadgrass.name=Dead Grass
tile.foliage_0.devilweed.name=Devilweed
tile.foliage_0.spectralfern.name=Spectral Fern
tile.foliage_0.barley.name=Barley
tile.grass.origin_grass_block.name=Origin Grass Block
tile.grass.loamy_grass_block.name=Loamy Grass Block
tile.grass.sandy_grass_block.name=Sandy Grass Block

6
src/main/resources/assets/biomesoplenty/models/block/desertsprouts.json
View File

@ -1,6 +0,0 @@
{
"parent": "block/cross",
"textures": {
"cross": "biomesoplenty:blocks/desertsprouts"
}
}

6
src/main/resources/assets/biomesoplenty/models/block/koru.json
View File

@ -1,6 +0,0 @@
{
"parent": "block/tinted_cross",
"textures": {
"cross": "biomesoplenty:blocks/koru"
}
}

6
src/main/resources/assets/biomesoplenty/models/item/desertsprouts.json
View File

@ -1,6 +0,0 @@
{
"parent": "item/generated",
"textures": {
"layer0": "biomesoplenty:blocks/desertsprouts"
}
}

6
src/main/resources/assets/biomesoplenty/models/item/koru.json
View File

@ -1,6 +0,0 @@
{
"parent": "item/generated",
"textures": {
"layer0": "biomesoplenty:blocks/koru"
}
}

BIN
src/main/resources/assets/biomesoplenty/textures/blocks/desertsprouts.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 805 B

BIN
src/main/resources/assets/biomesoplenty/textures/blocks/koru.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 291 B