Wrappper Item

HeatedIngotFactory.java

package com.Orion.Armory.Common.Factory;
/*
/  HeatedIngotFactory
/  Created by : Orion
/  Created on : 03/10/2014
*/

import com.Orion.Armory.Common.Item.ItemHeatedItem;
import com.Orion.Armory.Common.Registry.GeneralRegistry;
import com.Orion.Armory.Util.Core.ItemStackHelper;
import com.Orion.Armory.Util.References;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;

import java.security.InvalidParameterException;
import java.util.ArrayList;
import java.util.Iterator;

public class HeatedIngotFactory
{
    public static HeatedIngotFactory iInstance = null;
    protected ArrayList<ItemStack> iHeatableItems = new ArrayList<ItemStack>();
    protected ArrayList<String> iMappedNames = new ArrayList<String>();

    public static HeatedIngotFactory getInstance()
    {
        if (iInstance == null)
        {
            iInstance = new HeatedIngotFactory();
        }

        return iInstance;
    }

    public ItemStack convertToHeatedIngot(ItemStack pCooledIngotStack)
    {
        if (!isHeatable(pCooledIngotStack))
        {
            GeneralRegistry.iLogger.info("Got a not convertable item!:");
            GeneralRegistry.iLogger.info(ItemStackHelper.toString(pCooledIngotStack));
            return null;
        }

        ItemStack tReturnStack = new ItemStack(GeneralRegistry.Items.iHeatedIngot);
        NBTTagCompound tStackCompound = new NBTTagCompound();

        tStackCompound.setTag(References.NBTTagCompoundData.HeatedIngot.ORIGINALITEM, pCooledIngotStack.writeToNBT(new NBTTagCompound()));
        tStackCompound.setString(References.NBTTagCompoundData.HeatedIngot.MATERIALID, getMaterialIDFromItemStack(pCooledIngotStack));
        tStackCompound.setInteger(References.NBTTagCompoundData.HeatedIngot.CURRENTTEMPERATURE, 20);

        tReturnStack.setTagCompound(tStackCompound);

        return tReturnStack;
    }

    public ItemStack convertToCooledIngot(ItemStack pHeatedItemStack)
    {
        if (!(pHeatedItemStack.getItem() instanceof ItemHeatedItem))
        {
            if (isHeatable(pHeatedItemStack))
            {
                return pHeatedItemStack;
            }

            throw new InvalidParameterException("The given parameter is not a heatable item. Please report this to the modder!");
        }

        ItemStack tReturnStack = ItemStack.loadItemStackFromNBT(pHeatedItemStack.getTagCompound().getCompoundTag(References.NBTTagCompoundData.HeatedIngot.ORIGINALITEM));

        return tReturnStack;
    }

    public void addHeatableItemstack(String pMaterialName, ItemStack pNewItemStack)
    {
        ItemStack tSingledItemStack = pNewItemStack.copy();
        tSingledItemStack.stackSize = 1;

        if (!isHeatable(tSingledItemStack))
        {
            this.iHeatableItems.add(tSingledItemStack);
            this.iMappedNames.add(pMaterialName);
        }
    }

    public String getMaterialIDFromItemStack(ItemStack pItemStack)
    {
        if (pItemStack.getItem() instanceof ItemHeatedItem)
        {
            return pItemStack.getTagCompound().getString(References.NBTTagCompoundData.HeatedIngot.MATERIALID);
        }

        ItemStack tSingledItemStack = pItemStack.copy();
        tSingledItemStack.stackSize = 1;

        if (isHeatable(tSingledItemStack))
        {
            return iMappedNames.get(getIndexOfStack(tSingledItemStack));
        }

        return "";
    }

    public float getMeltingPointFromMaterial(String pMaterialName)
    {
        return GeneralRegistry.getInstance().getMeltingPoint(pMaterialName);
    }

    public ArrayList<ItemStack> getAllMappedStacks()
    {
        return iHeatableItems;
    }

    public float getMeltingPointFromMaterial(ItemStack pItemStack)
    {
        return this.getMeltingPointFromMaterial(this.getMaterialIDFromItemStack(pItemStack));
    }

    public boolean isHeatable(ItemStack pItemStack)
    {
        ItemStack tSingledItemStack = pItemStack.copy();
        tSingledItemStack.stackSize = 1;

        Iterator<ItemStack> tStackIter = getAllMappedStacks().iterator();

        while (tStackIter.hasNext())
        {
            if (ItemStackHelper.equalsIgnoreStackSize(tStackIter.next(), tSingledItemStack))
            {
                return true;
            }
        }

        return false;
    }

    private int getIndexOfStack(ItemStack pStack) {
        Iterator<ItemStack> tStackIter = getAllMappedStacks().iterator();
        int tIndex = 0;

        while (tStackIter.hasNext()) {
            if (ItemStackHelper.equalsIgnoreStackSize(tStackIter.next(), pStack)) {
                return tIndex;
            }

            tIndex++;
        }

        return -1;
    }
}

ITemHeatedItem.java

package com.Orion.Armory.Common.Item;
/*
/  ItemHeatedItem
/  Created by : Orion
/  Created on : 03/10/2014
*/

import com.Orion.Armory.Common.Factory.HeatedIngotFactory;
import com.Orion.Armory.Common.Registry.GeneralRegistry;
import com.Orion.Armory.Util.Client.TranslationKeys;
import com.Orion.Armory.Util.References;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.IIcon;
import net.minecraft.util.StatCollector;

import java.util.Iterator;
import java.util.List;

public class ItemHeatedItem extends Item
{
    public ItemHeatedItem()
    {
        setMaxStackSize(1);
        setCreativeTab(GeneralRegistry.iTabArmoryComponents);
        setUnlocalizedName(References.InternalNames.Items.ItemHeatedIngot);
    }

    //Function for getting the Icon from a render pass.
    @Override
    public IIcon getIcon(ItemStack pStack, int pRenderPass) {
        ItemStack tOriginalItemStack = ItemStack.loadItemStackFromNBT(pStack.getTagCompound().getCompoundTag(References.NBTTagCompoundData.HeatedIngot.ORIGINALITEM));
        return tOriginalItemStack.getItem().getIcon(tOriginalItemStack, pRenderPass);
    }

     @Override
     public IIcon getIconIndex(ItemStack pStack)
     {
         return getIcon(pStack, 0);
     }

    //Function that tells the renderer to use multiple layers
    @Override
    public boolean requiresMultipleRenderPasses() {
        return false;
    }

    //Function that tells the renderer to use a certain color
    @Override
    public int getColorFromItemStack(ItemStack pStack, int pRenderPass) {
        ItemStack tOriginalItemStack = ItemStack.loadItemStackFromNBT(pStack.getTagCompound().getCompoundTag(References.NBTTagCompoundData.HeatedIngot.ORIGINALITEM));
        return tOriginalItemStack.getItem().getColorFromItemStack(tOriginalItemStack, pRenderPass);
    }

    @Override
    public boolean showDurabilityBar(ItemStack pStack)
    {
        return false;
    }

    @Override
    public double getDurabilityForDisplay(ItemStack pStack)
    {
        return  1 - (pStack.getTagCompound().getFloat(References.NBTTagCompoundData.HeatedIngot.CURRENTTEMPERATURE)) / (HeatedIngotFactory.getInstance().getMeltingPointFromMaterial(pStack));
    }

    @SideOnly(Side.CLIENT)
    @Override
    public void addInformation(ItemStack pStack, EntityPlayer pPlayer, List pTooltipList, boolean pBoolean)
    {
        String tTemperatureLine = StatCollector.translateToLocal(TranslationKeys.Items.HeatedIngot.TemperatureTag);
        tTemperatureLine = tTemperatureLine + ": " + Math.round(getItemTemperature(pStack));

        pTooltipList.add(tTemperatureLine);
    }

    @Override
    public boolean getHasSubtypes()
    {
        return true;
    }

    @SideOnly(Side.CLIENT)
    @Override
    public void getSubItems(Item pArmorCore, CreativeTabs pCreativeTab, List pItemStacks)
    {
        Iterator<ItemStack> tStackIter = HeatedIngotFactory.getInstance().getAllMappedStacks().iterator();

        while (tStackIter.hasNext())
        {
            ItemStack tCooledStack = tStackIter.next();
            ItemStack tHeatedStack = HeatedIngotFactory.getInstance().convertToHeatedIngot(tCooledStack);

            if (tHeatedStack != null)
            {
                pItemStacks.add(tHeatedStack);
            }
            else
            {
                GeneralRegistry.iLogger.info("Tried to create a HeatedIngot from: " + HeatedIngotFactory.getInstance().getMaterialIDFromItemStack(tCooledStack) + " and failed!");
            }
        }
    }

    @Override
    public String getItemStackDisplayName(ItemStack pStack)
    {
        ItemStack tOriginalItemStack = ItemStack.loadItemStackFromNBT(pStack.getTagCompound().getCompoundTag(References.NBTTagCompoundData.HeatedIngot.ORIGINALITEM));
        return tOriginalItemStack.getItem().getItemStackDisplayName(tOriginalItemStack);
    }

    public static void setItemTemperature(ItemStack pItemStack, float pNewTemp)
    {
        if (pItemStack.getItem() instanceof ItemHeatedItem)
        {
            pItemStack.getTagCompound().setFloat(References.NBTTagCompoundData.HeatedIngot.CURRENTTEMPERATURE, pNewTemp);
        }
    }

    public static float getItemTemperature(ItemStack pItemStack)
    {
        if (pItemStack.getItem() instanceof ItemHeatedItem)
        {
            return pItemStack.getTagCompound().getFloat(References.NBTTagCompoundData.HeatedIngot.CURRENTTEMPERATURE);
        }

        return 0F;
    }
}

ItemRendererHeatedItem.java

package com.Orion.Armory.Client.Renderer.Items;
/*
 *   ItemHeatedIngotRenderer
 *   Created by: Orion
 *   Created on: 17-1-2015
 */

import com.Orion.Armory.Common.Factory.HeatedIngotFactory;
import com.Orion.Armory.Common.Item.ItemHeatedItem;
import com.Orion.Armory.Util.Client.Color;
import com.Orion.Armory.Util.Client.Colors;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.entity.RenderItem;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.item.ItemStack;
import net.minecraftforge.client.IItemRenderer;
import org.lwjgl.opengl.GL11;

public class ItemHeatedIngotRenderer implements IItemRenderer
{

    @Override
    public boolean handleRenderType(ItemStack pItemStack, ItemRenderType pRenderType) {
        if ((pItemStack.getItem() instanceof ItemHeatedItem) && (pRenderType == ItemRenderType.INVENTORY)) { return true; }

        return false;
    }

    @Override
    public boolean shouldUseRenderHelper(ItemRenderType pRenderType, ItemStack pItemStack, ItemRendererHelper pRenderHelper) {
        return false;
    }

    @Override
    public void renderItem(ItemRenderType pRenderType, ItemStack pItemStack, Object... pDataArray) {
        if (!(pItemStack.getItem() instanceof ItemHeatedItem) || !(pRenderType == ItemRenderType.INVENTORY)) { return; }

        if ((pRenderType == ItemRenderType.INVENTORY) && (RenderManager.instance.renderEngine != null))
        {
            RenderItem.getInstance().renderItemIntoGUI(Minecraft.getMinecraft().fontRenderer, RenderManager.instance.renderEngine, HeatedIngotFactory.getInstance().convertToCooledIngot(pItemStack), 0,0);
            renderTemperatureBar(pItemStack);
        }
    }

    private void renderTemperatureBar(ItemStack pItemStack)
    {
        double health = pItemStack.getItem().getDurabilityForDisplay(pItemStack);
        int j1 = (int)Math.round(13.0D - health * 13.0D);
        int k = (int)Math.round(255.0D - health * 255.0D);
        GL11.glDisable(GL11.GL_LIGHTING);
        GL11.glDisable(GL11.GL_DEPTH_TEST);
        GL11.glDisable(GL11.GL_TEXTURE_2D);
        GL11.glDisable(GL11.GL_ALPHA_TEST);
        GL11.glDisable(GL11.GL_BLEND);
        Tessellator tessellator = Tessellator.instance;
        int i1 = Color.Combine(Colors.General.ELECTRICBLUE, Colors.General.RED, (j1 / 13)).getColor();
        int l = (255 - k) / 4 << 16 | 16128;
        this.renderQuad(tessellator, 2, 13, 13, 2, 0);
        this.renderQuad(tessellator, 2, 13, 12, 1, l);
        this.renderQuad(tessellator, 2, 13, j1, 1, i1);
        GL11.glEnable(GL11.GL_BLEND); // Forge: Disable Bled because it screws with a lot of things down the line.
        GL11.glEnable(GL11.GL_ALPHA_TEST);
        GL11.glEnable(GL11.GL_TEXTURE_2D);
        GL11.glEnable(GL11.GL_LIGHTING);
        GL11.glEnable(GL11.GL_DEPTH_TEST);
        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
    }

    private void renderQuad(Tessellator pTessellator, int p_77017_2_, int p_77017_3_, int p_77017_4_, int p_77017_5_, int pOpaque)
    {
        pTessellator.startDrawingQuads();
        pTessellator.setColorOpaque_I(pOpaque);
        pTessellator.addVertex((double) (p_77017_2_ + 0), (double) (p_77017_3_ + 0), 0.0D);
        pTessellator.addVertex((double) (p_77017_2_ + 0), (double) (p_77017_3_ + p_77017_5_), 0.0D);
        pTessellator.addVertex((double) (p_77017_2_ + p_77017_4_), (double) (p_77017_3_ + p_77017_5_), 0.0D);
        pTessellator.addVertex((double) (p_77017_2_ + p_77017_4_), (double) (p_77017_3_ + 0), 0.0D);
        pTessellator.draw();
    }
}