diff --git a/src/minecraft/universalelectricity/prefab/BlockMachine.java b/src/minecraft/universalelectricity/prefab/BlockMachine.java index b0c6cb51..0134fb0f 100644 --- a/src/minecraft/universalelectricity/prefab/BlockMachine.java +++ b/src/minecraft/universalelectricity/prefab/BlockMachine.java @@ -205,7 +205,7 @@ public abstract class BlockMachine extends BlockContainer implements ISneakUseWr if (var7.hasTagCompound()) { - var12.getEntityItem().setTagCompound((NBTTagCompound) var7.getTagCompound().copy()); + var12.func_92014_d().setTagCompound((NBTTagCompound) var7.getTagCompound().copy()); } float var13 = 0.05F; diff --git a/src/minecraft/universalelectricity/prefab/modifier/IModifier.java b/src/minecraft/universalelectricity/prefab/modifier/IModifier.java new file mode 100644 index 00000000..dd0b49f4 --- /dev/null +++ b/src/minecraft/universalelectricity/prefab/modifier/IModifier.java @@ -0,0 +1,22 @@ +package universalelectricity.prefab.modifier; + +import net.minecraft.item.ItemStack; + +/** + * This must be applied to an item that acts as a modifier or an upgrade. + * + * @author Calclavia + * + */ +public interface IModifier +{ + /** + * @return - The name of the modifier. + */ + public String getName(ItemStack itemstack); + + /** + * @return - How much effect does this modifier have? + */ + public int getEffectiveness(ItemStack itemstack); +} diff --git a/src/minecraft/universalelectricity/prefab/modifier/SlotModifier.java b/src/minecraft/universalelectricity/prefab/modifier/SlotModifier.java new file mode 100644 index 00000000..f06b5b27 --- /dev/null +++ b/src/minecraft/universalelectricity/prefab/modifier/SlotModifier.java @@ -0,0 +1,29 @@ +package universalelectricity.prefab.modifier; + +import net.minecraft.inventory.IInventory; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; + +/** + * This slot should be used by any container that contains an item that is a modifier. An example of + * this would be upgrade slots. + * + * @author Calclavia + * + */ +public class SlotModifier extends Slot +{ + public SlotModifier(IInventory par2IInventory, int par3, int par4, int par5) + { + super(par2IInventory, par3, par4, par5); + } + + /** + * Check if the stack is a valid item for this slot. Always true beside for the armor slots. + */ + @Override + public boolean isItemValid(ItemStack par1ItemStack) + { + return par1ItemStack.getItem() instanceof IModifier; + } +} diff --git a/src/minecraft/universalelectricity/prefab/ore/OreGenBase.java b/src/minecraft/universalelectricity/prefab/ore/OreGenBase.java new file mode 100644 index 00000000..92faf394 --- /dev/null +++ b/src/minecraft/universalelectricity/prefab/ore/OreGenBase.java @@ -0,0 +1,99 @@ +package universalelectricity.prefab.ore; + +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.ORES_TO_GENERATE.add()} 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/minecraft/universalelectricity/prefab/ore/OreGenReplace.java b/src/minecraft/universalelectricity/prefab/ore/OreGenReplace.java new file mode 100644 index 00000000..e3e280ca --- /dev/null +++ b/src/minecraft/universalelectricity/prefab/ore/OreGenReplace.java @@ -0,0 +1,140 @@ +package universalelectricity.prefab.ore; + +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; + } + + 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 = (double) ((float) (par3 + 8) + MathHelper.sin(var6) * (float) this.amountPerBranch / 8.0F); + double var9 = (double) ((float) (par3 + 8) - MathHelper.sin(var6) * (float) this.amountPerBranch / 8.0F); + double var11 = (double) ((float) (par5 + 8) + MathHelper.cos(var6) * (float) this.amountPerBranch / 8.0F); + double var13 = (double) ((float) (par5 + 8) - MathHelper.cos(var6) * (float) this.amountPerBranch / 8.0F); + double var15 = (double) (par4 + par2Random.nextInt(3) - 2); + double var17 = (double) (par4 + par2Random.nextInt(3) - 2); + + for (int var19 = 0; var19 <= this.amountPerBranch; ++var19) + { + double var20 = var7 + (var9 - var7) * (double) var19 / (double) this.amountPerBranch; + double var22 = var15 + (var17 - var15) * (double) var19 / (double) this.amountPerBranch; + double var24 = var11 + (var13 - var11) * (double) var19 / (double) this.amountPerBranch; + double var26 = par2Random.nextDouble() * (double) this.amountPerBranch / 16.0D; + double var28 = (double) (MathHelper.sin((float) var19 * (float) Math.PI / (float) this.amountPerBranch) + 1.0F) * var26 + 1.0D; + double var30 = (double) (MathHelper.sin((float) var19 * (float) Math.PI / (float) 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 = ((double) var38 + 0.5D - var20) / (var28 / 2.0D); + + if (var39 * var39 < 1.0D) + { + for (int var41 = var33; var41 <= var36; ++var41) + { + double var42 = ((double) var41 + 0.5D - var22) / (var30 / 2.0D); + + if (var39 * var39 + var42 * var42 < 1.0D) + { + for (int var44 = var34; var44 <= var37; ++var44) + { + double var45 = ((double) 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.setBlockAndMetadata(var38, var41, var44, this.oreID, this.oreMeta); + } + } + } + } + } + } + } + + 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/minecraft/universalelectricity/prefab/ore/OreGenReplaceStone.java b/src/minecraft/universalelectricity/prefab/ore/OreGenReplaceStone.java new file mode 100644 index 00000000..151be2d4 --- /dev/null +++ b/src/minecraft/universalelectricity/prefab/ore/OreGenReplaceStone.java @@ -0,0 +1,17 @@ +package universalelectricity.prefab.ore; + +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/minecraft/universalelectricity/prefab/ore/OreGenerator.java b/src/minecraft/universalelectricity/prefab/ore/OreGenerator.java new file mode 100644 index 00000000..95e65601 --- /dev/null +++ b/src/minecraft/universalelectricity/prefab/ore/OreGenerator.java @@ -0,0 +1,75 @@ +package universalelectricity.prefab.ore; + +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); + } + + } + } +} diff --git a/src/minecraft/universalelectricity/prefab/potion/CustomPotion.java b/src/minecraft/universalelectricity/prefab/potion/CustomPotion.java new file mode 100644 index 00000000..11f6c865 --- /dev/null +++ b/src/minecraft/universalelectricity/prefab/potion/CustomPotion.java @@ -0,0 +1,37 @@ +package universalelectricity.prefab.potion; + +import net.minecraft.potion.Potion; +import cpw.mods.fml.common.registry.LanguageRegistry; + +public abstract class CustomPotion extends Potion +{ + /** + * Creates a new type of potion + * + * @param id - The ID of this potion. Make it greater than 20. + * @param isBadEffect - Is this potion a good potion or a bad one? + * @param color - The color of this potion. + * @param name - The name of this potion. + */ + public CustomPotion(int id, boolean isBadEffect, int color, String name) + { + super(id, isBadEffect, color); + this.setPotionName("potion." + name); + LanguageRegistry.instance().addStringLocalization(this.getName(), name); + } + + @Override + public Potion setIconIndex(int par1, int par2) + { + super.setIconIndex(par1, par2); + return this; + } + + /** + * You must register all your potion effects during mod initialization! + */ + public void register() + { + Potion.potionTypes[this.getId()] = this; + } +} diff --git a/src/minecraft/universalelectricity/prefab/potion/CustomPotionEffect.java b/src/minecraft/universalelectricity/prefab/potion/CustomPotionEffect.java new file mode 100644 index 00000000..788b623d --- /dev/null +++ b/src/minecraft/universalelectricity/prefab/potion/CustomPotionEffect.java @@ -0,0 +1,40 @@ +package universalelectricity.prefab.potion; + +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.item.ItemStack; +import net.minecraft.potion.Potion; +import net.minecraft.potion.PotionEffect; + +public class CustomPotionEffect extends PotionEffect +{ + public CustomPotionEffect(int potionID, int duration, int amplifier) + { + super(potionID, duration, amplifier); + } + + public CustomPotionEffect(Potion potion, int duration, int amplifier) + { + this(potion.getId(), duration, amplifier); + } + + /** + * Creates a potion effect with custom curable items. + * + * @param curativeItems - ItemStacks that can cure this potion effect + */ + public CustomPotionEffect(int potionID, int duration, int amplifier, List curativeItems) + { + super(potionID, duration, amplifier); + + if (curativeItems == null) + { + this.setCurativeItems(new ArrayList()); + } + else + { + this.setCurativeItems(curativeItems); + } + } +}