From e81b4354a666123feb95eb8b131eaf8d3f4f968e Mon Sep 17 00:00:00 2001 From: DarkGuardsman Date: Tue, 31 Dec 2013 12:35:46 -0500 Subject: [PATCH] Added world gen prefabs --- .../minecraft/worldgen/OreGenBase.java | 87 +++++++++++ .../minecraft/worldgen/OreGenReplace.java | 146 ++++++++++++++++++ .../worldgen/OreGenReplaceStone.java | 17 ++ .../minecraft/worldgen/OreGenerator.java | 70 +++++++++ 4 files changed, 320 insertions(+) create mode 100644 src/com/builtbroken/minecraft/worldgen/OreGenBase.java create mode 100644 src/com/builtbroken/minecraft/worldgen/OreGenReplace.java create mode 100644 src/com/builtbroken/minecraft/worldgen/OreGenReplaceStone.java create mode 100644 src/com/builtbroken/minecraft/worldgen/OreGenerator.java diff --git a/src/com/builtbroken/minecraft/worldgen/OreGenBase.java b/src/com/builtbroken/minecraft/worldgen/OreGenBase.java new file mode 100644 index 000000000..1db9bc8e8 --- /dev/null +++ b/src/com/builtbroken/minecraft/worldgen/OreGenBase.java @@ -0,0 +1,87 @@ +package com.builtbroken.minecraft.worldgen; + +import java.util.Random; + +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import net.minecraft.world.chunk.IChunkProvider; +import net.minecraftforge.common.Configuration; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.oredict.OreDictionary; +import cpw.mods.fml.common.FMLLog; + +/** This class is used for storing ore generation data. If you are too lazy to generate your own + * ores, you can do {@link #OreGenerator.addOre()} to add your ore to the list of ores to generate. + * + * @author Calclavia */ +public abstract class OreGenBase +{ + public String name; + + public String oreDictionaryName; + + public boolean shouldGenerate = false; + + public int blockIndexTexture; + + public ItemStack oreStack; + + public int oreID; + + public int oreMeta; + + /** What harvest level does this machine need to be acquired? */ + public int harvestLevel; + + /** The predefined tool classes are "pickaxe", "shovel", "axe". You can add others for custom + * tools. */ + public String harvestTool; + + /** @param name - The name of the ore for display + * @param textureFile - The 16x16 png texture of your ore to override + * @param minGenerateLevel - The highest generation level of your ore + * @param maxGenerateLevel - The lowest generation level of your ore + * @param amountPerChunk - The amount of ores to generate per chunk + * @param amountPerBranch - The amount of ores to generate in a clutter. E.g coal generates with + * a lot of other coal next to it. How much do you want? */ + public OreGenBase(String name, String oreDiectionaryName, ItemStack stack, String harvestTool, int harvestLevel) + { + if (stack != null) + { + this.name = name; + this.harvestTool = harvestTool; + this.harvestLevel = harvestLevel; + this.oreDictionaryName = oreDiectionaryName; + this.oreStack = stack; + this.oreID = stack.itemID; + this.oreMeta = stack.getItemDamage(); + + OreDictionary.registerOre(oreDictionaryName, stack); + MinecraftForge.setBlockHarvestLevel(Block.blocksList[stack.itemID], stack.getItemDamage(), harvestTool, harvestLevel); + } + else + { + FMLLog.severe("ItemStack is null while registering ore generation!"); + } + } + + public OreGenBase enable(Configuration config) + { + this.shouldGenerate = shouldGenerateOre(config, this.name); + return this; + } + + /** Checks the config file and see if Universal Electricity should generate this ore */ + private static boolean shouldGenerateOre(Configuration configuration, String oreName) + { + configuration.load(); + boolean shouldGenerate = configuration.get("Ore_Generation", "Generate " + oreName, true).getBoolean(true); + configuration.save(); + return shouldGenerate; + } + + public abstract void generate(World world, Random random, int varX, int varZ); + + public abstract boolean isOreGeneratedInWorld(World world, IChunkProvider chunkGenerator); +} diff --git a/src/com/builtbroken/minecraft/worldgen/OreGenReplace.java b/src/com/builtbroken/minecraft/worldgen/OreGenReplace.java new file mode 100644 index 000000000..55d47712e --- /dev/null +++ b/src/com/builtbroken/minecraft/worldgen/OreGenReplace.java @@ -0,0 +1,146 @@ +package com.builtbroken.minecraft.worldgen; + +import java.util.Random; + +import net.minecraft.item.ItemStack; +import net.minecraft.util.MathHelper; +import net.minecraft.world.World; +import net.minecraft.world.chunk.IChunkProvider; +import net.minecraft.world.gen.ChunkProviderEnd; +import net.minecraft.world.gen.ChunkProviderGenerate; +import net.minecraft.world.gen.ChunkProviderHell; + +/** This class is used for storing ore generation data. If you are too lazy to generate your own + * ores, you can do {@link #OreGenerator.ORES_TO_GENERATE.add()} to add your ore to the list of ores + * to generate. + * + * @author Calclavia */ +public class OreGenReplace extends OreGenBase +{ + + public int minGenerateLevel; + public int maxGenerateLevel; + public int amountPerChunk; + public int amountPerBranch; + public int replaceID; + + /** Dimensions to ignore ore generation */ + public boolean ignoreSurface = false; + public boolean ignoreNether = true; + public boolean ignoreEnd = true; + + /** @param name - The name of the ore for display + * @param textureFile - The 16x16 png texture of your ore to override + * @param minGenerateLevel - The highest generation level of your ore + * @param maxGenerateLevel - The lowest generation level of your ore + * @param amountPerChunk - The amount of ores to generate per chunk + * @param amountPerBranch - The amount of ores to generate in a clutter. E.g coal generates with + * a lot of other coal next to it. How much do you want? */ + public OreGenReplace(String name, String oreDiectionaryName, ItemStack stack, int replaceID, int minGenerateLevel, int maxGenerateLevel, int amountPerChunk, int amountPerBranch, String harvestTool, int harvestLevel) + { + super(name, oreDiectionaryName, stack, harvestTool, harvestLevel); + this.minGenerateLevel = minGenerateLevel; + this.maxGenerateLevel = maxGenerateLevel; + this.amountPerChunk = amountPerChunk; + this.amountPerBranch = amountPerBranch; + this.replaceID = replaceID; + } + + @Override + public void generate(World world, Random random, int varX, int varZ) + { + try + { + for (int i = 0; i < this.amountPerChunk; i++) + { + int x = varX + random.nextInt(16); + int z = varZ + random.nextInt(16); + int y = random.nextInt(Math.max(this.maxGenerateLevel - this.minGenerateLevel, 0)) + this.minGenerateLevel; + this.generateReplace(world, random, x, y, z); + } + } + catch (Exception e) + { + System.out.println("Error generating ore: " + this.name); + e.printStackTrace(); + } + } + + public boolean generateReplace(World par1World, Random par2Random, int par3, int par4, int par5) + { + float var6 = par2Random.nextFloat() * (float) Math.PI; + double var7 = par3 + 8 + MathHelper.sin(var6) * this.amountPerBranch / 8.0F; + double var9 = par3 + 8 - MathHelper.sin(var6) * this.amountPerBranch / 8.0F; + double var11 = par5 + 8 + MathHelper.cos(var6) * this.amountPerBranch / 8.0F; + double var13 = par5 + 8 - MathHelper.cos(var6) * this.amountPerBranch / 8.0F; + double var15 = par4 + par2Random.nextInt(3) - 2; + double var17 = par4 + par2Random.nextInt(3) - 2; + + for (int var19 = 0; var19 <= this.amountPerBranch; ++var19) + { + double var20 = var7 + (var9 - var7) * var19 / this.amountPerBranch; + double var22 = var15 + (var17 - var15) * var19 / this.amountPerBranch; + double var24 = var11 + (var13 - var11) * var19 / this.amountPerBranch; + double var26 = par2Random.nextDouble() * this.amountPerBranch / 16.0D; + double var28 = (MathHelper.sin(var19 * (float) Math.PI / this.amountPerBranch) + 1.0F) * var26 + 1.0D; + double var30 = (MathHelper.sin(var19 * (float) Math.PI / this.amountPerBranch) + 1.0F) * var26 + 1.0D; + int var32 = MathHelper.floor_double(var20 - var28 / 2.0D); + int var33 = MathHelper.floor_double(var22 - var30 / 2.0D); + int var34 = MathHelper.floor_double(var24 - var28 / 2.0D); + int var35 = MathHelper.floor_double(var20 + var28 / 2.0D); + int var36 = MathHelper.floor_double(var22 + var30 / 2.0D); + int var37 = MathHelper.floor_double(var24 + var28 / 2.0D); + + for (int var38 = var32; var38 <= var35; ++var38) + { + double var39 = (var38 + 0.5D - var20) / (var28 / 2.0D); + + if (var39 * var39 < 1.0D) + { + for (int var41 = var33; var41 <= var36; ++var41) + { + double var42 = (var41 + 0.5D - var22) / (var30 / 2.0D); + + if (var39 * var39 + var42 * var42 < 1.0D) + { + for (int var44 = var34; var44 <= var37; ++var44) + { + double var45 = (var44 + 0.5D - var24) / (var28 / 2.0D); + + int block = par1World.getBlockId(var38, var41, var44); + if (var39 * var39 + var42 * var42 + var45 * var45 < 1.0D && (this.replaceID == 0 || block == this.replaceID)) + { + par1World.setBlock(var38, var41, var44, this.oreID, this.oreMeta, 2); + } + } + } + } + } + } + } + + return true; + } + + @Override + public boolean isOreGeneratedInWorld(World world, IChunkProvider chunkGenerator) + { + if (!this.shouldGenerate) + { + return false; + } + if (this.ignoreSurface && chunkGenerator instanceof ChunkProviderGenerate) + { + return false; + } + if (this.ignoreNether && chunkGenerator instanceof ChunkProviderHell) + { + return false; + } + if (this.ignoreEnd && chunkGenerator instanceof ChunkProviderEnd) + { + return false; + } + return true; + } +} diff --git a/src/com/builtbroken/minecraft/worldgen/OreGenReplaceStone.java b/src/com/builtbroken/minecraft/worldgen/OreGenReplaceStone.java new file mode 100644 index 000000000..ce0ea686f --- /dev/null +++ b/src/com/builtbroken/minecraft/worldgen/OreGenReplaceStone.java @@ -0,0 +1,17 @@ +package com.builtbroken.minecraft.worldgen; + +import net.minecraft.item.ItemStack; + +public class OreGenReplaceStone extends OreGenReplace +{ + public OreGenReplaceStone(String name, String oreDiectionaryName, ItemStack stack, int minGenerateLevel, int maxGenerateLevel, int amountPerChunk, int amountPerBranch, String harvestTool, int harvestLevel) + { + super(name, oreDiectionaryName, stack, 1, minGenerateLevel, maxGenerateLevel, amountPerChunk, amountPerBranch, harvestTool, harvestLevel); + } + + // A simplified version of the constructor + public OreGenReplaceStone(String name, String oreDiectionaryName, ItemStack stack, int maxGenerateLevel, int amountPerChunk, int amountPerBranch) + { + this(name, oreDiectionaryName, stack, 0, maxGenerateLevel, amountPerChunk, amountPerBranch, "pickaxe", 1); + } +} diff --git a/src/com/builtbroken/minecraft/worldgen/OreGenerator.java b/src/com/builtbroken/minecraft/worldgen/OreGenerator.java new file mode 100644 index 000000000..1aa1290f8 --- /dev/null +++ b/src/com/builtbroken/minecraft/worldgen/OreGenerator.java @@ -0,0 +1,70 @@ +package com.builtbroken.minecraft.worldgen; + +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +import net.minecraft.world.World; +import net.minecraft.world.chunk.IChunkProvider; +import cpw.mods.fml.common.IWorldGenerator; +import cpw.mods.fml.common.registry.GameRegistry; + +public class OreGenerator implements IWorldGenerator +{ + public static boolean isInitiated = false; + + /** Add your ore data to this list of ores for it to automatically generate! No hassle indeed! */ + private static final List ORES_TO_GENERATE = new ArrayList(); + + /** Adds an ore to the ore generate list. Do this in pre-init. */ + public static void addOre(OreGenBase data) + { + if (!isInitiated) + { + GameRegistry.registerWorldGenerator(new OreGenerator()); + } + + ORES_TO_GENERATE.add(data); + } + + /** Checks to see if this ore + * + * @param oreName + * @return */ + public static boolean oreExists(String oreName) + { + for (OreGenBase ore : ORES_TO_GENERATE) + { + if (ore.oreDictionaryName == oreName) + { + return true; + } + } + + return false; + } + + /** Removes an ore to the ore generate list. Do this in init. */ + public static void removeOre(OreGenBase data) + { + ORES_TO_GENERATE.remove(data); + } + + @Override + public void generate(Random rand, int chunkX, int chunkZ, World world, IChunkProvider chunkGenerator, IChunkProvider chunkProvider) + { + chunkX = chunkX << 4; + chunkZ = chunkZ << 4; + + // Checks to make sure this is the normal + // world + for (OreGenBase oreData : ORES_TO_GENERATE) + { + if (oreData.shouldGenerate && oreData.isOreGeneratedInWorld(world, chunkGenerator)) + { + oreData.generate(world, rand, chunkX, chunkZ); + } + + } + } +}