.

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;

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);
+}

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;
+	}
+}

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);
+}

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;
+	}
+}

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);
+	}
+}

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<OreGenBase> ORES_TO_GENERATE = new ArrayList<OreGenBase>();
+
+	/**
+	 * 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);
+			}
+
+		}
+	}
+}

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;
+	}
+}

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<ItemStack> curativeItems)
+	{
+		super(potionID, duration, amplifier);
+
+		if (curativeItems == null)
+		{
+			this.setCurativeItems(new ArrayList<ItemStack>());
+		}
+		else
+		{
+			this.setCurativeItems(curativeItems);
+		}
+	}
+}