v4.3 Beta #1

*Updated mcmod.info.
*Removed PlatinumCable both physically and code-ly.
*Completely refactored TileEntity hierarchy *again* to make code more
efficient.
*Fixed container bug.
*Fixed GUI text not rendering.
*Added missing javadocs.
*Removed unused and unneeded code.
*Added Generator base for making Obsidian Ingots generators.
*Added Heat Generator, a block that generates energy with heat.
*Doubled Platinum Ore generation.
*Fixed energy devices to only have a max damage of 100.
*Fixed energy devices not working in SMP.
*Updated ITileNetwork with new packet changes.
*Other various bugfixes.

mcmod.info

@@ -3,8 +3,8 @@
   "modid": "ObsidianIngots",
   "name": "Obsidian Ingots",
   "description": "Energy, Armor, Tools, Weapons, Machines, Magic.",
-  "version": "4.2.2",
-  "mcversion": "1.3.2",
+  "version": "4.3",
+  "mcversion": "1.4.2",
   "updateUrl": "",
   "authors": [
     "aidancbrady"

src/common/net/uberkat/obsidian/common/BlockGenerator.java

@@ -0,0 +1,226 @@
+package net.uberkat.obsidian.common;
+
+import java.util.List;
+import java.util.Random;
+
+import cpw.mods.fml.common.Side;
+import cpw.mods.fml.common.asm.SideOnly;
+import net.minecraft.src.*;
+import net.minecraftforge.common.ForgeDirection;
+import net.uberkat.obsidian.common.BlockMachine.MachineType;
+
+public class BlockGenerator extends BlockContainer
+{
+	public Random machineRand = new Random();
+	
+	public BlockGenerator(int id)
+	{
+		super(id, Material.iron);
+		setHardness(3.5F);
+		setResistance(8F);
+		setCreativeTab(CreativeTabs.tabDecorations);
+		setRequiresSelfNotify();
+	}
+	
+    public void onBlockPlacedBy(World world, int x, int y, int z, EntityLiving entityliving)
+    {
+    	TileEntityGenerator tileEntity = (TileEntityGenerator)world.getBlockTileEntity(x, y, z);
+        int side = MathHelper.floor_double((double)(entityliving.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;
+        int change = 3;
+        
+        switch(side)
+        {
+        	case 0: change = 2; break;
+        	case 1: change = 5; break;
+        	case 2: change = 3; break;
+        	case 3: change = 4; break;
+        }
+        
+        tileEntity.setFacing((short)change);
+    }
+    
+    public int getBlockTextureFromSideAndMetadata(int side, int meta)
+    {
+    	if(meta == 0)
+    	{
+    		if(side == 3)
+    		{
+    			return 27;
+    		}
+    		else if(side != 0 && side != 1)
+        	{
+        		return 25;
+        	}
+        	else {
+        		return 26;
+        	}
+    	}
+    	else {
+    		return 0;
+    	}
+    }
+    
+    @SideOnly(Side.CLIENT)
+    public int getBlockTexture(IBlockAccess world, int x, int y, int z, int side)
+    {
+    	int metadata = world.getBlockMetadata(x, y, z);
+    	TileEntityGenerator tileEntity = (TileEntityGenerator)world.getBlockTileEntity(x, y, z);
+        
+    	if(metadata == 0)
+    	{
+	        if(side == tileEntity.facing)
+	        {
+	        	return 27;
+	        }
+	        else if(side != 0 && side != 1)
+	        {
+	        	return 25;
+	        }
+	        else {
+	        	return 26;
+	        }
+    	}
+    	else {
+    		return 0;
+    	}
+    }
+    
+    public int damageDropped(int i)
+    {
+    	return i;
+    }
+    
+	@SideOnly(Side.CLIENT)
+	public void getSubBlocks(int i, CreativeTabs creativetabs, List list)
+	{
+		list.add(new ItemStack(i, 1, 0));
+	}
+    
+	/**
+	 * Checks if a generator is operating.
+	 * @param world
+	 * @param x
+	 * @param y
+	 * @param z
+	 * @return if generator is operating
+	 */
+    public boolean isActive(IBlockAccess world, int x, int y, int z)
+    {
+    	TileEntityGenerator tileEntity = (TileEntityGenerator)world.getBlockTileEntity(x, y, z);
+    	if(tileEntity != null)
+    	{
+    		return tileEntity.canPower();
+    	}
+    	return false;
+    }
+    
+    public void breakBlock(World world, int x, int y, int z, int i1, int i2)
+    {
+        TileEntityGenerator tileEntity = (TileEntityGenerator)world.getBlockTileEntity(x, y, z);
+
+        if (tileEntity != null)
+        {
+            for (int i = 0; i < tileEntity.getSizeInventory(); ++i)
+            {
+                ItemStack slotStack = tileEntity.getStackInSlot(i);
+
+                if (slotStack != null)
+                {
+                    float xRandom = machineRand.nextFloat() * 0.8F + 0.1F;
+                    float yRandom = machineRand.nextFloat() * 0.8F + 0.1F;
+                    float zRandom = machineRand.nextFloat() * 0.8F + 0.1F;
+
+                    while (slotStack.stackSize > 0)
+                    {
+                        int j = machineRand.nextInt(21) + 10;
+
+                        if (j > slotStack.stackSize)
+                        {
+                            j = slotStack.stackSize;
+                        }
+
+                        slotStack.stackSize -= j;
+                        EntityItem item = new EntityItem(world, (double)((float)x + xRandom), (double)((float)y + yRandom), (double)((float)z + zRandom), new ItemStack(slotStack.itemID, j, slotStack.getItemDamage()));
+
+                        if (slotStack.hasTagCompound())
+                        {
+                            item.item.setTagCompound((NBTTagCompound)slotStack.getTagCompound().copy());
+                        }
+
+                        float k = 0.05F;
+                        item.motionX = (double)((float)machineRand.nextGaussian() * k);
+                        item.motionY = (double)((float)machineRand.nextGaussian() * k + 0.2F);
+                        item.motionZ = (double)((float)machineRand.nextGaussian() * k);
+                        world.spawnEntityInWorld(item);
+                    }
+                }
+            }
+            tileEntity.invalidate();
+        }
+	        
+    	super.breakBlock(world, x, y, z, i1, i2);
+    }
+    
+    public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer entityplayer, int facing, float playerX, float playerY, float playerZ)
+    {
+        if (world.isRemote)
+        {
+            return true;
+        }
+        else
+        {
+        	TileEntityGenerator tileEntity = (TileEntityGenerator)world.getBlockTileEntity(x, y, z);
+        	int metadata = world.getBlockMetadata(x, y, z);
+        	
+            if (tileEntity != null)
+            {
+            	if(!entityplayer.isSneaking())
+            	{
+            		int id = 0;
+            		
+            		if(metadata == 0) id = 9;
+            		
+            		entityplayer.openGui(ObsidianIngots.instance, id, world, x, y, z);
+            	}
+            	else {
+            		return false;
+            	}
+            }
+            return true;
+        }
+    }
+    
+    public String getTextureFile()
+    {
+    	return "/textures/terrain.png";
+    }
+    
+    public TileEntity createNewTileEntity(World world, int metadata)
+    {
+    	if(metadata == MachineType.HEAT_GENERATOR.index)
+    	{
+    		return new TileEntityHeatGenerator();
+    	}
+    	else {
+    		return null;
+    	}
+    }
+	
+    /*This method is not used, metadata manipulation is required to create a Tile Entity.*/
+	public TileEntity createNewTileEntity(World world)
+	{
+		return null;
+	}
+	
+	public static enum MachineType
+	{
+		HEAT_GENERATOR(0);
+		
+		private int index;
+		
+		private MachineType(int i)
+		{
+			index = i;
+		}
+	}
+}

src/common/net/uberkat/obsidian/common/CommonProxy.java

@@ -55,6 +55,7 @@ public class CommonProxy
 		ObsidianIngots.oreBlockID = ObsidianIngots.configuration.getBlock("OreBlock", 3002).getInt();
 	  	ObsidianIngots.obsidianTNTID = ObsidianIngots.configuration.getBlock("ObsidianTNT", 3003).getInt();
 	  	ObsidianIngots.powerUnitID = ObsidianIngots.configuration.getBlock("PowerUnit", 3004).getInt();
+	  	ObsidianIngots.generatorID = ObsidianIngots.configuration.getBlock("Generator", 3005).getInt();
 	  	ObsidianIngots.extrasEnabled = ObsidianIngots.configuration.get("ExtrasEnabled", Configuration.CATEGORY_GENERAL, true).getBoolean(true);
 	  	ObsidianIngots.oreGenerationEnabled = ObsidianIngots.configuration.get("OreGenerationEnabled", Configuration.CATEGORY_GENERAL, true).getBoolean(true);
 	  	ObsidianIngots.configuration.save();
@@ -117,6 +118,9 @@ public class CommonProxy
 			case 8:
 				TileEntityPowerUnit tileentity5 = (TileEntityPowerUnit)world.getBlockTileEntity(x, y, z);
 				return new ContainerPowerUnit(player.inventory, tileentity5);
+			case 9:
+				TileEntityGenerator tileentity6 = (TileEntityGenerator)world.getBlockTileEntity(x, y, z);
+				return new ContainerGenerator(player.inventory, tileentity6);
 		}
 		return null;
 	}

src/common/net/uberkat/obsidian/common/ContainerAdvancedElectricMachine.java

@@ -42,7 +42,7 @@ public class ContainerAdvancedElectricMachine extends Container
     /**
      * Called to transfer a stack from one inventory to the other eg. when shift clicking.
      */
-    public ItemStack transferStackInSlot(int slotID)
+    public ItemStack func_82846_b(EntityPlayer player, int slotID)
     {
         ItemStack stack = null;
         Slot currentSlot = (Slot)inventorySlots.get(slotID);
@@ -165,7 +165,7 @@ public class ContainerAdvancedElectricMachine extends Container
                 return null;
             }
 
-            currentSlot.putStack(slotStack);
+            currentSlot.func_82870_a(player, slotStack);
         }
 
         return stack;

src/common/net/uberkat/obsidian/common/ContainerElectricMachine.java

@@ -41,7 +41,7 @@ public class ContainerElectricMachine extends Container
     /**
      * Called to transfer a stack from one inventory to the other eg. when shift clicking.
      */
-    public ItemStack transferStackInSlot(int slotID)
+    public ItemStack func_82846_b(EntityPlayer player, int slotID)
     {
         ItemStack stack = null;
         Slot currentSlot = (Slot)inventorySlots.get(slotID);
@@ -122,7 +122,7 @@ public class ContainerElectricMachine extends Container
                 return null;
             }
 
-            currentSlot.putStack(slotStack);
+            currentSlot.func_82870_a(player, slotStack);
         }
 
         return stack;

src/common/net/uberkat/obsidian/common/ContainerGenerator.java

@@ -0,0 +1,105 @@
+package net.uberkat.obsidian.common;
+
+import ic2.api.IElectricItem;
+import obsidian.api.IEnergizedItem;
+import obsidian.api.IMachineUpgrade;
+import universalelectricity.implement.IItemElectric;
+import net.minecraft.src.*;
+
+public class ContainerGenerator extends Container
+{
+    private TileEntityGenerator tileEntity;
+
+    public ContainerGenerator(InventoryPlayer inventory, TileEntityGenerator tentity)
+    {
+        tileEntity = tentity;
+        addSlotToContainer(new Slot(tentity, 0, 17, 35));
+        addSlotToContainer(new SlotEnergy(tentity, 1, 143, 35));
+        int slotX;
+
+        for (slotX = 0; slotX < 3; ++slotX)
+        {
+            for (int slotY = 0; slotY < 9; ++slotY)
+            {
+                addSlotToContainer(new Slot(inventory, slotY + slotX * 9 + 9, 8 + slotY * 18, 84 + slotX * 18));
+            }
+        }
+
+        for (slotX = 0; slotX < 9; ++slotX)
+        {
+            addSlotToContainer(new Slot(inventory, slotX, 8 + slotX * 18, 142));
+        }
+    }
+
+    public boolean canInteractWith(EntityPlayer par1EntityPlayer)
+    {
+        return tileEntity.isUseableByPlayer(par1EntityPlayer);
+    }
+
+    /**
+     * Called to transfer a stack from one inventory to the other eg. when shift clicking.
+     */
+    public ItemStack func_82846_b(EntityPlayer player, int slotID)
+    {
+        ItemStack stack = null;
+        Slot currentSlot = (Slot)inventorySlots.get(slotID);
+
+        if(currentSlot != null && currentSlot.getHasStack())
+        {
+            ItemStack slotStack = currentSlot.getStack();
+            stack = slotStack.copy();
+            
+        	if(slotStack.getItem() instanceof IEnergizedItem || slotStack.getItem() instanceof IItemElectric || slotStack.getItem() instanceof IElectricItem || slotStack.itemID == Item.redstone.shiftedIndex)
+            {
+	            if(slotID != 1)
+	            {
+	                if (!mergeItemStack(slotStack, 1, 2, false))
+	                {
+	                	return null;
+	                }
+	            }
+	            else if(slotID == 1)
+	            {
+	            	if(!mergeItemStack(slotStack, 2, inventorySlots.size(), false))
+	            	{
+	            		return null;
+	            	}
+	            }
+            }
+        	else if(tileEntity.getFuel(slotStack) > 0)
+        	{
+            	if(slotID != 0 && slotID != 1)
+            	{
+                    if (!mergeItemStack(slotStack, 0, 1, false))
+	                {
+	                    return null;
+	                }
+            	}
+            	else {
+	            	if(!mergeItemStack(slotStack, 2, inventorySlots.size(), true))
+	            	{
+	            		return null;
+	            	}
+            	}
+        	}
+            
+            if (slotStack.stackSize == 0)
+            {
+                currentSlot.putStack((ItemStack)null);
+            }
+            else
+            {
+                currentSlot.onSlotChanged();
+            }
+
+            if (slotStack.stackSize == stack.stackSize)
+            {
+                return null;
+            }
+
+            currentSlot.func_82870_a(player, slotStack);
+        }
+
+        return stack;
+    }
+}

src/common/net/uberkat/obsidian/common/ContainerPowerUnit.java

@@ -36,7 +36,7 @@ public class ContainerPowerUnit extends Container
         return tileEntity.isUseableByPlayer(par1EntityPlayer);
     }
     
-    public ItemStack transferStackInSlot(int slotID)
+    public ItemStack func_82846_b(EntityPlayer player, int slotID)
     {
         ItemStack stack = null;
         Slot currentSlot = (Slot)inventorySlots.get(slotID);
@@ -91,7 +91,7 @@ public class ContainerPowerUnit extends Container
                 return null;
             }
 
-            currentSlot.putStack(slotStack);
+            currentSlot.func_82870_a(player, slotStack);
         }
 
         return stack;

src/common/net/uberkat/obsidian/common/ItemBlockGenerator.java

@@ -0,0 +1,46 @@
+package net.uberkat.obsidian.common;
+
+import net.minecraft.src.*;
+
+/**
+ * Item class for handling multiple generator block IDs.
+ * 0: Heat Generator
+ * @author AidanBrady
+ *
+ */
+public class ItemBlockGenerator extends ItemBlock
+{
+	public Block metaBlock;
+	
+	public ItemBlockGenerator(int id, Block block)
+	{
+		super(id);
+		metaBlock = block;
+		setHasSubtypes(true);
+	}
+	
+	public int getMetadata(int i)
+	{
+		return i;
+	}
+	
+	public int getIconFromDamage(int i)
+	{
+		return metaBlock.getBlockTextureFromSideAndMetadata(2, i);
+	}
+	
+	public String getItemNameIS(ItemStack itemstack)
+	{
+		String name = "";
+		switch(itemstack.getItemDamage())
+		{
+			case 0:
+				name = "HeatGenerator";
+				break;
+			default:
+				name = "Unknown";
+				break;
+		}
+		return getItemName() + "." + name;
+	}
+}

src/common/net/uberkat/obsidian/common/ItemEnergized.java

@@ -17,13 +17,16 @@ public class ItemEnergized extends ItemObsidian implements IEnergizedItem, IItem
 	
 	public int transferRate;
 	
-	public ItemEnergized(int id, int energy, int rate)
+	public int divider;
+	
+	public ItemEnergized(int id, int energy, int rate, int divide)
 	{
 		super(id);
+		divider = divide;
 		maxEnergy = energy;
 		transferRate = rate;
 		setMaxStackSize(1);
-		setMaxDamage(maxEnergy);
+		setMaxDamage(maxEnergy/divider);
 		setNoRepair();
 		setCreativeTab(CreativeTabs.tabRedstone);
 	}
@@ -60,7 +63,7 @@ public class ItemEnergized extends ItemObsidian implements IEnergizedItem, IItem
 			stored = itemstack.stackTagCompound.getInteger("energy");
 		}
 		
-		itemstack.setItemDamage(maxEnergy - stored);
+		itemstack.setItemDamage((maxEnergy - stored)/divider);
 		return stored;
 	}
 	
@@ -73,20 +76,20 @@ public class ItemEnergized extends ItemObsidian implements IEnergizedItem, IItem
 		
 		int stored = Math.max(Math.min(energy, maxEnergy), 0);
 		itemstack.stackTagCompound.setInteger("energy", stored);
-        itemstack.setItemDamage(maxEnergy - stored);
+        itemstack.setItemDamage((maxEnergy - stored)/divider);
 	}
 	
 	public ItemStack getUnchargedItem()
 	{
 		ItemStack charged = new ItemStack(this);
-		charged.setItemDamage(maxEnergy);
+		charged.setItemDamage(maxEnergy/divider);
 		return charged;
 	}
 	
 	public void getSubItems(int i, CreativeTabs tabs, List list)
 	{
 		ItemStack discharged = new ItemStack(this);
-		discharged.setItemDamage(maxEnergy);
+		discharged.setItemDamage(maxEnergy/divider);
 		list.add(discharged);
 		ItemStack charged = new ItemStack(this);
 		setEnergy(charged, ((IEnergizedItem)charged.getItem()).getMaxEnergy());
@@ -170,4 +173,9 @@ public class ItemEnergized extends ItemObsidian implements IEnergizedItem, IItem
 	{
 		return true;
 	}
+	
+	public int getDivider()
+	{
+		return divider;
+	}
 }

src/common/net/uberkat/obsidian/common/ObsidianIngots.java

@@ -39,7 +39,7 @@ import cpw.mods.fml.common.registry.TickRegistry;
  * @author AidanBrady
  *
  */
-@Mod(modid = "ObsidianIngots", name = "Obsidian Ingots", version = "4.2.3")
+@Mod(modid = "ObsidianIngots", name = "Obsidian Ingots", version = "4.2.4")
 @NetworkMod(channels = { "ObsidianIngots" }, clientSideRequired = true, serverSideRequired = false, packetHandler = PacketHandler.class)
 public class ObsidianIngots
 {
@@ -61,7 +61,7 @@ public class ObsidianIngots
     public static Configuration configuration;
     
 	/** Obsidian Ingots version number */
-	public static Version versionNumber = new Version(4, 2, 3);
+	public static Version versionNumber = new Version(4, 2, 4);
 	
 	/** The latest version number which is received from the Obsidian Ingots server */
 	public static String latestVersionNumber;
@@ -106,6 +106,7 @@ public class ObsidianIngots
     public static int oreBlockID = 3002;
 	public static int obsidianTNTID = 3003;
 	public static int powerUnitID = 3004;
+	public static int generatorID = 3005;
 	
 	//Base Items
 	public static Item WoodPaxel;
@@ -211,6 +212,7 @@ public class ObsidianIngots
 	public static Block OreBlock;
 	public static Block ObsidianTNT;
 	public static Block PowerUnit;
+	public static Block Generator;
 	
 	//Boolean Values
 	public static boolean extrasEnabled = true;
@@ -674,6 +676,9 @@ public class ObsidianIngots
 		LanguageRegistry.instance().addStringLocalization("tile.PowerUnit.PowerUnit.name", "Power Unit");
 		LanguageRegistry.instance().addStringLocalization("tile.PowerUnit.AdvancedPowerUnit.name", "Advanced Power Unit");
 		
+		//Localization for Generator
+		LanguageRegistry.instance().addStringLocalization("tile.Generator.HeatGenerator.name", "Heat Generator");
+		
 		if(extrasEnabled == true)
 		{
 			LanguageRegistry.instance().addStringLocalization("tile.MachineBlock.TheoreticalElementizer.name", "Theoretical Elementizer");
@@ -870,9 +875,9 @@ public class ObsidianIngots
 		GlowstoneLegs = new ItemObsidianArmor(11310, armorGLOWSTONE, proxy.getArmorIndex("glowstone"), 2).setItemName("GlowstoneLegs");
 		GlowstoneBoots = new ItemObsidianArmor(11311, armorGLOWSTONE, proxy.getArmorIndex("glowstone"), 3).setItemName("GlowstoneBoots");
 		GlowstoneKnife = new ItemObsidianKnife(11312, toolGLOWSTONE).setItemName("GlowstoneKnife");
-		EnergyTablet = (ItemEnergized) new ItemEnergized(11314, 50000, 100).setItemName("EnergyTablet");
-		EnergyOrb = (ItemEnergized) new ItemEnergized(11315, 15000000, 1000).setItemName("EnergyOrb");
-		EnergyCube = (ItemEnergized) new ItemEnergized(11316, 12000, 100).setItemName("EnergyCube");
+		EnergyTablet = (ItemEnergized) new ItemEnergized(11314, 50000, 100, 500).setItemName("EnergyTablet");
+		EnergyOrb = (ItemEnergized) new ItemEnergized(11315, 15000000, 1000, 150000).setItemName("EnergyOrb");
+		EnergyCube = (ItemEnergized) new ItemEnergized(11316, 12000, 100, 120).setItemName("EnergyCube");
 		SpeedUpgrade = new ItemMachineUpgrade(11317).setItemName("SpeedUpgrade");
 		EnergyUpgrade = new ItemMachineUpgrade(11318).setItemName("EnergyUpgrade");
 		UltimateUpgrade = new ItemMachineUpgrade(11319).setItemName("UltimateUpgrade");
@@ -888,6 +893,7 @@ public class ObsidianIngots
 		MachineBlock = new BlockMachine(machineBlockID).setBlockName("MachineBlock");
 		OreBlock = new BlockOre(oreBlockID).setBlockName("OreBlock");
 		PowerUnit = new BlockPowerUnit(powerUnitID).setBlockName("PowerUnit");
+		Generator = new BlockGenerator(generatorID).setBlockName("Generator");
 		ObsidianTNT = new BlockObsidianTNT(obsidianTNTID).setBlockName("ObsidianTNT").setCreativeTab(CreativeTabs.tabRedstone);
 		
 		//Registrations
@@ -898,6 +904,7 @@ public class ObsidianIngots
 		Item.itemsList[machineBlockID] = new ItemBlockMachine(machineBlockID - 256, MachineBlock).setItemName("MachineBlock");
 		Item.itemsList[oreBlockID] = new ItemBlockOre(oreBlockID - 256, OreBlock).setItemName("OreBlock");
 		Item.itemsList[powerUnitID] = new ItemBlockPowerUnit(powerUnitID - 256, PowerUnit).setItemName("PowerUnit");
+		Item.itemsList[generatorID] = new ItemBlockGenerator(generatorID - 256, Generator).setItemName("Generator");
 	}
 	
 	/**
@@ -971,6 +978,7 @@ public class ObsidianIngots
 		GameRegistry.registerTileEntity(TileEntityTheoreticalElementizer.class, "TheoreticalElementizer");
 		GameRegistry.registerTileEntity(TileEntityPowerUnit.class, "PowerUnit");
 		GameRegistry.registerTileEntity(TileEntityAdvancedPowerUnit.class, "AdvancedPowerUnit");
+		GameRegistry.registerTileEntity(TileEntityHeatGenerator.class, "HeatGenerator");
 	}
 	
 	/**

src/common/net/uberkat/obsidian/common/OreHandler.java

@@ -1,5 +1,7 @@
 package net.uberkat.obsidian.common;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Random;
 
 import net.minecraft.src.IChunkProvider;
@@ -9,7 +11,7 @@ import net.minecraft.src.WorldGenMinable;
 import cpw.mods.fml.common.IWorldGenerator;
 
 public class OreHandler implements IWorldGenerator
-{
+{	
 	public void generate(Random random, int chunkX, int chunkZ, World world, IChunkProvider chunkGenerator, IChunkProvider chunkProvider) 
 	{
 		switch(world.provider.dimensionId)
@@ -30,7 +32,7 @@ public class OreHandler implements IWorldGenerator
 	{
 		if(ObsidianIngots.oreGenerationEnabled == true)
 		{
-			for (int i=0;i<3;i++)
+			for (int i=0;i<6;i++)
 			{
 				int randPosX = chunkX + random.nextInt(16);
 				int randPosY = random.nextInt(60);

src/common/net/uberkat/obsidian/common/PacketHandler.java

@@ -316,6 +316,74 @@ public class PacketHandler implements IPacketHandler
         PacketDispatcher.sendPacketToAllAround(sender.xCoord, sender.yCoord, sender.zCoord, distance, sender.worldObj.provider.dimensionId, packet);
 	}
 	
+	/**
+	 * Send a generator packet from server to client. This will send the data int '4,' as well as the machine's x, y, and z
+	 * coordinates, along with it's facing, energy stored, and fuel stored.
+	 * @param sender - tile entity who is sending the packet
+	 */
+	public static void sendGeneratorPacket(TileEntityGenerator sender)
+	{
+		ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+        DataOutputStream output = new DataOutputStream(bytes);
+        
+        try {
+        	output.writeInt(EnumPacketType.TILE_ENTITY.id);
+        	output.writeInt(sender.xCoord);
+        	output.writeInt(sender.yCoord);
+        	output.writeInt(sender.zCoord);
+        	output.writeInt(sender.facing);
+        	output.writeInt(sender.energyStored);
+        	output.writeInt(sender.fuelStored);
+        } catch (IOException e)
+        {
+        	System.err.println("[ObsidianIngots] Error while writing tile entity packet.");
+        	e.printStackTrace();
+        }
+        
+        Packet250CustomPayload packet = new Packet250CustomPayload();
+        packet.channel = "ObsidianIngots";
+        packet.data = bytes.toByteArray();
+        packet.length = packet.data.length;
+        
+        if(FMLCommonHandler.instance().getMinecraftServerInstance() != null)
+        {
+        	FMLCommonHandler.instance().getMinecraftServerInstance().getConfigurationManager().sendPacketToAllPlayers(packet);
+        }
+	}
+	
+	/**
+	 * Send a generator packet from server to client with a defined range. This will send the data int '4,' as well as 
+	 * the machine's x, y, and z coordinates, along with it's facing, energy stored, and fuel stored.
+	 * @param sender - tile entity who is sending the packet
+	 * @param distance - radius to send packet in
+	 */
+	public static void sendGeneratorPacketWithRange(TileEntityGenerator sender, double distance)
+	{
+		ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+        DataOutputStream output = new DataOutputStream(bytes);
+        
+        try {
+        	output.writeInt(EnumPacketType.TILE_ENTITY.id);
+        	output.writeInt(sender.xCoord);
+        	output.writeInt(sender.yCoord);
+        	output.writeInt(sender.zCoord);
+        	output.writeInt(sender.facing);
+        	output.writeInt(sender.energyStored);
+        	output.writeInt(sender.fuelStored);
+        } catch (IOException e)
+        {
+        	System.err.println("[ObsidianIngots] Error while writing tile entity packet.");
+        	e.printStackTrace();
+        }
+        
+        Packet250CustomPayload packet = new Packet250CustomPayload();
+        packet.channel = "ObsidianIngots";
+        packet.data = bytes.toByteArray();
+        packet.length = packet.data.length;
+        
+        PacketDispatcher.sendPacketToAllAround(sender.xCoord, sender.yCoord, sender.zCoord, distance, sender.worldObj.provider.dimensionId, packet);
+	}
+	
 	/**
 	 * Sends the server the defined packet data int.
 	 * @param type - packet type

src/common/net/uberkat/obsidian/common/TileEntityAdvancedElectricMachine.java

@@ -414,6 +414,11 @@ public abstract class TileEntityAdvancedElectricMachine extends TileEntityBasicM
 		secondaryEnergyStored = Math.max(Math.min(energy, getFuelTicks(inventory[1])), 0);
 	}
 	
+	/**
+	 * Gets the scaled secondary energy level for the GUI.
+	 * @param i - multiplier
+	 * @return scaled secondary energy
+	 */
 	public int getScaledSecondaryEnergyLevel(int i)
 	{
 		return secondaryEnergyStored*i / MAX_SECONDARY_ENERGY;

src/common/net/uberkat/obsidian/common/TileEntityAdvancedPowerUnit.java

@@ -4,6 +4,6 @@ public class TileEntityAdvancedPowerUnit extends TileEntityPowerUnit
 {
 	public TileEntityAdvancedPowerUnit()
 	{
-		super(50000000, 1024);
+		super("Advanced Power Unit", 50000000, 1024);
 	}
 }

src/common/net/uberkat/obsidian/common/TileEntityBasicMachine.java

@@ -25,11 +25,8 @@ import net.minecraftforge.common.ForgeDirection;
 import net.minecraftforge.common.ISidedInventory;
 import net.uberkat.obsidian.client.Sound;
 
-public abstract class TileEntityBasicMachine extends TileEntityDisableable implements IElectricMachine
+public abstract class TileEntityBasicMachine extends TileEntityElectricBlock implements IElectricMachine
 {
-	/** The inventory slot itemstacks used by this machine. */
-	public ItemStack[] inventory;
-	
 	/** The Sound instance for this machine. */
 	public Sound audio;
 	
@@ -42,39 +39,21 @@ public abstract class TileEntityBasicMachine extends TileEntityDisableable imple
 	/** How many ticks this machine has operated for. */
 	public int operatingTicks = 0;
 	
-	/** How much energy is stored in this machine. */
-	public int energyStored = 0;
-	
 	/** Ticks required to operate -- or smelt an item. */
 	public int TICKS_REQUIRED;
 	
 	/** The current tick requirement for this machine. */
 	public int currentTicksRequired;
 	
-	/** Maximum amount of energy this machine can hold. */
-	public int MAX_ENERGY;
-	
 	/** The current energy capacity for this machine. */
 	public int currentMaxEnergy;
 	
-	/** The direction this block is facing. */
-	public int facing;
-	
-	/** A timer used to send packets to clients. */
-	public int packetTick = 0;
-	
 	/** Whether or not this block is in it's active state. */
 	public boolean isActive;
 	
 	/** The previous active state for this block. */
 	public boolean prevActive;
 	
-	/** Whether or not this machine has initialized and registered with other mods. */
-	public boolean initialized;
-	
-	/** The full name of this machine. */
-	public String fullName;
-	
 	/** The GUI texture path for this machine. */
 	public String guiTexturePath;
 	
@@ -92,49 +71,26 @@ public abstract class TileEntityBasicMachine extends TileEntityDisableable imple
 	 */
 	public TileEntityBasicMachine(String soundPath, String name, String path, int perTick, int ticksRequired, int maxEnergy)
 	{
+		super(name, maxEnergy);
 		ENERGY_PER_TICK = perTick;
 		TICKS_REQUIRED = currentTicksRequired = ticksRequired;
-		MAX_ENERGY = currentMaxEnergy = maxEnergy;
 		soundURL = soundPath;
-		fullName = name;
 		guiTexturePath = path;
 		isActive = false;
 		if(PowerFramework.currentFramework != null)
 		{
 			powerProvider = PowerFramework.currentFramework.createPowerProvider();
-			powerProvider.configure(5, 25, 25, 25, maxEnergy/10);
+			powerProvider.configure(20, 25, 25, 25, maxEnergy/10);
 		}
 	}
 	
-	public void updateEntity()
+	public void onUpdate()
 	{
-		if(!initialized && worldObj != null)
-		{
-			if(ObsidianIngots.hooks.IC2Loaded)
-			{
-				EnergyNet.getForWorld(worldObj).addTileEntity(this);
-			}
-			
-			initialized = true;
-		}
-		
 		if(audio == null && worldObj.isRemote)
 		{
 			audio = ObsidianIngots.audioHandler.getSound(fullName.replace(" ", ""), soundURL, worldObj, xCoord, yCoord, zCoord);
 		}
 		
-		onUpdate();
-		
-		if(!worldObj.isRemote)
-		{
-			if(packetTick == 5)
-			{
-				sendPacket();
-			}
-			
-			packetTick++;
-		}
-		
 		if(worldObj.isRemote)
 		{
 			audio.updateVolume(FMLClientHandler.instance().getClient().thePlayer);
@@ -147,36 +103,12 @@ public abstract class TileEntityBasicMachine extends TileEntityDisableable imple
 				audio.stop();
 			}
 		}
-		
-		if(!worldObj.isRemote)
-		{
-			sendPacketWithRange();
-		}
-	}
-	
-	public boolean isUseableByPlayer(EntityPlayer entityplayer)
-	{
-		return worldObj.getBlockTileEntity(xCoord, yCoord, zCoord) != this ? false : entityplayer.getDistanceSq((double)xCoord + 0.5D, (double)yCoord + 0.5D, (double)zCoord + 0.5D) <= 64.0D;
-	}
-	
-	public void openChest() {}
-
-	public void closeChest() {}
-	
-	public String getInvName() 
-	{
-		return fullName;
-	}
-	
-	public int getInventoryStackLimit() 
-	{
-		return 64;
 	}
 	
 	public void invalidate()
 	{
 		super.invalidate();
-		if(worldObj.isRemote)
+		if(worldObj.isRemote && audio != null)
 		{
 			audio.remove();
 		}
@@ -203,46 +135,6 @@ public abstract class TileEntityBasicMachine extends TileEntityDisableable imple
     	
     	return rejects;
     }
-
-	public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side)
-	{
-		return true;
-	}
-
-	public short getFacing() 
-	{
-		return (short)facing;
-	}
-
-	public void setFacing(short direction) 
-	{
-		if(initialized)
-		{
-			if(ObsidianIngots.hooks.IC2Loaded)
-			{
-				EnergyNet.getForWorld(worldObj).removeTileEntity(this);
-			}
-		}
-		
-		initialized = false;
-		facing = direction;
-		sendPacket();
-		if(ObsidianIngots.hooks.IC2Loaded)
-		{
-			EnergyNet.getForWorld(worldObj).addTileEntity(this);
-		}
-		initialized = true;
-	}
-
-	public boolean wrenchCanRemove(EntityPlayer entityPlayer) 
-	{
-		return true;
-	}
-
-	public float getWrenchDropRate() 
-	{
-		return 1.0F;
-	}
 	
 	public void setPowerProvider(IPowerProvider provider)
 	{
@@ -266,15 +158,10 @@ public abstract class TileEntityBasicMachine extends TileEntityDisableable imple
 		return true;
 	}
 	
-	public boolean isAddedToEnergyNet()
-	{
-		return initialized;
-	}
-	
 	/**
 	 * Gets the scaled energy level for the GUI.
 	 * @param i - multiplier
-	 * @return
+	 * @return scaled energy
 	 */
 	public int getScaledEnergyLevel(int i)
 	{
@@ -365,82 +252,6 @@ public abstract class TileEntityBasicMachine extends TileEntityDisableable imple
 	public void attach(IComputerAccess computer, String computerSide) {}
 
 	public void detach(IComputerAccess computer) {}
-	
-	public int getStartInventorySide(ForgeDirection side) 
-	{
-        if (side == ForgeDirection.DOWN) return 1;
-        if (side == ForgeDirection.UP) return 0; 
-        return 2;
-	}
-
-	public int getSizeInventorySide(ForgeDirection side)
-	{
-		return 1;
-	}
-
-	public int getSizeInventory() 
-	{
-		return inventory.length;
-	}
-
-	public ItemStack getStackInSlot(int par1) 
-	{
-		return inventory[par1];
-	}
-
-    public ItemStack decrStackSize(int par1, int par2)
-    {
-        if (inventory[par1] != null)
-        {
-            ItemStack var3;
-
-            if (inventory[par1].stackSize <= par2)
-            {
-                var3 = inventory[par1];
-                inventory[par1] = null;
-                return var3;
-            }
-            else
-            {
-                var3 = inventory[par1].splitStack(par2);
-
-                if (inventory[par1].stackSize == 0)
-                {
-                    inventory[par1] = null;
-                }
-
-                return var3;
-            }
-        }
-        else
-        {
-            return null;
-        }
-    }
-
-    public ItemStack getStackInSlotOnClosing(int par1)
-    {
-        if (inventory[par1] != null)
-        {
-            ItemStack var2 = inventory[par1];
-            inventory[par1] = null;
-            return var2;
-        }
-        else
-        {
-            return null;
-        }
-    }
-
-    public void setInventorySlotContents(int par1, ItemStack par2ItemStack)
-    {
-        inventory[par1] = par2ItemStack;
-
-        if (par2ItemStack != null && par2ItemStack.stackSize > getInventoryStackLimit())
-        {
-            par2ItemStack.stackSize = getInventoryStackLimit();
-        }
-    }
     
 	public int transferToAcceptor(int amount)
 	{

src/common/net/uberkat/obsidian/common/TileEntityElectricBlock.java

@@ -0,0 +1,228 @@
+package net.uberkat.obsidian.common;
+
+import obsidian.api.ITileNetwork;
+import universalelectricity.prefab.TileEntityDisableable;
+import ic2.api.EnergyNet;
+import ic2.api.IWrenchable;
+import net.minecraft.src.*;
+import net.minecraftforge.common.ForgeDirection;
+import net.minecraftforge.common.ISidedInventory;
+
+public abstract class TileEntityElectricBlock extends TileEntityDisableable implements IWrenchable, ISidedInventory, IInventory, ITileNetwork
+{
+	/** The inventory slot itemstacks used by this block. */
+	public ItemStack[] inventory;
+	
+	/** How much energy is stored in this block. */
+	public int energyStored;
+	
+	/** The direction this block is facing. */
+	public int facing;
+	
+	/** Maximum amount of energy this machine can hold. */
+	public int MAX_ENERGY;
+	
+	/** The full name of this machine. */
+	public String fullName;
+	
+	/** Whether or not this machine has initialized and registered with other mods. */
+	public boolean initialized;
+	
+	/** The amount of players using this block */
+	public int playersUsing = 0;
+	
+	/** A timer used to send packets to clients. */
+	public int packetTick;
+	
+	/**
+	 * The base of all blocks that deal with electricity. It has a facing state, initialized state,
+	 * and a current amount of stored energy.
+	 * @param name - full name of this block
+	 * @param maxEnergy - how much energy this block can store
+	 */
+	public TileEntityElectricBlock(String name, int maxEnergy)
+	{
+		fullName = name;
+		MAX_ENERGY = maxEnergy;
+	}
+	
+	public void updateEntity()
+	{
+		if(!initialized && worldObj != null)
+		{
+			if(ObsidianIngots.hooks.IC2Loaded)
+			{
+				EnergyNet.getForWorld(worldObj).addTileEntity(this);
+			}
+			
+			initialized = true;
+		}
+		
+		onUpdate();
+		
+		if(!worldObj.isRemote)
+		{
+			if(playersUsing > 0)
+			{
+				sendPacketWithRange();
+			}
+			else {
+				if(packetTick % 100 == 0)
+				{
+					sendPacketWithRange();
+				}
+			}
+		}
+	}
+	
+	/**
+	 * Update call for machines. Use instead of updateEntity -- it's called every tick.
+	 */
+	public abstract void onUpdate();
+	
+	public int getStartInventorySide(ForgeDirection side) 
+	{
+        if (side == ForgeDirection.DOWN) return 1;
+        if (side == ForgeDirection.UP) return 0; 
+        return 2;
+	}
+
+	public int getSizeInventorySide(ForgeDirection side)
+	{
+		return 1;
+	}
+
+	public int getSizeInventory() 
+	{
+		return inventory.length;
+	}
+
+	public ItemStack getStackInSlot(int par1) 
+	{
+		return inventory[par1];
+	}
+
+    public ItemStack decrStackSize(int par1, int par2)
+    {
+        if (inventory[par1] != null)
+        {
+            ItemStack var3;
+
+            if (inventory[par1].stackSize <= par2)
+            {
+                var3 = inventory[par1];
+                inventory[par1] = null;
+                return var3;
+            }
+            else
+            {
+                var3 = inventory[par1].splitStack(par2);
+
+                if (inventory[par1].stackSize == 0)
+                {
+                    inventory[par1] = null;
+                }
+
+                return var3;
+            }
+        }
+        else
+        {
+            return null;
+        }
+    }
+
+    public ItemStack getStackInSlotOnClosing(int par1)
+    {
+        if (inventory[par1] != null)
+        {
+            ItemStack var2 = inventory[par1];
+            inventory[par1] = null;
+            return var2;
+        }
+        else
+        {
+            return null;
+        }
+    }
+
+    public void setInventorySlotContents(int par1, ItemStack par2ItemStack)
+    {
+        inventory[par1] = par2ItemStack;
+
+        if (par2ItemStack != null && par2ItemStack.stackSize > getInventoryStackLimit())
+        {
+            par2ItemStack.stackSize = getInventoryStackLimit();
+        }
+    }
+    
+	public boolean isUseableByPlayer(EntityPlayer entityplayer)
+	{
+		return worldObj.getBlockTileEntity(xCoord, yCoord, zCoord) != this ? false : entityplayer.getDistanceSq((double)xCoord + 0.5D, (double)yCoord + 0.5D, (double)zCoord + 0.5D) <= 64.0D;
+	}
+
+	public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side)
+	{
+		return true;
+	}
+
+	public short getFacing() 
+	{
+		return (short)facing;
+	}
+
+	public void setFacing(short direction) 
+	{
+		if(initialized)
+		{
+			if(ObsidianIngots.hooks.IC2Loaded)
+			{
+				EnergyNet.getForWorld(worldObj).removeTileEntity(this);
+			}
+		}
+		
+		initialized = false;
+		facing = direction;
+		sendPacket();
+		if(ObsidianIngots.hooks.IC2Loaded)
+		{
+			EnergyNet.getForWorld(worldObj).addTileEntity(this);
+		}
+		initialized = true;
+	}
+
+	public boolean wrenchCanRemove(EntityPlayer entityPlayer) 
+	{
+		return true;
+	}
+
+	public float getWrenchDropRate() 
+	{
+		return 1.0F;
+	}
+	
+	public boolean isAddedToEnergyNet()
+	{
+		return initialized;
+	}
+	
+	public String getInvName()
+	{
+		return fullName;
+	}
+	
+	public int getInventoryStackLimit() 
+	{
+		return 64;
+	}
+	
+	public void openChest() 
+	{
+		playersUsing++;
+	}
+
+	public void closeChest() 
+	{
+		playersUsing--;
+	}
+}

src/common/net/uberkat/obsidian/common/TileEntityGenerator.java

@@ -0,0 +1,484 @@
+package net.uberkat.obsidian.common;
+
+import buildcraft.api.core.Orientations;
+import buildcraft.api.power.IPowerProvider;
+import buildcraft.api.power.IPowerReceptor;
+import buildcraft.api.power.PowerFramework;
+import buildcraft.api.power.PowerProvider;
+
+import com.google.common.io.ByteArrayDataInput;
+
+import dan200.computer.api.IComputerAccess;
+import dan200.computer.api.IPeripheral;
+
+import ic2.api.Direction;
+import ic2.api.ElectricItem;
+import ic2.api.EnergyNet;
+import ic2.api.IElectricItem;
+import ic2.api.IEnergySource;
+import ic2.api.IEnergyStorage;
+import obsidian.api.IEnergizedItem;
+import obsidian.api.IEnergyAcceptor;
+import universalelectricity.core.UniversalElectricity;
+import universalelectricity.core.Vector3;
+import universalelectricity.electricity.ElectricInfo;
+import universalelectricity.electricity.ElectricityManager;
+import universalelectricity.implement.IConductor;
+import universalelectricity.implement.IElectricityReceiver;
+import universalelectricity.implement.IItemElectric;
+import universalelectricity.implement.IJouleStorage;
+import universalelectricity.prefab.TileEntityConductor;
+import net.minecraft.src.*;
+import net.minecraftforge.common.ForgeDirection;
+
+public abstract class TileEntityGenerator extends TileEntityElectricBlock implements IEnergySource, IEnergyStorage, IPowerReceptor, IJouleStorage, IElectricityReceiver, IPeripheral
+{
+	/** The amount of fuel stored in this generator. */
+	public int fuelStored;
+	
+	/** The maximum amount of fuel this generator can store. */
+	public int MAX_FUEL;
+	
+	/** Output per tick this generator can transfer. */
+	public int output = 128;
+	
+	/** BuildCraft power provider. */
+	public IPowerProvider powerProvider;
+	
+	/**
+	 * Generator -- a block that produces energy. It has a certain amount of fuel it can store as well as an output rate.
+	 * @param name - full name of this generator
+	 * @param maxEnergy - how much energy this generator can store
+	 * @param maxFuel - how much fuel this generator can store
+	 */
+	public TileEntityGenerator(String name, int maxEnergy, int maxFuel)
+	{
+		super(name, maxEnergy);
+		MAX_FUEL = maxFuel;
+		inventory = new ItemStack[2];
+		if(PowerFramework.currentFramework != null)
+		{
+			powerProvider = PowerFramework.currentFramework.createPowerProvider();
+			powerProvider.configure(0, 2, 2000, 1, MAX_ENERGY/10);
+		}
+	}
+	
+	public void onUpdate()
+	{
+		if(powerProvider != null)
+		{
+			int received = (int)(powerProvider.useEnergy(25, 25, true)*10);
+			setEnergy(energyStored + received);
+		}
+		
+		if(inventory[1] != null && energyStored > 0)
+		{
+			if(inventory[1].getItem() instanceof IEnergizedItem)
+			{
+				IEnergizedItem item = (IEnergizedItem)inventory[1].getItem();
+				int rejects = item.charge(inventory[1], item.getRate());
+				setEnergy(energyStored - (item.getRate() - rejects));
+			}
+			else if(inventory[1].getItem() instanceof IItemElectric)
+			{
+				IItemElectric electricItem = (IItemElectric) inventory[1].getItem();
+				double ampsToGive = Math.min(ElectricInfo.getAmps(electricItem.getMaxJoules() * 0.005, getVoltage()), (energyStored*UniversalElectricity.IC2_RATIO));
+				double joules = electricItem.onReceive(ampsToGive, getVoltage(), inventory[1]);
+				setJoules((energyStored*UniversalElectricity.IC2_RATIO) - (ElectricInfo.getJoules(ampsToGive, getVoltage(), 1) - joules));
+			}
+			else if(inventory[1].getItem() instanceof IElectricItem)
+			{
+				int sent = ElectricItem.charge(inventory[1], energyStored, 3, false, false);
+				setEnergy(energyStored - sent);
+			}
+		}
+		
+		if(inventory[0] != null && fuelStored < MAX_ENERGY)
+		{
+			int fuel = getFuel(inventory[0]);
+			if(fuel > 0)
+			{
+				int fuelNeeded = MAX_FUEL - fuelStored;
+				if(fuel <= fuelNeeded)
+				{
+					fuelStored += fuel;
+					--inventory[0].stackSize;
+				}
+				
+				if(inventory[0].stackSize == 0)
+				{
+					inventory[0] = null;
+				}
+			}
+		}
+		
+		if(energyStored < MAX_ENERGY)
+		{
+			System.out.println(getEnvironmentBoost());
+			setEnergy(energyStored + getEnvironmentBoost());
+			
+			if(fuelStored > 0)
+			{
+				fuelStored--;
+				setEnergy(energyStored + 4);
+			}
+		}
+		
+		if(energyStored > 0)
+		{
+			TileEntity tileEntity = Vector3.getTileEntityFromSide(worldObj, Vector3.get(this), ForgeDirection.getOrientation(facing));
+			
+			if(ObsidianIngots.hooks.IC2Loaded)
+			{
+				if(energyStored >= output)
+				{
+					setEnergy(energyStored - (output - EnergyNet.getForWorld(worldObj).emitEnergyFrom(this, output)));
+				}
+			}
+			
+			if(tileEntity != null)
+			{
+				if(isPowerReceptor(tileEntity))
+				{
+					IPowerReceptor receptor = (IPowerReceptor)tileEntity;
+	            	int energyNeeded = Math.min(receptor.getPowerProvider().getMinEnergyReceived(), receptor.getPowerProvider().getMaxEnergyReceived())*10;
+	            	float transferEnergy = Math.max(Math.min(Math.min(energyNeeded, energyStored), 54000), 0);
+	            	receptor.getPowerProvider().receiveEnergy((float)(transferEnergy/10), Orientations.dirs()[ForgeDirection.getOrientation(facing).getOpposite().ordinal()]);
+	            	setEnergy(energyStored - (int)transferEnergy);
+				}
+				else if(tileEntity instanceof TileEntityConductor)
+				{
+					double joulesNeeded = ElectricityManager.instance.getElectricityRequired(((IConductor) tileEntity).getNetwork());
+					double transferAmps = Math.max(Math.min(Math.min(ElectricInfo.getAmps(joulesNeeded, getVoltage()), ElectricInfo.getAmps(energyStored*UniversalElectricity.IC2_RATIO, getVoltage())), 80), 0);
+					if (!worldObj.isRemote)
+					{
+						ElectricityManager.instance.produceElectricity(this, (IConductor)tileEntity, transferAmps, getVoltage());
+					}
+					setEnergy(energyStored - (int)(ElectricInfo.getJoules(transferAmps, getVoltage())*UniversalElectricity.TO_IC2_RATIO));
+				}
+				else if(tileEntity instanceof IEnergyAcceptor)
+				{
+					if(((IEnergyAcceptor)tileEntity).canReceive(ForgeDirection.getOrientation(facing).getOpposite()))
+					{
+						int sendingEnergy = 0;
+						if(energyStored >= output)
+						{
+							sendingEnergy = output;
+						}
+						else if(energyStored < output)
+						{
+							sendingEnergy = energyStored;
+						}
+						
+						int rejects = ((IEnergyAcceptor)tileEntity).transferToAcceptor(output);
+						
+						setEnergy(energyStored - (sendingEnergy - rejects));
+					}
+				}
+			}
+		}
+	}
+	
+	/**
+	 * Gets the amount of fuel a certain ItemStack contains.
+	 * @param itemstack - slot stack to check
+	 * @return amount of fuel the stack contains
+	 */
+	public abstract int getFuel(ItemStack itemstack);
+	
+	/**
+	 * Gets the boost this generator can receive in it's current location.
+	 * @return environmental boost
+	 */
+	public int getEnvironmentBoost()
+	{
+		int boost = 0;
+		
+		if(worldObj.getBlockId(xCoord+1, yCoord, zCoord) == 10)
+			boost+=1;
+		if(worldObj.getBlockId(xCoord-1, yCoord, zCoord) == 10)
+			boost+=1;
+		if(worldObj.getBlockId(xCoord, yCoord+1, zCoord) == 10)
+			boost+=1;
+		if(worldObj.getBlockId(xCoord, yCoord-1, zCoord) == 10)
+			boost+=1;
+		if(worldObj.getBlockId(xCoord, yCoord, zCoord+1) == 10)
+			boost+=1;
+		if(worldObj.getBlockId(xCoord, yCoord, zCoord-1) == 10)
+			boost+=1;
+		
+		if(worldObj.isDaytime() && worldObj.canBlockSeeTheSky(xCoord, yCoord+1, zCoord) && !worldObj.isRaining() && !worldObj.isThundering() && !worldObj.provider.hasNoSky)
+		{
+			boost+=2;
+			if(worldObj.getWorldChunkManager().getBiomeGenAt(xCoord, zCoord).biomeName.equals("Desert"))
+				boost+=2;
+			else if(worldObj.getWorldChunkManager().getBiomeGenAt(xCoord, zCoord).biomeName.equals("Plains"))
+				boost+=1;
+		}
+		
+		return boost;
+	}
+	
+	/**
+	 * Whether or not this machine can operate and generate power.
+	 * @return if the machine can generate power
+	 */
+	public boolean canPower()
+	{
+		if(fuelStored <= 0)
+		{
+			return false;
+		}
+		
+		if(energyStored >= MAX_ENERGY)
+		{
+			return false;
+		}
+		return true;
+	}
+	
+	/**
+	 * Whether or not the declared Tile Entity is an instance of a BuildCraft power receptor.
+	 * @param tileEntity - tile entity to check
+	 * @return if the tile entity is a power receptor
+	 */
+	public boolean isPowerReceptor(TileEntity tileEntity)
+	{
+		if(tileEntity instanceof IPowerReceptor) 
+		{
+			IPowerReceptor receptor = (IPowerReceptor)tileEntity;
+			IPowerProvider provider = receptor.getPowerProvider();
+			return provider != null && provider.getClass().getSuperclass().equals(PowerProvider.class);
+		}
+		return false;
+	}
+	
+	/**
+	 * Gets the scaled energy level for the GUI.
+	 * @param i - multiplier
+	 * @return
+	 */
+	public int getScaledEnergyLevel(int i)
+	{
+		return energyStored*i / MAX_ENERGY;
+	}
+	
+	/**
+	 * Gets the scaled fuel level for the GUI.
+	 * @param i - multiplier
+	 * @return
+	 */
+	public int getScaledFuelLevel(int i)
+	{
+		return fuelStored*i / MAX_FUEL;
+	}
+	
+	/**
+	 * Set this block's energy to a new amount.
+	 * @param energy - new amount of energy
+	 */
+	public void setEnergy(int energy)
+	{
+		energyStored = Math.max(Math.min(energy, MAX_ENERGY), 0);
+	}
+	
+    public void readFromNBT(NBTTagCompound nbtTags)
+    {
+        super.readFromNBT(nbtTags);
+        
+        if(PowerFramework.currentFramework != null)
+        {
+        	PowerFramework.currentFramework.loadPowerProvider(this, nbtTags);
+        }
+        
+        NBTTagList tagList = nbtTags.getTagList("Items");
+        inventory = new ItemStack[getSizeInventory()];
+
+        for (int slots = 0; slots < tagList.tagCount(); ++slots)
+        {
+            NBTTagCompound tagCompound = (NBTTagCompound)tagList.tagAt(slots);
+            byte slotID = tagCompound.getByte("Slot");
+
+            if (slotID >= 0 && slotID < inventory.length)
+            {
+                inventory[slotID] = ItemStack.loadItemStackFromNBT(tagCompound);
+            }
+        }
+
+        energyStored = nbtTags.getInteger("energyStored");
+        fuelStored = nbtTags.getInteger("fuelStored");
+        facing = nbtTags.getInteger("facing");
+    }
+
+    public void writeToNBT(NBTTagCompound nbtTags)
+    {
+        super.writeToNBT(nbtTags);
+        
+        if(PowerFramework.currentFramework != null)
+        {
+        	PowerFramework.currentFramework.savePowerProvider(this, nbtTags);
+        }
+        
+        nbtTags.setInteger("energyStored", energyStored);
+        nbtTags.setInteger("fuelStored", fuelStored);
+        nbtTags.setInteger("facing", facing);
+        NBTTagList tagList = new NBTTagList();
+
+        for (int slots = 0; slots < inventory.length; ++slots)
+        {
+            if (inventory[slots] != null)
+            {
+                NBTTagCompound tagCompound = new NBTTagCompound();
+                tagCompound.setByte("Slot", (byte)slots);
+                inventory[slots].writeToNBT(tagCompound);
+                tagList.appendTag(tagCompound);
+            }
+        }
+
+        nbtTags.setTag("Items", tagList);
+    }
+	
+	public double getVoltage()
+	{
+		return 120;
+	}
+	
+	public void setJoules(double joules, Object... data) 
+	{
+		setEnergy((int)(joules*UniversalElectricity.TO_IC2_RATIO));
+	}
+
+	public void handlePacketData(INetworkManager network, Packet250CustomPayload packet, EntityPlayer player, ByteArrayDataInput dataStream)
+	{
+		try {
+			facing = dataStream.readInt();
+			energyStored = dataStream.readInt();
+			fuelStored = dataStream.readInt();
+			worldObj.markBlockAsNeedsUpdate(xCoord, yCoord, zCoord);
+		} catch (Exception e)
+		{
+			System.out.println("[ObsidianIngots] Error while handling tile entity packet.");
+			e.printStackTrace();
+		}
+	}
+	
+	public void sendPacket()
+	{
+		PacketHandler.sendGeneratorPacket(this);
+	}
+	
+	public void sendPacketWithRange()
+	{
+		PacketHandler.sendGeneratorPacketWithRange(this, 50);
+	}
+	
+	public String getType() 
+	{
+		return getInvName();
+	}
+
+	public String[] getMethodNames() 
+	{
+		return new String[] {"getStored", "getOutput", "getMaxEnergy", "getEnergyNeeded", "getFuel", "getFuelNeeded"};
+	}
+
+	public Object[] callMethod(IComputerAccess computer, int method, Object[] arguments) throws Exception 
+	{
+		switch(method)
+		{
+			case 0:
+				return new Object[] {energyStored};
+			case 1:
+				return new Object[] {output};
+			case 2:
+				return new Object[] {MAX_ENERGY};
+			case 3:
+				return new Object[] {(MAX_ENERGY-energyStored)};
+			case 4:
+				return new Object[] {fuelStored};
+			case 5:
+				return new Object[] {MAX_FUEL-fuelStored};
+			default:
+				System.err.println("[ObsidianIngots] Attempted to call unknown method with computer ID " + computer.getID());
+				return null;
+		}
+	}
+
+	public boolean canAttachToSide(int side) 
+	{
+		return true;
+	}
+
+	public void attach(IComputerAccess computer, String computerSide) {}
+
+	public void detach(IComputerAccess computer) {}
+	
+	public void setPowerProvider(IPowerProvider provider)
+	{
+		powerProvider = provider;
+	}
+
+	public IPowerProvider getPowerProvider() 
+	{
+		return powerProvider;
+	}
+
+	public void doWork() {}
+
+	public int powerRequest() 
+	{
+		return getPowerProvider().getMaxEnergyReceived();
+	}
+	
+	public double getMaxJoules() 
+	{
+		return MAX_ENERGY*UniversalElectricity.IC2_RATIO;
+	}
+	
+	public double getJoules(Object... data) 
+	{
+		return energyStored*UniversalElectricity.IC2_RATIO;
+	}
+	
+	public int getMaxEnergyOutput()
+	{
+		return output;
+	}
+	
+	public boolean emitsEnergyTo(TileEntity receiver, Direction direction)
+	{
+		return direction.toForgeDirection() == ForgeDirection.getOrientation(facing);
+	}
+	
+	public int getStored() 
+	{
+		return energyStored;
+	}
+
+	public int getCapacity() 
+	{
+		return MAX_ENERGY;
+	}
+
+	public int getRate() 
+	{
+		return output;
+	}
+	
+	public boolean canConnect(ForgeDirection side) 
+	{
+		return side == ForgeDirection.getOrientation(facing);
+	}
+	
+	public void onReceive(TileEntity sender, double amps, double voltage, ForgeDirection side) {}
+
+	public double wattRequest() 
+	{
+		return 0;
+	}
+
+	public boolean canReceiveFromSide(ForgeDirection side) 
+	{
+		return false;
+	}
+}

src/common/net/uberkat/obsidian/common/TileEntityHeatGenerator.java

@@ -0,0 +1,18 @@
+package net.uberkat.obsidian.common;
+
+import com.google.common.io.ByteArrayDataInput;
+
+import net.minecraft.src.*;
+
+public class TileEntityHeatGenerator extends TileEntityGenerator
+{
+	public TileEntityHeatGenerator()
+	{
+		super("Heat Generator", 8000, 2000);
+	}
+
+	public int getFuel(ItemStack itemstack)
+	{
+		return TileEntityFurnace.getItemBurnTime(itemstack);
+	}
+}

src/common/net/uberkat/obsidian/common/TileEntityPowerUnit.java

@@ -42,38 +42,20 @@ import net.minecraft.src.*;
 import net.minecraftforge.common.ForgeDirection;
 import net.minecraftforge.common.ISidedInventory;
 
-public class TileEntityPowerUnit extends TileEntityDisableable implements IInventory, ISidedInventory, ITileNetwork, IWrenchable, IEnergySink, IEnergySource, IEnergyStorage, IPowerReceptor, IJouleStorage, IElectricityReceiver, IEnergyAcceptor, IPeripheral
+public class TileEntityPowerUnit extends TileEntityElectricBlock implements IEnergySink, IEnergySource, IEnergyStorage, IPowerReceptor, IJouleStorage, IElectricityReceiver, IEnergyAcceptor, IPeripheral
 {
-	/** The inventory slot itemstacks used by this power unit. */
-	public ItemStack[] inventory = new ItemStack[2];
-	
-	/** Maximum amount of energy this unit can hold. */
-	public int maxEnergy;
-	
 	/** Output per tick this machine can transfer. */
 	public int output;
 	
-	/** The amount of energy this unit is storing. */
-	public int energyStored = 0;
-	
-	/** Direction this block is facing. */
-	public int facing;
-	
-	/** A timer used to send packets to clients. */
-	public int packetTick = 0;
-	
 	/** BuildCraft power provider. */
 	public IPowerProvider powerProvider;
 	
-	/** Whether or not this machine has initialized and registered with other mods. */
-	public boolean initialized = false;
-	
 	/**
 	 * A block used to store and transfer electricity.
 	 */
 	public TileEntityPowerUnit()
 	{
-		this(500000, 256);
+		this("Power Unit", 500000, 256);
 	}
 	
 	/**
@@ -81,39 +63,20 @@ public class TileEntityPowerUnit extends TileEntityDisableable implements IInven
 	 * @param energy - maximum energy this block can hold.
 	 * @param i - output per tick this block can handle.
 	 */
-	public TileEntityPowerUnit(int energy, int i)
+	public TileEntityPowerUnit(String name, int maxEnergy, int i)
 	{
-		maxEnergy = energy;
+		super(name, maxEnergy);
+		inventory = new ItemStack[2];
 		output = i;
 		if(PowerFramework.currentFramework != null)
 		{
 			powerProvider = PowerFramework.currentFramework.createPowerProvider();
-			powerProvider.configure(5, 25, 25, 25, maxEnergy/10);
+			powerProvider.configure(0, 2, 2000, 1, MAX_ENERGY/10);
 		}
 	}
 	
-	public void updateEntity()
+	public void onUpdate()
 	{
-		if(!worldObj.isRemote)
-		{
-			if(packetTick == 5)
-			{
-				PacketHandler.sendPowerUnitPacket(this);
-			}
-			
-			packetTick++;
-		}
-		
-		if(!initialized)
-		{
-			if(ObsidianIngots.hooks.IC2Loaded)
-			{
-				EnergyNet.getForWorld(worldObj).addTileEntity(this);
-			}
-			
-			initialized = true;
-		}
-		
 		if(powerProvider != null)
 		{
 			int received = (int)(powerProvider.useEnergy(25, 25, true)*10);
@@ -142,7 +105,7 @@ public class TileEntityPowerUnit extends TileEntityDisableable implements IInven
 			}
 		}
 		
-		if(inventory[1] != null && energyStored < maxEnergy)
+		if(inventory[1] != null && energyStored < MAX_ENERGY)
 		{
 			if(inventory[1].getItem() instanceof IEnergizedItem)
 			{
@@ -165,7 +128,7 @@ public class TileEntityPowerUnit extends TileEntityDisableable implements IInven
 				IElectricItem item = (IElectricItem)inventory[1].getItem();
 				if(item.canProvideEnergy())
 				{
-					int gain = ElectricItem.discharge(inventory[1], maxEnergy - energyStored, 3, false, false);
+					int gain = ElectricItem.discharge(inventory[1], MAX_ENERGY - energyStored, 3, false, false);
 					setEnergy(energyStored + gain);
 				}
 			}
@@ -234,105 +197,16 @@ public class TileEntityPowerUnit extends TileEntityDisableable implements IInven
 				}
 			}
 		}
-		
-		if(!worldObj.isRemote)
-		{
-			PacketHandler.sendPowerUnitPacketWithRange(this, 50);
-		}
 	}
 	
+	/**
+	 * Set this block's energy to a new amount.
+	 * @param energy - new amount of energy
+	 */
 	public void setEnergy(int energy)
 	{
-		energyStored = Math.max(Math.min(energy, maxEnergy), 0);
+		energyStored = Math.max(Math.min(energy, MAX_ENERGY), 0);
 	}
-
-	public int getStartInventorySide(ForgeDirection side) 
-	{
-		return 1;
-	}
-
-    public int getSizeInventorySide(ForgeDirection side)
-    {
-        return 1;
-    }
-
-    public int getSizeInventory()
-    {
-        return inventory.length;
-    }
-
-    public ItemStack getStackInSlot(int par1)
-    {
-        return inventory[par1];
-    }
-
-    public ItemStack decrStackSize(int par1, int par2)
-    {
-        if (inventory[par1] != null)
-        {
-            ItemStack var3;
-
-            if (inventory[par1].stackSize <= par2)
-            {
-                var3 = inventory[par1];
-                inventory[par1] = null;
-                return var3;
-            }
-            else
-            {
-                var3 = inventory[par1].splitStack(par2);
-
-                if (inventory[par1].stackSize == 0)
-                {
-                    inventory[par1] = null;
-                }
-
-                return var3;
-            }
-        }
-        else
-        {
-            return null;
-        }
-    }
-
-    public ItemStack getStackInSlotOnClosing(int par1)
-    {
-        if (inventory[par1] != null)
-        {
-            ItemStack var2 = inventory[par1];
-            inventory[par1] = null;
-            return var2;
-        }
-        else
-        {
-            return null;
-        }
-    }
-    
-    public void setInventorySlotContents(int par1, ItemStack par2ItemStack)
-    {
-        inventory[par1] = par2ItemStack;
-
-        if (par2ItemStack != null && par2ItemStack.stackSize > getInventoryStackLimit())
-        {
-            par2ItemStack.stackSize = getInventoryStackLimit();
-        }
-    }
-
-	public String getInvName()
-	{
-		return output == 1024 ? "Advanced Power Unit" : "Power Unit";
-	}
-
-	public int getInventoryStackLimit() 
-	{
-		return 64;
-	}
-
-	public void openChest() {}
-
-	public void closeChest() {}
 	
     public void readFromNBT(NBTTagCompound nbtTags)
     {
@@ -401,56 +275,11 @@ public class TileEntityPowerUnit extends TileEntityDisableable implements IInven
 		}
 	}
 
-	public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side)
-	{
-		return facing != side;
-	}
-
-	public short getFacing()
-	{
-		return (short)facing;
-	}
-
-	public void setFacing(short direction) 
-	{
-		if(initialized)
-		{
-			if(ObsidianIngots.hooks.IC2Loaded)
-			{
-				EnergyNet.getForWorld(worldObj).removeTileEntity(this);
-			}
-		}
-		
-		initialized = false;
-		facing = direction;
-		PacketHandler.sendPowerUnitPacket(this);
-		if(ObsidianIngots.hooks.IC2Loaded)
-		{
-			EnergyNet.getForWorld(worldObj).addTileEntity(this);
-		}
-		initialized = true;
-	}
-
-	public boolean wrenchCanRemove(EntityPlayer entityPlayer) 
-	{
-		return true;
-	}
-
-	public float getWrenchDropRate() 
-	{
-		return 1.0F;
-	}
-
 	public boolean acceptsEnergyFrom(TileEntity emitter, Direction direction)
 	{
 		return direction.toForgeDirection() != ForgeDirection.getOrientation(facing);
 	}
 
-	public boolean isAddedToEnergyNet() 
-	{
-		return initialized;
-	}
-
 	public int getStored() 
 	{
 		return energyStored;
@@ -458,7 +287,7 @@ public class TileEntityPowerUnit extends TileEntityDisableable implements IInven
 
 	public int getCapacity() 
 	{
-		return maxEnergy;
+		return MAX_ENERGY;
 	}
 
 	public int getRate() 
@@ -468,13 +297,13 @@ public class TileEntityPowerUnit extends TileEntityDisableable implements IInven
 
 	public boolean demandsEnergy() 
 	{
-		return energyStored < maxEnergy;
+		return energyStored < MAX_ENERGY;
 	}
 
     public int injectEnergy(Direction direction, int i)
     {
     	int rejects = 0;
-    	int neededEnergy = maxEnergy-energyStored;
+    	int neededEnergy = MAX_ENERGY-energyStored;
     	if(i <= neededEnergy)
     	{
     		energyStored += i;
@@ -510,7 +339,7 @@ public class TileEntityPowerUnit extends TileEntityDisableable implements IInven
 
 	public double getMaxJoules() 
 	{
-		return maxEnergy*UniversalElectricity.IC2_RATIO;
+		return MAX_ENERGY*UniversalElectricity.IC2_RATIO;
 	}
 
 	public void setPowerProvider(IPowerProvider provider)
@@ -542,14 +371,14 @@ public class TileEntityPowerUnit extends TileEntityDisableable implements IInven
 	
 	/**
 	 * Whether or not the declared Tile Entity is an instance of a BuildCraft power receptor.
-	 * @param tileEntity
-	 * @return
+	 * @param tileEntity - tile entity to check
+	 * @return if the tile entity is a power receptor
 	 */
 	public boolean isPowerReceptor(TileEntity tileEntity)
 	{
 		if(tileEntity instanceof IPowerReceptor) 
 		{
-			IPowerReceptor receptor = (IPowerReceptor) tileEntity;
+			IPowerReceptor receptor = (IPowerReceptor)tileEntity;
 			IPowerProvider provider = receptor.getPowerProvider();
 			return provider != null && provider.getClass().getSuperclass().equals(PowerProvider.class);
 		}
@@ -563,7 +392,7 @@ public class TileEntityPowerUnit extends TileEntityDisableable implements IInven
 
 	public double wattRequest() 
 	{
-		return ElectricInfo.getWatts(maxEnergy*UniversalElectricity.IC2_RATIO) - ElectricInfo.getWatts(energyStored*UniversalElectricity.IC2_RATIO);
+		return ElectricInfo.getWatts(MAX_ENERGY*UniversalElectricity.IC2_RATIO) - ElectricInfo.getWatts(energyStored*UniversalElectricity.IC2_RATIO);
 	}
 
 	public boolean canReceiveFromSide(ForgeDirection side) 
@@ -571,11 +400,6 @@ public class TileEntityPowerUnit extends TileEntityDisableable implements IInven
 		return side != ForgeDirection.getOrientation(facing);
 	}
 
-	public boolean isUseableByPlayer(EntityPlayer entityplayer)
-	{
-		return worldObj.getBlockTileEntity(xCoord, yCoord, zCoord) != this ? false : entityplayer.getDistanceSq((double)xCoord + 0.5D, (double)yCoord + 0.5D, (double)zCoord + 0.5D) <= 64.0D;
-	}
-
 	public String getType() 
 	{
 		return getInvName();
@@ -595,9 +419,9 @@ public class TileEntityPowerUnit extends TileEntityDisableable implements IInven
 			case 1:
 				return new Object[] {output};
 			case 2:
-				return new Object[] {maxEnergy};
+				return new Object[] {MAX_ENERGY};
 			case 3:
-				return new Object[] {(maxEnergy-energyStored)};
+				return new Object[] {(MAX_ENERGY-energyStored)};
 			default:
 				System.err.println("[ObsidianIngots] Attempted to call unknown method with computer ID " + computer.getID());
 				return null;
@@ -616,7 +440,7 @@ public class TileEntityPowerUnit extends TileEntityDisableable implements IInven
 	public int transferToAcceptor(int amount) 
 	{
     	int rejects = 0;
-    	int neededEnergy = maxEnergy-energyStored;
+    	int neededEnergy = MAX_ENERGY-energyStored;
     	if(amount <= neededEnergy)
     	{
     		energyStored += amount;
@@ -634,4 +458,14 @@ public class TileEntityPowerUnit extends TileEntityDisableable implements IInven
 	{
 		return side != ForgeDirection.getOrientation(facing);
 	}
+	
+    public void sendPacket()
+    {
+    	PacketHandler.sendPowerUnitPacket(this);
+    }
+    
+    public void sendPacketWithRange()
+    {
+    	PacketHandler.sendPowerUnitPacketWithRange(this, 50);
+    }
 }

src/common/obsidian/api/IElectricMachine.java

@@ -19,7 +19,7 @@ import net.minecraftforge.common.ISidedInventory;
  * @author AidanBrady
  *
  */
-public interface IElectricMachine extends IInventory, ISidedInventory, IWrenchable, ITileNetwork, IPowerReceptor, IEnergySink, IJouleStorage, IElectricityReceiver, IEnergyAcceptor, IPeripheral
+public interface IElectricMachine extends IPowerReceptor, IEnergySink, IJouleStorage, IElectricityReceiver, IEnergyAcceptor, IPeripheral
 {
     /**
      * Update call for machines. Use instead of updateEntity() - it's called every tick.
@@ -36,16 +36,6 @@ public interface IElectricMachine extends IInventory, ISidedInventory, IWrenchab
 	 * Runs this machine's operation -- or smelts the item.
 	 */
 	public void operate();
-	
-	/**
-	 * Sends a tile entity packet to the server.
-	 */
-	public void sendPacket();
-	
-	/**
-	 * Sends a tile entity packet to the server with a defined range.
-	 */
-	public void sendPacketWithRange();
 
 	/**
 	 * Gets the recipe vector from the machine tile entity.

src/common/obsidian/api/IEnergizedItem.java

@@ -50,4 +50,10 @@ public interface IEnergizedItem
 	 * @return leftover energy
 	 */
 	public int discharge(ItemStack itemstack, int amount);
+	
+	/**
+	 * Gets the divider that gets that returns the max damage as 100.
+	 * @return divider
+	 */
+	public int getDivider();
 }

src/common/obsidian/api/ITileNetwork.java

@@ -21,4 +21,14 @@ public interface ITileNetwork
 	 * @param dataStream
 	 */
 	public void handlePacketData(INetworkManager network, Packet250CustomPayload packet, EntityPlayer player, ByteArrayDataInput dataStream);
+	
+	/**
+	 * Sends a tile entity packet to the server.
+	 */
+	public void sendPacket();
+	
+	/**
+	 * Sends a tile entity packet to the server with a defined range.
+	 */
+	public void sendPacketWithRange();
 }

src/minecraft/net/uberkat/obsidian/client/ClientProxy.java

@@ -31,6 +31,7 @@ import net.uberkat.obsidian.common.ObsidianUtils;
 import net.uberkat.obsidian.common.TileEntityCombiner;
 import net.uberkat.obsidian.common.TileEntityCrusher;
 import net.uberkat.obsidian.common.TileEntityEnrichmentChamber;
+import net.uberkat.obsidian.common.TileEntityGenerator;
 import net.uberkat.obsidian.common.TileEntityPlatinumCompressor;
 import net.uberkat.obsidian.common.TileEntityPowerUnit;
 import net.uberkat.obsidian.common.TileEntityTheoreticalElementizer;
@@ -59,7 +60,6 @@ public class ClientProxy extends CommonProxy
 		MinecraftForgeClient.preloadTexture("/textures/ElementizerFront.png");
 		MinecraftForgeClient.preloadTexture("/textures/ElementizerBack.png");
 		MinecraftForgeClient.preloadTexture("/textures/ElementizerSide.png");
-		MinecraftForgeClient.preloadTexture("/texture/PlatinumCable.png");
 		
 		//Register animated TextureFX for machines
 		try {
@@ -119,6 +119,9 @@ public class ClientProxy extends CommonProxy
 			case 8:
 				TileEntityPowerUnit tileentity5 = (TileEntityPowerUnit)world.getBlockTileEntity(x, y, z);
 				return new GuiPowerUnit(player.inventory, tileentity5);
+			case 9:
+				TileEntityGenerator tileentity6 = (TileEntityGenerator)world.getBlockTileEntity(x, y, z);
+				return new GuiGenerator(player.inventory, tileentity6);
 		}
 		return null;
 	}

src/minecraft/net/uberkat/obsidian/client/GuiAdvancedElectricMachine.java

@@ -18,7 +18,7 @@ public class GuiAdvancedElectricMachine extends GuiContainer
     /**
      * Draw the foreground layer for the GuiContainer (everythin in front of the items)
      */
-    protected void drawGuiContainerForegroundLayer()
+    protected void drawGuiContainerForegroundLayer(int par1, int par2)
     {
         fontRenderer.drawString(tileEntity.fullName, 45, 6, 0x404040);
         fontRenderer.drawString("Inventory", 8, (ySize - 96) + 2, 0x404040);

src/minecraft/net/uberkat/obsidian/client/GuiElectricMachine.java

@@ -18,7 +18,7 @@ public class GuiElectricMachine extends GuiContainer
     /**
      * Draw the foreground layer for the GuiContainer (everythin in front of the items)
      */
-    protected void drawGuiContainerForegroundLayer()
+    protected void drawGuiContainerForegroundLayer(int par1, int par2)
     {
         fontRenderer.drawString(tileEntity.fullName, 45, 6, 0x404040);
         fontRenderer.drawString("Inventory", 8, (ySize - 96) + 2, 0x404040);

src/minecraft/net/uberkat/obsidian/client/GuiGenerator.java

@@ -0,0 +1,47 @@
+package net.uberkat.obsidian.client;
+
+import org.lwjgl.opengl.GL11;
+
+import net.minecraft.src.*;
+import net.uberkat.obsidian.common.ContainerGenerator;
+import net.uberkat.obsidian.common.TileEntityGenerator;
+
+public class GuiGenerator extends GuiContainer
+{
+	public TileEntityGenerator tileEntity;
+	
+	public GuiGenerator(InventoryPlayer inventory, TileEntityGenerator tentity)
+    {
+        super(new ContainerGenerator(inventory, tentity));
+        tileEntity = tentity;
+    }
+
+    /**
+     * Draw the foreground layer for the GuiContainer (everythin in front of the items)
+     */
+	protected void drawGuiContainerForegroundLayer(int par1, int par2)
+    {
+        fontRenderer.drawString(tileEntity.fullName, 45, 6, 0x404040);
+        fontRenderer.drawString("Inventory", 8, (ySize - 96) + 2, 0x404040);
+    }
+
+    /**
+     * Draw the background layer for the GuiContainer (everything behind the items)
+     */
+    protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3)
+    {
+        int texture = mc.renderEngine.getTexture("/gui/GuiGenerator.png");
+        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+        mc.renderEngine.bindTexture(texture);
+        int guiWidth = (width - xSize) / 2;
+        int guiHeight = (height - ySize) / 2;
+        drawTexturedModalRect(guiWidth, guiHeight, 0, 0, xSize, ySize);
+        int displayInt;
+        
+        displayInt = tileEntity.getScaledFuelLevel(52);
+        drawTexturedModalRect(guiWidth + 7, guiHeight + 17 + 52 - displayInt, 176, 52 + 52 - displayInt, 4, displayInt);
+        
+        displayInt = tileEntity.getScaledEnergyLevel(52);
+        drawTexturedModalRect(guiWidth + 165, guiHeight + 17 + 52 - displayInt, 176, 52 - displayInt, 4, displayInt);
+    }
+}

src/minecraft/net/uberkat/obsidian/client/GuiPowerUnit.java

@@ -20,9 +20,9 @@ public class GuiPowerUnit extends GuiContainer
 		tileEntity = tentity;
 	}
 	
-	protected void drawGuiContainerForegroundLayer()
+	protected void drawGuiContainerForegroundLayer(int par1, int par2)
 	{
-		String capacityInfo = "Stored: " + ObsidianUtils.getDisplayedEnergyNoColor(tileEntity.energyStored) + "/" + ObsidianUtils.getDisplayedEnergyNoColor(tileEntity.maxEnergy);
+		String capacityInfo = "Stored: " + ObsidianUtils.getDisplayedEnergyNoColor(tileEntity.energyStored) + "/" + ObsidianUtils.getDisplayedEnergyNoColor(tileEntity.MAX_ENERGY);
 		String outputInfo = "Output: " + ObsidianUtils.getDisplayedEnergyNoColor(tileEntity.output) + "/t";
 		fontRenderer.drawString(tileEntity.getInvName(), 43, 6, 0x404040);
 		fontRenderer.drawString(capacityInfo, 45, 42, 0x404040);
@@ -39,7 +39,7 @@ public class GuiPowerUnit extends GuiContainer
         guiWidth = (width - xSize) / 2;
         guiHeight = (height - ySize) / 2;
         drawTexturedModalRect(guiWidth, guiHeight, 0, 0, xSize, ySize);
-        int scale = (int)(((double)tileEntity.energyStored / tileEntity.maxEnergy) * 72);
+        int scale = (int)(((double)tileEntity.energyStored / tileEntity.MAX_ENERGY) * 72);
         drawTexturedModalRect(guiWidth + 65, guiHeight + 17, 176, 0, scale, 20);
     }
 }

src/minecraft/net/uberkat/obsidian/client/GuiTheoreticalElementizer.java

@@ -14,9 +14,9 @@ public class GuiTheoreticalElementizer extends GuiAdvancedElectricMachine
         super(inventory, tentity);
     }
 
-    protected void drawGuiContainerForegroundLayer()
+    protected void drawGuiContainerForegroundLayer(int par1, int par2)
     {
-    	super.drawGuiContainerForegroundLayer();
+    	super.drawGuiContainerForegroundLayer(par1, par2);
     	String displayText = "";
         if(tileEntity.isActive)
         {