% Refactored the entire project to stop using MiscUtils everywhere possible, now it's gtPlusPlus.

8 files changed, 1444 insertions, 0 deletions

diff --git a/src/Java/gtPlusPlus/core/item/general/BedLocator_Base.java b/src/Java/gtPlusPlus/core/item/general/BedLocator_Base.java
new file mode 100644
index 0000000000..5a05ac7655
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/item/general/BedLocator_Base.java
@@ -0,0 +1,107 @@
+package gtPlusPlus.core.item.general;
+
+import gtPlusPlus.core.creative.AddToCreativeTab;
+import gtPlusPlus.core.lib.CORE;
+
+import java.util.List;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.world.World;
+
+public class BedLocator_Base extends Item{
+
+	public int bed_X = 0;
+	public int bed_Y = 0;
+	public int bed_Z = 0;
+	
+	public BedLocator_Base(String unlocalizedName) {
+		this.setUnlocalizedName(unlocalizedName);
+		this.setTextureName(CORE.MODID + ":" + unlocalizedName);
+		this.setMaxStackSize(1);	
+		this.setCreativeTab(AddToCreativeTab.tabMachines);
+	}
+
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	@Override
+	public void addInformation(ItemStack stack, EntityPlayer aPlayer, List list, boolean bool) {
+
+		
+		int NBT_X = bed_X;
+		int NBT_Y = bed_Y;
+		int NBT_Z = bed_Z;
+		
+
+		if (stack.stackTagCompound != null) {
+			NBT_X = stack.stackTagCompound.getInteger("pos_x");
+			NBT_Y = stack.stackTagCompound.getInteger("pos_y");
+			NBT_Z = stack.stackTagCompound.getInteger("pos_z");
+
+		String tempX = String.valueOf(NBT_X);
+		String tempY = String.valueOf(NBT_Y);
+		String tempZ = String.valueOf(NBT_Z);
+		String formattedX = EnumChatFormatting.DARK_RED+tempX+EnumChatFormatting.GRAY;
+		String formattedY = EnumChatFormatting.RED+tempY+EnumChatFormatting.GRAY;
+		String formattedZ = EnumChatFormatting.RED+tempZ+EnumChatFormatting.GRAY;
+
+		list.add(EnumChatFormatting.GRAY+"X: "+formattedX+".");
+		list.add(EnumChatFormatting.GRAY+"Y: "+formattedY+".");
+		list.add(EnumChatFormatting.GRAY+"Z: "+formattedZ+".");
+		super.addInformation(stack, aPlayer, list, bool);
+	}
+	}
+
+	//Ticking and NBT Handling
+	/* Called each tick as long the item is on a player inventory. Uses by maps to check if is on a player hand and
+	 * update it's contents.
+	 * 
+	 *  public int fuelRemaining = 0;
+	public int maximumFuel = 0;
+	public String fuelType = "";
+	public float heat = 0;
+	public float maxHeat = 5000;
+	 *  
+	 */
+	@Override
+	public void onCreated(ItemStack itemStack, World world, EntityPlayer player) { 
+		itemStack.stackTagCompound = new NBTTagCompound();
+		this.bed_X = 0;
+		this.bed_Y = 0;
+		this.bed_Z = 0;
+		itemStack.stackTagCompound.setInteger("pos_x", bed_X);
+		itemStack.stackTagCompound.setInteger("pos_y", bed_Y);
+		itemStack.stackTagCompound.setInteger("pos_z", bed_Z);
+	}
+
+	@Override
+	public void onUpdate(ItemStack itemStack, World par2World, Entity par3Entity, int par4, boolean par5) {
+		
+
+	}
+
+	@Override
+	public ItemStack onItemRightClick(ItemStack itemStack, World world, EntityPlayer par3Entity) {
+		itemStack.stackTagCompound = new NBTTagCompound();
+		if (par3Entity.getBedLocation() != null){
+		this.bed_X = par3Entity.getBedLocation().posX;
+		this.bed_Y = par3Entity.getBedLocation().posY;
+		this.bed_Z = par3Entity.getBedLocation().posZ;
+		}
+		else {
+			this.bed_X = 0;
+			this.bed_Y = 0;
+			this.bed_Z = 0;
+		}
+		itemStack.stackTagCompound.setInteger("pos_x", bed_X);
+		itemStack.stackTagCompound.setInteger("pos_y", bed_Y);
+		itemStack.stackTagCompound.setInteger("pos_z", bed_Z);
+		return super.onItemRightClick(itemStack, world, par3Entity);
+	}
+
+
+
+}
diff --git a/src/Java/gtPlusPlus/core/item/general/BufferCore.java b/src/Java/gtPlusPlus/core/item/general/BufferCore.java
new file mode 100644
index 0000000000..6343ede855
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/item/general/BufferCore.java
@@ -0,0 +1,93 @@
+package gtPlusPlus.core.item.general;
+
+import gtPlusPlus.core.item.base.BaseItemWithDamageValue;
+import gtPlusPlus.core.lib.CORE;
+
+import java.util.List;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BufferCore extends BaseItemWithDamageValue{
+	
+	public int coreTier = 0;
+	
+	public BufferCore(String unlocalizedName, int i) {
+		super(unlocalizedName);
+		this.setTextureName(CORE.MODID + ":" + unlocalizedName);
+		this.setMaxStackSize(2);
+		this.coreTier = i;
+	}
+
+	@Override
+	public String getItemStackDisplayName(ItemStack stack) {
+		return super.getItemStackDisplayName(stack)+" ["+CORE.VOLTAGES[this.coreTier-1]+"].";
+	}
+	
+	@Override
+	@SideOnly(Side.CLIENT)
+    public boolean requiresMultipleRenderPasses()
+    {
+        return true;
+    }
+
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	@Override
+	public void addInformation(ItemStack stack, EntityPlayer aPlayer, List list, boolean bool) {
+		list.add(EnumChatFormatting.GRAY+"A key crafting component for making energy buffers.");
+		super.addInformation(stack, aPlayer, list, bool);
+	}
+
+	public final int getCoreTier() {
+		return coreTier;
+	}
+
+	@Override
+	public int getColorFromItemStack(ItemStack stack, int HEX_OxFFFFFF) {
+		//Figure Out Damage
+		String s = String.format("%X", HEX_OxFFFFFF);
+		//Utils.LOG_INFO(s);
+		//String rgb = Utils.hex2Rgb(s);
+		//Utils.LOG_INFO(rgb);
+		if (coreTier == 1){
+			HEX_OxFFFFFF = 0x4d4d4d;
+		}
+		else if (coreTier == 2){
+			HEX_OxFFFFFF = 0x666666;
+		}
+		else if (coreTier == 3){
+			HEX_OxFFFFFF = 0x8c8c8c;
+		}
+		else if (coreTier == 4){
+			HEX_OxFFFFFF = 0xa6a6a6;
+		}
+		else if (coreTier == 5){
+			HEX_OxFFFFFF = 0xcccccc;
+		}
+		else if (coreTier == 6){
+			HEX_OxFFFFFF = 0xe6e6e6;
+		}
+		else if (coreTier == 7){
+			HEX_OxFFFFFF = 0xffffcc;
+		}
+		else if (coreTier == 8){
+			HEX_OxFFFFFF = 0xace600;
+		}
+		else if (coreTier == 9){
+			HEX_OxFFFFFF = 0xffff00;
+		}
+		else if (coreTier == 10){
+			HEX_OxFFFFFF = 0xff0000;
+		}
+		else {
+			HEX_OxFFFFFF = 0xffffff;
+		}
+
+		
+		return HEX_OxFFFFFF;
+	}
+	
+}
diff --git a/src/Java/gtPlusPlus/core/item/general/ItemCloakingDevice.java b/src/Java/gtPlusPlus/core/item/general/ItemCloakingDevice.java
new file mode 100644
index 0000000000..22b6ed27f1
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/item/general/ItemCloakingDevice.java
@@ -0,0 +1,256 @@
+package gtPlusPlus.core.item.general;
+
+import gtPlusPlus.core.creative.AddToCreativeTab;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.item.UtilsItems;
+import gtPlusPlus.core.util.math.MathUtils;
+import ic2.api.item.ElectricItem;
+import ic2.api.item.IElectricItem;
+import ic2.api.item.IElectricItemManager;
+
+import java.util.List;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.world.World;
+import baubles.api.BaubleType;
+import baubles.api.IBauble;
+import cpw.mods.fml.common.registry.GameRegistry;
+
+public class ItemCloakingDevice extends Item implements IElectricItem, IElectricItemManager, IBauble{
+
+	private final String unlocalizedName = "personalCloakingDevice";
+	private final ItemStack thisStack;
+	private final static int maxValueEU = 10000*20*500;
+	protected double chargeEU = 0;
+
+	public ItemCloakingDevice(double charge){
+		this.chargeEU = charge;
+		this.setCreativeTab(AddToCreativeTab.tabMachines);
+		this.setUnlocalizedName(unlocalizedName);
+		this.setMaxStackSize(1);
+		this.setTextureName(CORE.MODID + ":" + "personalCloakingDevice");
+		this.thisStack = UtilsItems.getSimpleStack(this);
+		this.charge(thisStack, charge, 3, true, false);
+		if (charge == 10000*20*500){
+			this.setDamage(thisStack, 13);	
+		}
+		GameRegistry.registerItem(this, unlocalizedName+"-"+charge);
+	}
+
+	@Override
+	public void onUpdate(ItemStack itemStack, World worldObj, Entity player, int p_77663_4_, boolean p_77663_5_) {
+		if (worldObj.isRemote) {
+			return;
+		}
+
+		if (player instanceof EntityPlayer){
+			for (ItemStack is : ((EntityPlayer) player).inventory.mainInventory) {
+				if (is == itemStack) {
+					continue;
+				}
+				if (is != null) {
+					if (is.getItem() instanceof IElectricItem) {
+						IElectricItem electricItem = (IElectricItem) is.getItem();
+						chargeEU = ElectricItem.manager.getCharge(is);
+					}
+
+				}
+			}
+		}
+
+
+		super.onUpdate(itemStack, worldObj, player, p_77663_4_, p_77663_5_);
+	}
+
+	@Override
+	public boolean canProvideEnergy(ItemStack itemStack) {
+		return true;
+	}
+
+	@Override
+	public Item getChargedItem(ItemStack itemStack) {
+		ItemStack x = itemStack.copy();
+		x.setItemDamage(maxValueEU);
+		return x.getItem();
+	}
+
+	@Override
+	public Item getEmptyItem(ItemStack itemStack) {
+		ItemStack x = itemStack.copy();
+		x.setItemDamage(0);
+		return x.getItem();
+	}
+
+	@Override
+	public double getMaxCharge(ItemStack itemStack) {
+		return maxValueEU;
+	}
+
+	@Override
+	public int getTier(ItemStack itemStack) {
+		return 5;
+	}
+
+	@Override
+	public double getTransferLimit(ItemStack itemStack) {
+		return 8196;
+	}
+
+	@Override
+	public String getItemStackDisplayName(ItemStack p_77653_1_) {
+
+		return (EnumChatFormatting.BLUE+"Personal Cloaking Device"+EnumChatFormatting.GRAY);
+	}
+
+	@Override
+	public double getDurabilityForDisplay(ItemStack stack)
+	{
+		//return 1.0D - getEnergyStored(stack) / this.capacity;
+		return  1.0D - (double)getCharge(stack) / (double)getMaxCharge(stack);
+	}
+
+	@Override
+	public boolean showDurabilityBar(ItemStack stack)
+	{
+		return true;
+	}
+	
+	public int secondsLeft(ItemStack stack){
+		double r = 0;
+		r = getCharge(stack)/(10000*20);
+		return (int) MathUtils.decimalRounding(r);
+	}
+
+	@Override
+	public void addInformation(ItemStack stack, EntityPlayer aPlayer, List list, boolean bool) {				
+		list.add("");				
+		list.add(EnumChatFormatting.GREEN+"Worn as a Belt within Baubles."+EnumChatFormatting.GRAY);	
+		list.add(EnumChatFormatting.GREEN+"Drains 10,000EU/t to provide invisibility."+EnumChatFormatting.GRAY);			
+		list.add("");			
+		list.add(EnumChatFormatting.GOLD+"IC2/EU Information"+EnumChatFormatting.GRAY);	
+		list.add(EnumChatFormatting.GRAY+"Tier: ["+EnumChatFormatting.YELLOW+getTier(thisStack)+EnumChatFormatting.GRAY+"] Input Limit: ["+EnumChatFormatting.YELLOW+getTransferLimit(thisStack)+EnumChatFormatting.GRAY +"EU/t]");
+		list.add(EnumChatFormatting.GRAY+"Current Power: ["+EnumChatFormatting.YELLOW+(long) getCharge(stack)+EnumChatFormatting.GRAY+"EU] ["+EnumChatFormatting.YELLOW+MathUtils.findPercentage(getCharge(stack), getMaxCharge(stack))+EnumChatFormatting.GRAY +"%]");
+		list.add(EnumChatFormatting.GRAY+"Time Remaining: ["+EnumChatFormatting.YELLOW+secondsLeft(stack)+ EnumChatFormatting.GRAY +" seconds]");
+		super.addInformation(stack, aPlayer, list, bool);
+	}
+
+	/*@Override
+	public ItemStack getContainerItem(ItemStack itemStack)
+	{
+		ItemStack newItem = itemStack.copy();
+		newItem.stackSize = 1;
+		extractEnergy(newItem, 150000, false);
+		return newItem;
+	}*/
+
+	/*@Override
+	public boolean hasContainerItem(ItemStack stack)
+	{
+		return true;
+	}*/
+
+	/*@Override
+	public int getBurnTime(ItemStack fuel) {
+		if ((fuel == null) || (fuel.getItem() != this)) {
+			return 0;
+		}
+		return extractEnergy(fuel, 150000, true) / 50 / 100;
+	}*/
+
+	@Override
+	public double charge(ItemStack stack, double amount, int tier,
+			boolean ignoreTransferLimit, boolean simulate) {		 
+
+		if (!simulate)
+		{
+			ElectricItem.manager.charge(stack, amount, tier, true, simulate);
+
+		}
+		return ElectricItem.manager.charge(stack, amount, tier, true, simulate);
+	}
+
+	@Override
+	public double discharge(ItemStack stack, double amount, int tier,
+			boolean ignoreTransferLimit, boolean externally, boolean simulate) {		
+		if (!simulate)
+		{
+			ElectricItem.manager.discharge(stack, amount, tier, ignoreTransferLimit, externally, simulate);
+		}
+
+		return ElectricItem.manager.discharge(stack, amount, tier, ignoreTransferLimit, externally, simulate);
+	}
+
+	@Override
+	public double getCharge(ItemStack stack) {
+		return ElectricItem.manager.getCharge(stack);
+	}
+
+	@Override
+	public boolean canUse(ItemStack stack, double amount) {
+		return ElectricItem.manager.canUse(stack, amount);
+	}
+
+	@Override
+	public boolean use(ItemStack stack, double amount, EntityLivingBase entity) {
+		return ElectricItem.manager.use(stack, amount, entity);
+	}
+
+	@Override
+	public void chargeFromArmor(ItemStack stack, EntityLivingBase entity) {
+		ElectricItem.manager.chargeFromArmor(stack, entity);
+	}
+
+	@Override
+	public String getToolTip(ItemStack stack) {
+		return ElectricItem.manager.getToolTip(stack);
+	}
+
+	@Override
+	public boolean canEquip(ItemStack arg0, EntityLivingBase arg1) {
+		return true;
+	}
+
+	@Override
+	public boolean canUnequip(ItemStack arg0, EntityLivingBase arg1) {
+		return true;
+	}
+
+	@Override
+	public BaubleType getBaubleType(ItemStack arg0) {
+		return BaubleType.BELT;
+	}
+
+	@Override //TODO
+	public void onEquipped(ItemStack arg0, EntityLivingBase arg1) {
+
+	}
+
+	@Override //TODO
+	public void onUnequipped(ItemStack arg0, EntityLivingBase arg1) {
+
+	}
+
+	@Override //TODO
+	public void onWornTick(ItemStack arg0, EntityLivingBase arg1) {
+		//Utils.LOG_INFO("Trying to Tick Belt. 1");
+		if (!arg1.worldObj.isRemote){
+			if (getCharge(arg0) >= 10000){
+				arg1.addPotionEffect(new PotionEffect(Potion.invisibility.id, 10, 2));
+				discharge(arg0, 10000, 5, true, true, false);
+			}
+			else {
+				if (arg1.isPotionActive((Potion.invisibility))){
+					arg1.removePotionEffect(Potion.invisibility.id);
+				}
+			}
+		}
+	}
+
+}
diff --git a/src/Java/gtPlusPlus/core/item/general/ItemHealingDevice.java b/src/Java/gtPlusPlus/core/item/general/ItemHealingDevice.java
new file mode 100644
index 0000000000..728d498e2b
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/item/general/ItemHealingDevice.java
@@ -0,0 +1,228 @@
+package gtPlusPlus.core.item.general;
+
+import gtPlusPlus.core.creative.AddToCreativeTab;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.item.UtilsItems;
+import gtPlusPlus.core.util.math.MathUtils;
+import ic2.api.item.ElectricItem;
+import ic2.api.item.IElectricItem;
+import ic2.api.item.IElectricItemManager;
+
+import java.util.List;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.world.World;
+import baubles.api.BaubleType;
+import baubles.api.IBauble;
+import cpw.mods.fml.common.registry.GameRegistry;
+
+public class ItemHealingDevice extends Item implements IElectricItem, IElectricItemManager, IBauble{
+
+	private final String unlocalizedName = "personalHealingDevice";
+	private final ItemStack thisStack;
+	private final static int maxValueEU = 1000000000;
+	protected double chargeEU = 0;
+
+	public ItemHealingDevice(){
+		this.setCreativeTab(AddToCreativeTab.tabMachines);
+		this.setUnlocalizedName(unlocalizedName);
+		this.setMaxStackSize(1);
+		this.setTextureName(CORE.MODID + ":" + "personalCloakingDevice");
+		this.thisStack = UtilsItems.getSimpleStack(this);
+		GameRegistry.registerItem(this, unlocalizedName);
+	}
+
+	@Override
+	public void onUpdate(ItemStack itemStack, World worldObj, Entity player, int p_77663_4_, boolean p_77663_5_) {
+		if (worldObj.isRemote) {
+			return;
+		}
+
+		if (player instanceof EntityPlayer){
+			for (ItemStack is : ((EntityPlayer) player).inventory.mainInventory) {
+				if (is == itemStack) {
+					continue;
+				}
+				if (is != null) {
+					if (is.getItem() instanceof IElectricItem) {
+						IElectricItem electricItem = (IElectricItem) is.getItem();
+						chargeEU = ElectricItem.manager.getCharge(is);
+					}
+
+				}
+			}
+		}
+
+
+		super.onUpdate(itemStack, worldObj, player, p_77663_4_, p_77663_5_);
+	}
+
+	@Override
+	public boolean canProvideEnergy(ItemStack itemStack) {
+		return true;
+	}
+
+	@Override
+	public Item getChargedItem(ItemStack itemStack) {
+		ItemStack x = itemStack.copy();
+		x.setItemDamage(maxValueEU);
+		return x.getItem();
+	}
+
+	@Override
+	public Item getEmptyItem(ItemStack itemStack) {
+		ItemStack x = itemStack.copy();
+		x.setItemDamage(0);
+		return x.getItem();
+	}
+
+	@Override
+	public double getMaxCharge(ItemStack itemStack) {
+		return maxValueEU;
+	}
+
+	@Override
+	public int getTier(ItemStack itemStack) {
+		return 5;
+	}
+
+	@Override
+	public double getTransferLimit(ItemStack itemStack) {
+		return 32784;
+	}
+
+	@Override
+	public String getItemStackDisplayName(ItemStack p_77653_1_) {
+
+		return (EnumChatFormatting.BLUE+"Personal Healing NanoBooster"+EnumChatFormatting.RESET);
+	}
+
+	@Override
+	public double getDurabilityForDisplay(ItemStack stack)
+	{
+		//return 1.0D - getEnergyStored(stack) / this.capacity;
+		return  1.0D - (double)getCharge(stack) / (double)getMaxCharge(stack);
+	}
+
+	@Override
+	public boolean showDurabilityBar(ItemStack stack)
+	{
+		return true;
+	}
+	
+	public double secondsLeft(ItemStack stack){
+		
+		double r = 0;
+		r = getCharge(stack)/(1638400/4);
+		return (int) r;
+	}
+
+	@Override
+	public void addInformation(ItemStack stack, EntityPlayer aPlayer, List list, boolean bool) {				
+		list.add("");				
+		list.add(EnumChatFormatting.GREEN+"Worn as a Necklace within Baubles."+EnumChatFormatting.GRAY);	
+		list.add(EnumChatFormatting.GREEN+"Drains 1638400eu to restore hunger."+EnumChatFormatting.GRAY);			
+		list.add("");			
+		list.add(EnumChatFormatting.GOLD+"IC2/EU Information"+EnumChatFormatting.GRAY);	
+		list.add(EnumChatFormatting.GRAY+"Tier: ["+EnumChatFormatting.YELLOW+getTier(thisStack)+EnumChatFormatting.GRAY+"] Transfer Limit: ["+EnumChatFormatting.YELLOW+getTransferLimit(thisStack)+EnumChatFormatting.GRAY +"Eu/t]");
+		list.add(EnumChatFormatting.GRAY+"Current Power: ["+EnumChatFormatting.YELLOW+(long) getCharge(stack)+EnumChatFormatting.GRAY+"Eu] ["+EnumChatFormatting.YELLOW+MathUtils.findPercentage(getCharge(stack), getMaxCharge(stack))+EnumChatFormatting.GRAY +"%]");
+		list.add(EnumChatFormatting.GRAY+"Uses Remaining: ["+EnumChatFormatting.YELLOW+secondsLeft(stack)+ EnumChatFormatting.GRAY +"]");
+		super.addInformation(stack, aPlayer, list, bool);
+	}
+
+	@Override
+	public double charge(ItemStack stack, double amount, int tier,
+			boolean ignoreTransferLimit, boolean simulate) {		 
+
+		if (!simulate)
+		{
+			ElectricItem.manager.charge(stack, amount, tier, true, simulate);
+
+		}
+		return ElectricItem.manager.charge(stack, amount, tier, true, simulate);
+	}
+
+	@Override
+	public double discharge(ItemStack stack, double amount, int tier,
+			boolean ignoreTransferLimit, boolean externally, boolean simulate) {		
+		if (!simulate)
+		{
+			ElectricItem.manager.discharge(stack, amount, tier, ignoreTransferLimit, externally, simulate);
+		}
+
+		return ElectricItem.manager.discharge(stack, amount, tier, ignoreTransferLimit, externally, simulate);
+	}
+
+	@Override
+	public double getCharge(ItemStack stack) {
+		return ElectricItem.manager.getCharge(stack);
+	}
+
+	@Override
+	public boolean canUse(ItemStack stack, double amount) {
+		return ElectricItem.manager.canUse(stack, amount);
+	}
+
+	@Override
+	public boolean use(ItemStack stack, double amount, EntityLivingBase entity) {
+		return ElectricItem.manager.use(stack, amount, entity);
+	}
+
+	@Override
+	public void chargeFromArmor(ItemStack stack, EntityLivingBase entity) {
+		ElectricItem.manager.chargeFromArmor(stack, entity);
+	}
+
+	@Override
+	public String getToolTip(ItemStack stack) {
+		return ElectricItem.manager.getToolTip(stack);
+	}
+
+	@Override
+	public boolean canEquip(ItemStack arg0, EntityLivingBase arg1) {
+		return true;
+	}
+
+	@Override
+	public boolean canUnequip(ItemStack arg0, EntityLivingBase arg1) {
+		return true;
+	}
+
+	@Override
+	public BaubleType getBaubleType(ItemStack arg0) {
+		return BaubleType.AMULET;
+	}
+
+	@Override //TODO
+	public void onEquipped(ItemStack arg0, EntityLivingBase arg1) {
+
+	}
+
+	@Override //TODO
+	public void onUnequipped(ItemStack arg0, EntityLivingBase arg1) {
+
+	}
+
+	@Override //TODO
+	public void onWornTick(ItemStack arg0, EntityLivingBase arg1) {
+		if (!arg1.worldObj.isRemote){
+			if (getCharge(arg0) >= 1638400/4){
+				if (arg1.getHealth() < arg1.getMaxHealth()){
+					float rx = arg1.getMaxHealth()-arg1.getHealth();
+					Utils.LOG_INFO("rx:"+rx);
+				arg1.heal(rx*2);
+				discharge(arg0, (1638400/4)*rx, 6, true, true, false);
+				Utils.messagePlayer((EntityPlayer) arg1, "Your NanoBooster Whirs! Leaving you feeling stronger. It Healed "+rx+" hp.");
+				Utils.messagePlayer((EntityPlayer) arg1, "You check it's remaining uses, it has "+secondsLeft(arg0)+".");
+				}
+			}
+		}
+	}
+
+}
diff --git a/src/Java/gtPlusPlus/core/item/general/NuclearFuelRodBase.java b/src/Java/gtPlusPlus/core/item/general/NuclearFuelRodBase.java
new file mode 100644
index 0000000000..f452b83a73
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/item/general/NuclearFuelRodBase.java
@@ -0,0 +1,210 @@
+package gtPlusPlus.core.item.general;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.player.FillBucketEvent;
+import cpw.mods.fml.common.eventhandler.Event;
+
+public class NuclearFuelRodBase extends Item
+{
+    /** field for checking if the bucket has been filled. */
+    private Block isFull;
+    public NuclearFuelRodBase(Block p_i45331_1_)
+    {
+        this.maxStackSize = 1;
+        this.isFull = p_i45331_1_;
+        this.setCreativeTab(CreativeTabs.tabMisc);
+    }
+
+    /**
+     * Called whenever this item is equipped and the right mouse button is pressed. Args: itemStack, world, entityPlayer
+     */
+    @Override
+	public ItemStack onItemRightClick(ItemStack p_77659_1_, World p_77659_2_, EntityPlayer p_77659_3_)
+    {
+        boolean flag = this.isFull == Blocks.air;
+        MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(p_77659_2_, p_77659_3_, flag);
+
+        if (movingobjectposition == null)
+        {
+            return p_77659_1_;
+        }
+		FillBucketEvent event = new FillBucketEvent(p_77659_3_, p_77659_1_, p_77659_2_, movingobjectposition);
+		if (MinecraftForge.EVENT_BUS.post(event))
+		{
+		    return p_77659_1_;
+		}
+
+		if (event.getResult() == Event.Result.ALLOW)
+		{
+		    if (p_77659_3_.capabilities.isCreativeMode)
+		    {
+		        return p_77659_1_;
+		    }
+
+		    if (--p_77659_1_.stackSize <= 0)
+		    {
+		        return event.result;
+		    }
+
+		    if (!p_77659_3_.inventory.addItemStackToInventory(event.result))
+		    {
+		        p_77659_3_.dropPlayerItemWithRandomChoice(event.result, false);
+		    }
+
+		    return p_77659_1_;
+		}
+		if (movingobjectposition.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
+		{
+		    int i = movingobjectposition.blockX;
+		    int j = movingobjectposition.blockY;
+		    int k = movingobjectposition.blockZ;
+
+		    if (!p_77659_2_.canMineBlock(p_77659_3_, i, j, k))
+		    {
+		        return p_77659_1_;
+		    }
+
+		    if (flag)
+		    {
+		        if (!p_77659_3_.canPlayerEdit(i, j, k, movingobjectposition.sideHit, p_77659_1_))
+		        {
+		            return p_77659_1_;
+		        }
+
+		        Material material = p_77659_2_.getBlock(i, j, k).getMaterial();
+		        int l = p_77659_2_.getBlockMetadata(i, j, k);
+
+		        if (material == Material.water && l == 0)
+		        {
+		            p_77659_2_.setBlockToAir(i, j, k);
+		            return this.func_150910_a(p_77659_1_, p_77659_3_, Items.water_bucket);
+		        }
+
+		        if (material == Material.lava && l == 0)
+		        {
+		            p_77659_2_.setBlockToAir(i, j, k);
+		            return this.func_150910_a(p_77659_1_, p_77659_3_, Items.lava_bucket);
+		        }
+		    }
+		    else
+		    {
+		        if (this.isFull == Blocks.air)
+		        {
+		            return new ItemStack(Items.bucket);
+		        }
+
+		        if (movingobjectposition.sideHit == 0)
+		        {
+		            --j;
+		        }
+
+		        if (movingobjectposition.sideHit == 1)
+		        {
+		            ++j;
+		        }
+
+		        if (movingobjectposition.sideHit == 2)
+		        {
+		            --k;
+		        }
+
+		        if (movingobjectposition.sideHit == 3)
+		        {
+		            ++k;
+		        }
+
+		        if (movingobjectposition.sideHit == 4)
+		        {
+		            --i;
+		        }
+
+		        if (movingobjectposition.sideHit == 5)
+		        {
+		            ++i;
+		        }
+
+		        if (!p_77659_3_.canPlayerEdit(i, j, k, movingobjectposition.sideHit, p_77659_1_))
+		        {
+		            return p_77659_1_;
+		        }
+
+		        if (this.tryPlaceContainedLiquid(p_77659_2_, i, j, k) && !p_77659_3_.capabilities.isCreativeMode)
+		        {
+		            return new ItemStack(Items.bucket);
+		        }
+		    }
+		}
+
+		return p_77659_1_;
+    }
+
+    @SuppressWarnings("static-method")
+	private ItemStack func_150910_a(ItemStack p_150910_1_, EntityPlayer p_150910_2_, Item p_150910_3_)
+    {
+        if (p_150910_2_.capabilities.isCreativeMode)
+        {
+            return p_150910_1_;
+        }
+        else if (--p_150910_1_.stackSize <= 0)
+        {
+            return new ItemStack(p_150910_3_);
+        }
+        else
+        {
+            if (!p_150910_2_.inventory.addItemStackToInventory(new ItemStack(p_150910_3_)))
+            {
+                p_150910_2_.dropPlayerItemWithRandomChoice(new ItemStack(p_150910_3_, 1, 0), false);
+            }
+
+            return p_150910_1_;
+        }
+    }
+
+    /**
+     * Attempts to place the liquid contained inside the bucket.
+     */
+    public boolean tryPlaceContainedLiquid(World p_77875_1_, int p_77875_2_, int p_77875_3_, int p_77875_4_)
+    {
+        if (this.isFull == Blocks.air)
+        {
+            return false;
+        }
+		Material material = p_77875_1_.getBlock(p_77875_2_, p_77875_3_, p_77875_4_).getMaterial();
+		boolean flag = !material.isSolid();
+
+		if (!p_77875_1_.isAirBlock(p_77875_2_, p_77875_3_, p_77875_4_) && !flag)
+		{
+		    return false;
+		}
+		if (p_77875_1_.provider.isHellWorld && this.isFull == Blocks.flowing_water)
+		{
+		    p_77875_1_.playSoundEffect((double)((float)p_77875_2_ + 0.5F), (double)((float)p_77875_3_ + 0.5F), (double)((float)p_77875_4_ + 0.5F), "random.fizz", 0.5F, 2.6F + (p_77875_1_.rand.nextFloat() - p_77875_1_.rand.nextFloat()) * 0.8F);
+
+		    for (int l = 0; l < 8; ++l)
+		    {
+		        p_77875_1_.spawnParticle("largesmoke", (double)p_77875_2_ + Math.random(), (double)p_77875_3_ + Math.random(), (double)p_77875_4_ + Math.random(), 0.0D, 0.0D, 0.0D);
+		    }
+		}
+		else
+		{
+		    if (!p_77875_1_.isRemote && flag && !material.isLiquid())
+		    {
+		        p_77875_1_.func_147480_a(p_77875_2_, p_77875_3_, p_77875_4_, true);
+		    }
+
+		    p_77875_1_.setBlock(p_77875_2_, p_77875_3_, p_77875_4_, this.isFull, 0, 3);
+		}
+
+		return true;
+    }
+}
\ No newline at end of file
diff --git a/src/Java/gtPlusPlus/core/item/general/RF2EU_Battery.java b/src/Java/gtPlusPlus/core/item/general/RF2EU_Battery.java
new file mode 100644
index 0000000000..f1141e1ef4
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/item/general/RF2EU_Battery.java
@@ -0,0 +1,314 @@
+package gtPlusPlus.core.item.general;
+
+import gtPlusPlus.core.creative.AddToCreativeTab;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.item.UtilsItems;
+import gtPlusPlus.core.util.math.MathUtils;
+import ic2.api.item.ElectricItem;
+import ic2.api.item.IElectricItem;
+import ic2.api.item.IElectricItemManager;
+
+import java.util.List;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.World;
+import cofh.api.energy.ItemEnergyContainer;
+import cpw.mods.fml.common.IFuelHandler;
+import cpw.mods.fml.common.registry.GameRegistry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class RF2EU_Battery extends ItemEnergyContainer implements IElectricItem, IElectricItemManager, IFuelHandler{
+
+	public static int rfPerEU = 4;
+	private final String unlocalizedName = "rfEUBattery";
+	private final ItemStack thisStack;
+	private final static int maxValueEU = 100000000;
+	private final static int maxValueRF = maxValueEU * rfPerEU;
+	protected double chargeEU = 0;
+
+	public RF2EU_Battery(){
+		super(maxValueRF, maxValueRF, maxValueRF);
+		GameRegistry.registerFuelHandler(this);
+		//this.setMaxDamage(Integer.MAX_VALUE);
+		//this.setDamage(UtilsItems.getSimpleStack(this), 0);
+		this.setCreativeTab(AddToCreativeTab.tabMachines);
+		this.setUnlocalizedName(unlocalizedName);
+		this.setMaxStackSize(1);
+		this.setTextureName(CORE.MODID + ":" + "itemIngot");
+		this.thisStack = UtilsItems.getSimpleStack(this);
+		GameRegistry.registerItem(this, unlocalizedName);
+	}
+
+	@Override
+	public void onUpdate(ItemStack itemStack, World worldObj, Entity player, int p_77663_4_, boolean p_77663_5_) {
+		getEnergyStored(itemStack);
+		if (worldObj.isRemote) {
+			return;
+		}
+
+		if (player instanceof EntityPlayer){
+			for (ItemStack is : ((EntityPlayer) player).inventory.mainInventory) {
+				if (is == itemStack) {
+					continue;
+				}
+				if (is != null) {
+					if (is.getItem() instanceof IElectricItem) {
+						IElectricItem electricItem = (IElectricItem) is.getItem();
+						chargeEU = ElectricItem.manager.getCharge(is);
+					}
+
+				}
+			}
+		}
+
+
+		super.onUpdate(itemStack, worldObj, player, p_77663_4_, p_77663_5_);
+	}
+
+	@Override
+	public boolean canProvideEnergy(ItemStack itemStack) {
+		return true;
+	}
+
+	@Override
+	public Item getChargedItem(ItemStack itemStack) {
+		ItemStack x = itemStack.copy();
+		x.setItemDamage(maxValueEU);
+		return x.getItem();
+	}
+
+	@Override
+	public Item getEmptyItem(ItemStack itemStack) {
+		ItemStack x = itemStack.copy();
+		x.setItemDamage(0);
+		return x.getItem();
+	}
+
+	@Override
+	public double getMaxCharge(ItemStack itemStack) {
+		return maxValueEU;
+	}
+
+	@Override
+	public int getTier(ItemStack itemStack) {
+		return 3;
+	}
+
+	@Override
+	public double getTransferLimit(ItemStack itemStack) {
+		return 8196;
+	}
+
+	@Override
+	public String getItemStackDisplayName(ItemStack p_77653_1_) {
+
+		return ("Universally Chargeable Battery");
+	}
+
+	@Override
+	public double getDurabilityForDisplay(ItemStack stack)
+	{
+		//return 1.0D - getEnergyStored(stack) / this.capacity;
+		return MathUtils.findPercentage(getEnergyStored(stack), getMaxEnergyStored(stack));
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public int getColorFromItemStack(ItemStack par1ItemStack, int par2)
+	{
+		int i = 30;
+
+		float f13 = (float)(Minecraft.getSystemTime() % 6000L) / 3000.0F * 3.141592F * 2.0F;
+
+		float t = 0.9F + 0.1F * MathHelper.cos(f13);
+
+		double v = 1.0D - getDurabilityForDisplay(par1ItemStack);
+
+		int r = i + (int)(v * (255 - i) * t);
+		if (r > 255) {
+			r = 255;
+		}
+		int g = i + (int)(v * (64 - i) * t);
+
+		return r << 16 | g << 8 | i;
+	}
+
+	@Override
+	public boolean showDurabilityBar(ItemStack stack)
+	{
+		return false;
+	}
+
+	@Override
+	public void addInformation(ItemStack stack, EntityPlayer aPlayer, List list, boolean bool) {			
+		list.add(EnumChatFormatting.YELLOW+"IC2/EU Information"+EnumChatFormatting.GRAY);	
+		list.add(EnumChatFormatting.GRAY+"Tier: ["+EnumChatFormatting.YELLOW+getTier(thisStack)+EnumChatFormatting.GRAY+"] Current Power: ["+EnumChatFormatting.YELLOW+(long) getCharge(stack)+EnumChatFormatting.GRAY+"/EU]");
+		list.add(EnumChatFormatting.GRAY+"Transfer Limit: ["+EnumChatFormatting.YELLOW+getTransferLimit(thisStack)+ EnumChatFormatting.GRAY +"Eu/t]" +"Burn Time: ["+EnumChatFormatting.YELLOW+getBurnTime(stack)/20+EnumChatFormatting.GRAY+"s]");
+		list.add("");
+		list.add(EnumChatFormatting.RED+"RF Information");
+		list.add(EnumChatFormatting.GRAY+"Extraction Rate: [" +EnumChatFormatting.RED+ this.maxExtract + EnumChatFormatting.GRAY + "Rf/t]" + " Insert Rate: [" +EnumChatFormatting.RED+ this.maxReceive+EnumChatFormatting.GRAY+"Rf/t]");
+		list.add(EnumChatFormatting.GRAY+"Current Charge: ["+EnumChatFormatting.RED+getEnergyStored(stack) + EnumChatFormatting.GRAY + "Rf / " + getMaxEnergyStored(stack)+"Rf] "+EnumChatFormatting.RED+MathUtils.findPercentage(getEnergyStored(stack), getMaxEnergyStored(stack))+EnumChatFormatting.GRAY+"%");
+		super.addInformation(stack, aPlayer, list, bool);
+	}
+
+	@Override
+	public ItemStack getContainerItem(ItemStack itemStack)
+	{
+		ItemStack newItem = itemStack.copy();
+		newItem.stackSize = 1;
+		extractEnergy(newItem, 150000, false);
+		return newItem;
+	}
+
+	@Override
+	public boolean hasContainerItem(ItemStack stack)
+	{
+		return true;
+	}
+
+	@Override
+	public int getBurnTime(ItemStack fuel) {
+		if ((fuel == null) || (fuel.getItem() != this)) {
+			return 0;
+		}
+		return extractEnergy(fuel, 150000, true) / 50 / 100;
+	}
+
+	@Override
+	public double charge(ItemStack stack, double amount, int tier,
+			boolean ignoreTransferLimit, boolean simulate) {		 
+		if (stack.stackTagCompound == null) {
+			stack.stackTagCompound = new NBTTagCompound();
+		}
+		int energy = stack.stackTagCompound.getInteger("Energy");
+		int energyReceived = Math.min(this.capacity - energy, Math.min(this.maxReceive, maxReceive));
+		if (!simulate)
+		{
+			energy += energyReceived;
+			stack.stackTagCompound.setInteger("Energy", energy);
+			ElectricItem.manager.discharge(stack, ElectricItem.manager.getCharge(stack), 3, true, true, false);
+			ElectricItem.manager.charge(stack, energy/rfPerEU, 3, true, false);
+			
+		}
+		return ElectricItem.manager.charge(stack, amount, tier, ignoreTransferLimit, simulate);
+	}
+
+	@Override
+	public double discharge(ItemStack stack, double amount, int tier,
+			boolean ignoreTransferLimit, boolean externally, boolean simulate) {
+		if ((stack.stackTagCompound == null) || (!stack.stackTagCompound.hasKey("Energy"))) {
+			double euCharge = getCharge(UtilsItems.getSimpleStack(this));
+			if (euCharge != 0 && euCharge >= 1){
+				return (int) (MathUtils.decimalRoundingToWholes(euCharge*rfPerEU));
+			}
+			return 0;
+		}
+		int energy = stack.stackTagCompound.getInteger("Energy");
+		int energyExtracted = Math.min(energy, Math.min(this.maxExtract, maxExtract));
+		if (!simulate)
+		{
+			energy -= energyExtracted;
+			stack.stackTagCompound.setInteger("Energy", energy);
+			ElectricItem.manager.discharge(stack, ElectricItem.manager.getCharge(stack), 3, true, true, false);
+			ElectricItem.manager.charge(stack, energy/rfPerEU, 3, true, false);
+		}
+		
+		return ElectricItem.manager.discharge(stack, amount, tier, ignoreTransferLimit, externally, simulate);
+	}
+
+	@Override
+	public double getCharge(ItemStack stack) {
+		return ElectricItem.manager.getCharge(stack);
+	}
+
+	@Override
+	public boolean canUse(ItemStack stack, double amount) {
+		return ElectricItem.manager.canUse(stack, amount);
+	}
+
+	@Override
+	public boolean use(ItemStack stack, double amount, EntityLivingBase entity) {
+		return ElectricItem.manager.use(stack, amount, entity);
+	}
+
+	@Override
+	public void chargeFromArmor(ItemStack stack, EntityLivingBase entity) {
+		ElectricItem.manager.chargeFromArmor(stack, entity);
+	}
+
+	@Override
+	public String getToolTip(ItemStack stack) {
+		return ElectricItem.manager.getToolTip(stack);
+	}
+
+	@Override
+	public int receiveEnergy(ItemStack container, int maxReceive, boolean simulate)
+	{
+		if ((container.stackTagCompound == null) || (!container.stackTagCompound.hasKey("Energy"))) {
+			double euCharge = getCharge(UtilsItems.getSimpleStack(this));
+			if (euCharge != 0 && euCharge >= 1){
+				return (int) (MathUtils.decimalRoundingToWholes(euCharge*rfPerEU));
+			}
+			return 0;
+		}
+		int energy = container.stackTagCompound.getInteger("Energy");
+		int energyReceived = Math.min(this.capacity - energy, Math.min(this.maxReceive, maxReceive));
+		if (!simulate)
+		{
+			energy += energyReceived;
+			container.stackTagCompound.setInteger("Energy", energy);
+			ElectricItem.manager.discharge(container, ElectricItem.manager.getCharge(container), 3, true, true, false);
+			ElectricItem.manager.charge(container, energy/rfPerEU, 3, true, false);
+			
+		}
+		return energyReceived;
+	}
+
+	@Override
+	public int extractEnergy(ItemStack container, int maxExtract, boolean simulate)
+	{
+		if ((container.stackTagCompound == null) || (!container.stackTagCompound.hasKey("Energy"))) {
+			double euCharge = getCharge(UtilsItems.getSimpleStack(this));
+			if (euCharge != 0 && euCharge >= 1){
+				return (int) (MathUtils.decimalRoundingToWholes(euCharge*rfPerEU));
+			}
+			return 0;
+		}
+		int energy = container.stackTagCompound.getInteger("Energy");
+		int energyExtracted = Math.min(energy, Math.min(this.maxExtract, maxExtract));
+		if (!simulate)
+		{
+			energy -= energyExtracted;
+			container.stackTagCompound.setInteger("Energy", energy);
+			ElectricItem.manager.discharge(container, ElectricItem.manager.getCharge(container), 3, true, true, false);
+			ElectricItem.manager.charge(container, energy/rfPerEU, 3, true, false);
+		}
+		return energyExtracted;
+	}
+
+	@Override
+	public int getEnergyStored(ItemStack container)
+	{
+		if ((container.stackTagCompound == null) || (!container.stackTagCompound.hasKey("Energy"))) {
+			double euCharge = getCharge(UtilsItems.getSimpleStack(this));
+			if (euCharge != 0 && euCharge >= 1){
+				return (int) (MathUtils.decimalRoundingToWholes(euCharge*rfPerEU));
+			}
+			return 0;
+		}
+		int energy = container.stackTagCompound.getInteger("Energy");
+		ElectricItem.manager.discharge(container, ElectricItem.manager.getCharge(container), 3, true, true, false);
+		ElectricItem.manager.charge(container, energy/rfPerEU, 3, true, false);
+		return energy;
+	}
+
+}
diff --git a/src/Java/gtPlusPlus/core/item/general/fuelrods/FuelRod_Base.java b/src/Java/gtPlusPlus/core/item/general/fuelrods/FuelRod_Base.java
new file mode 100644
index 0000000000..36e6c66df8
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/item/general/fuelrods/FuelRod_Base.java
@@ -0,0 +1,223 @@
+package gtPlusPlus.core.item.general.fuelrods;
+
+import gtPlusPlus.core.creative.AddToCreativeTab;
+import gtPlusPlus.core.lib.CORE;
+
+import java.util.List;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.world.World;
+
+public class FuelRod_Base extends Item{
+
+	public int fuelRemaining = 0;
+	public int maximumFuel = 0;
+	public String fuelType = "";
+	public float heat = 0;
+	public float maxHeat = getMaxHeat();
+	public FuelRod_Base(String unlocalizedName, String type, int fuelLeft, int maxFuel) {
+		this.setUnlocalizedName(unlocalizedName);
+		this.setTextureName(CORE.MODID + ":" + unlocalizedName);
+		this.setMaxStackSize(1);
+		this.setMaxDamage(maxFuel);
+		this.maximumFuel = maxFuel;
+		this.fuelRemaining = fuelLeft;
+		this.fuelType = type;
+		this.setCreativeTab(AddToCreativeTab.tabMachines);
+	}
+	
+	private float getMaxHeat(){
+		float tempvar;
+		if (fuelType == "Thorium"){
+			tempvar = 2500;
+		}
+		
+		else if (fuelType == "Uranium"){
+			tempvar = 5000;
+		}
+		
+		else if (fuelType == "Plutonium"){
+			tempvar = 10000;
+		}
+		
+		else {
+			tempvar = 5000;
+		}
+		return tempvar;
+		
+	}
+	
+	private void updateVars(ItemStack stack){
+		if (stack.stackTagCompound != null) {
+			heat = stack.stackTagCompound.getFloat("heat");
+			fuelRemaining = stack.stackTagCompound.getInteger("fuelRemaining");
+			}
+	}
+	
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	@Override
+	public void addInformation(ItemStack stack, EntityPlayer aPlayer, List list, boolean bool) {
+
+		Float NBT_Heat = heat;
+		Float NBT_MaxHeat = maxHeat;
+		int NBT_Fuel = fuelRemaining;
+		String NBT_Type= fuelType;
+
+		if (stack.stackTagCompound != null) {
+			NBT_Heat = stack.stackTagCompound.getFloat("heat");
+			NBT_MaxHeat = stack.stackTagCompound.getFloat("maxHeat");
+			NBT_Fuel = stack.stackTagCompound.getInteger("fuelRemaining");
+			NBT_Type = stack.stackTagCompound.getString("fuelType");
+			}
+
+		String tempHeat = String.valueOf(NBT_Heat);
+		String tempMaxHeat = String.valueOf(NBT_MaxHeat);
+		String tempFuel = String.valueOf(NBT_Fuel);
+		String formattedType = EnumChatFormatting.DARK_RED+NBT_Type+EnumChatFormatting.GRAY;
+		String formattedHeat = EnumChatFormatting.RED+tempHeat+EnumChatFormatting.GRAY;
+		String formattedMaxHeat = EnumChatFormatting.RED+tempMaxHeat+EnumChatFormatting.GRAY;
+		String formattedFuelLeft = tempFuel+EnumChatFormatting.GRAY;
+
+		int tempMax = maximumFuel;
+		float tempCurrentHeat = heat;
+		int tempFuelLeft = fuelRemaining;
+		
+		//Fuel Usage Formatting
+		if (tempFuelLeft <= maximumFuel/3){
+			formattedFuelLeft = EnumChatFormatting.RED+tempFuel+EnumChatFormatting.GRAY;
+		}
+		else if (tempFuelLeft >= maximumFuel/3 && tempFuelLeft <= (maximumFuel/3)*2){
+			formattedFuelLeft = EnumChatFormatting.YELLOW+tempFuel+EnumChatFormatting.GRAY;
+		}
+		else if (tempFuelLeft >= (maximumFuel/3)*2 && tempFuelLeft <= maximumFuel){
+			formattedFuelLeft = EnumChatFormatting.GREEN+tempFuel+EnumChatFormatting.GRAY;
+		}
+		else {
+			formattedFuelLeft = EnumChatFormatting.GRAY+tempFuel+EnumChatFormatting.GRAY;
+		}
+		
+		//Heat Formatting
+		if (tempCurrentHeat <= 200 && tempCurrentHeat >= 0){
+			formattedHeat = EnumChatFormatting.GRAY+tempHeat+EnumChatFormatting.GRAY;
+		}
+		else if (tempCurrentHeat <= maxHeat/3 && tempCurrentHeat > 200){
+			formattedHeat = EnumChatFormatting.YELLOW+tempHeat+EnumChatFormatting.GRAY;
+		}
+		else if (tempCurrentHeat >= maxHeat/3 && tempMax < (maxHeat/3)*2 && tempCurrentHeat != 0){
+			formattedHeat = EnumChatFormatting.GOLD+tempHeat+EnumChatFormatting.GRAY;
+		}
+		else if (tempCurrentHeat >= ((maxHeat/3)*2) && tempMax <= maxHeat && tempCurrentHeat != 0){
+			formattedHeat = EnumChatFormatting.RED+tempHeat+EnumChatFormatting.GRAY;
+		}
+		else {
+			formattedHeat = EnumChatFormatting.BLUE+tempHeat+EnumChatFormatting.GRAY;
+		}
+		list.add(EnumChatFormatting.GRAY+"A "+formattedType+" Fuel Rod.");
+		list.add(EnumChatFormatting.GRAY+"Running at "+formattedHeat+"/"+formattedMaxHeat+" Kelvin.");
+		list.add(EnumChatFormatting.GRAY+"Fuel Remaining: "+formattedFuelLeft+"L.");
+		super.addInformation(stack, aPlayer, list, bool);
+	}
+
+	public String getType(ItemStack stack){
+		if (stack.stackTagCompound != null){
+			return stack.stackTagCompound.getString("fuelType");
+			}
+			return fuelType;
+	}
+
+	public int getFuelRemaining(ItemStack stack){
+		if (stack.stackTagCompound != null){
+			return stack.stackTagCompound.getInteger("fuelRemaining");
+			}
+			return 0;
+	}
+
+	public int getMaxFuel(){
+		return maximumFuel;
+	}
+
+	public int getFuel(ItemStack stack){
+		if (stack != null){
+			int i = stack.getItemDamage();
+			int r = maximumFuel - i;
+			return r;
+		}
+		return getFuelRemaining(stack);
+	}
+
+	public boolean setFuelRemainingExplicitly(int i){
+		int tempFuel = fuelRemaining;
+		fuelRemaining = i;
+		if (i != tempFuel){
+			return true;
+		}		
+		return false;
+	}
+
+	public boolean addFuel(int i){
+		int tempFuel = fuelRemaining;
+		fuelRemaining = tempFuel+i;
+		if (fuelRemaining != tempFuel){
+			return true;
+		}		
+		return false;
+	}
+
+	public float getHeat(ItemStack value){
+		if (value.stackTagCompound != null){
+		return value.stackTagCompound.getFloat("heat");
+		}
+		return 0f;
+	}
+
+	public boolean addHeat(float i){
+		float tempFuel = heat;
+		heat = tempFuel+i;
+		if (heat != tempFuel){
+			return true;
+		}		
+		return false;
+	}
+
+
+	//Ticking and NBT Handling
+	/* Called each tick as long the item is on a player inventory. Uses by maps to check if is on a player hand and
+	 * update it's contents.
+	 * 
+	 *  public int fuelRemaining = 0;
+	public int maximumFuel = 0;
+	public String fuelType = "";
+	public float heat = 0;
+	public float maxHeat = 5000;
+	 *  
+	 */
+	@Override
+	public void onCreated(ItemStack itemStack, World world, EntityPlayer player) { 
+		itemStack.stackTagCompound = new NBTTagCompound();
+		itemStack.stackTagCompound.setInteger("fuelRemaining", getFuelRemaining(itemStack));
+		itemStack.stackTagCompound.setInteger("maximumFuel", maximumFuel);
+		itemStack.stackTagCompound.setFloat("heat", getHeat(itemStack));
+		itemStack.stackTagCompound.setFloat("maxHeat", getMaxHeat());
+		itemStack.stackTagCompound.setString("fuelType", getType(itemStack));
+		updateVars(itemStack);
+	}
+
+	@Override
+	public void onUpdate(ItemStack itemStack, World par2World, Entity par3Entity, int par4, boolean par5) {
+		itemStack.stackTagCompound = new NBTTagCompound();
+		itemStack.stackTagCompound.setInteger("fuelRemaining", getFuelRemaining(itemStack));
+		itemStack.stackTagCompound.setInteger("maximumFuel", maximumFuel);
+		itemStack.stackTagCompound.setFloat("heat", getHeat(itemStack));
+		itemStack.stackTagCompound.setFloat("maxHeat", getMaxHeat());
+		itemStack.stackTagCompound.setString("fuelType", getType(itemStack));
+		updateVars(itemStack);
+	}
+	
+	
+
+}
diff --git a/src/Java/gtPlusPlus/core/item/general/fuelrods/FuelRod_Thorium.java b/src/Java/gtPlusPlus/core/item/general/fuelrods/FuelRod_Thorium.java
new file mode 100644
index 0000000000..9b852cb1ea
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/item/general/fuelrods/FuelRod_Thorium.java
@@ -0,0 +1,13 @@
+package gtPlusPlus.core.item.general.fuelrods;
+
+public class FuelRod_Thorium extends FuelRod_Base{
+
+	public FuelRod_Thorium(String unlocalizedName, String type, int fuelLeft, int maxFuel) {
+		super(unlocalizedName, type, fuelLeft, maxFuel);
+		this.setMaxDamage(maxFuel);
+		this.maximumFuel = maxFuel;
+		this.fuelRemaining = fuelLeft;
+		this.fuelType = type;
+	}
+
+}