fix missing source folder

1 files changed, 366 insertions, 0 deletions

diff --git a/src/main/java/ihl/processing/metallurgy/Crucible.java b/src/main/java/ihl/processing/metallurgy/Crucible.java
new file mode 100644
index 0000000..220b505
--- /dev/null
+++ b/src/main/java/ihl/processing/metallurgy/Crucible.java
@@ -0,0 +1,366 @@
+package ihl.processing.metallurgy;

+

+import java.util.Arrays;

+import java.util.LinkedList;

+import java.util.List;

+import java.util.Map;

+

+import cpw.mods.fml.common.registry.GameRegistry;

+import cpw.mods.fml.relauncher.Side;

+import cpw.mods.fml.relauncher.SideOnly;

+import ic2.api.item.IItemHudInfo;

+import ic2.api.recipe.IRecipeInput;

+import ic2.api.recipe.RecipeInputOreDict;

+import ic2.core.IC2;

+import ic2.core.IHasGui;

+import ic2.core.item.IHandHeldInventory;

+import ic2.core.util.LiquidUtil;

+import ic2.core.util.StackUtil;

+import ihl.IHLCreativeTab;

+import ihl.IHLModInfo;

+import ihl.recipes.UniversalRecipeInput;

+import ihl.recipes.UniversalRecipeManager;

+import ihl.recipes.UniversalRecipeOutput;

+import net.minecraft.client.renderer.texture.IIconRegister;

+import net.minecraft.entity.player.EntityPlayer;

+import net.minecraft.inventory.IInventory;

+import net.minecraft.item.Item;

+import net.minecraft.item.ItemStack;

+import net.minecraft.nbt.NBTTagCompound;

+import net.minecraft.tileentity.TileEntity;

+import net.minecraft.util.IIcon;

+import net.minecraft.util.StatCollector;

+import net.minecraft.world.World;

+import net.minecraftforge.common.util.ForgeDirection;

+import net.minecraftforge.fluids.Fluid;

+import net.minecraftforge.fluids.FluidRegistry;

+import net.minecraftforge.fluids.FluidStack;

+import net.minecraftforge.fluids.IFluidContainerItem;

+import net.minecraftforge.fluids.IFluidHandler;

+

+public class Crucible extends Item implements IHandHeldInventory, IFluidContainerItem, IItemHudInfo{

+

+	public int capacity=864;

+	private String itemName;

+	protected static final UniversalRecipeManager recipeManager = new UniversalRecipeManager("crucible");

+	

+	@SideOnly(Side.CLIENT)

+	private IIcon iconHot;

+

+	public Crucible() {

+		super();

+		this.itemName="crucible";

+		this.setUnlocalizedName(itemName);

+		GameRegistry.registerItem(this, this.itemName);

+		this.setCreativeTab(IHLCreativeTab.tab);

+		this.maxStackSize=1;

+		this.setCreativeTab(IHLCreativeTab.tab);

+		this.setMaxDamage(0);

+	}

+	

+	public static void addRecipe(String string, FluidStack output) 

+	{

+		recipeManager.addRecipe(new UniversalRecipeInput(null, new IRecipeInput[] {new RecipeInputOreDict(string)}), new UniversalRecipeOutput(new FluidStack[] {output},null,20));

+	}

+

+	@Override

+	public IHasGui getInventory(EntityPlayer entityPlayer, ItemStack itemStack) 

+	{

+		return new CrucibleInventory(entityPlayer, itemStack);

+	}

+	

+    @Override

+	public ItemStack onItemRightClick(ItemStack itemStack, World world, EntityPlayer entityPlayer)

+    {

+        if (IC2.platform.isSimulating())

+        {

+            IC2.platform.launchGui(entityPlayer, this.getInventory(entityPlayer, itemStack));

+        }

+        return itemStack;

+    }

+

+    /**

+     * allows items to add custom lines of information to the mouseover description

+     */

+    @SuppressWarnings({ "rawtypes", "unchecked" })

+	@Override

+	public void addInformation(ItemStack itemStack, EntityPlayer player, List info, boolean b)

+    {

+        super.addInformation(itemStack, player, info, b);

+        FluidStack fs = this.getFluid(itemStack);

+

+        if (fs != null)

+        {

+            info.add("< " + FluidRegistry.getFluidName(fs) + ", " + fs.amount + " mB >");

+        }

+        else

+        {

+            info.add(StatCollector.translateToLocal("ic2.item.FluidContainer.Empty"));

+        }

+    }

+

+    @Override

+	public List<String> getHudInfo(ItemStack itemStack)

+    {

+        LinkedList<String> info = new LinkedList<String>();

+        FluidStack fs = this.getFluid(itemStack);

+

+        if (fs != null)

+        {

+            info.add("< " + FluidRegistry.getFluidName(fs) + ", " + fs.amount + " mB >");

+        }

+        else

+        {

+            info.add(StatCollector.translateToLocal("ic2.item.FluidContainer.Empty"));

+        }

+

+        return info;

+    }

+

+    @Override

+	public FluidStack getFluid(ItemStack stack)

+    {

+        NBTTagCompound nbtTagCompound = StackUtil.getOrCreateNbtData(stack);

+        NBTTagCompound fluidTag = nbtTagCompound.getCompoundTag("Fluid");

+        return FluidStack.loadFluidStackFromNBT(fluidTag);

+    }

+

+    public boolean isEmpty(ItemStack stack)

+    {

+        return this.getFluid(stack) == null;

+    }

+

+    @Override

+	public int getCapacity(ItemStack container)

+    {

+        return this.capacity;

+    }

+

+    public boolean canfill(Fluid var1)

+    {

+        return true;

+    }

+    

+    public ItemStack processContent(ItemStack itemStack, IInventory inventoryContainer)

+    {

+    	CrucibleInventory inventory = new CrucibleInventory(inventoryContainer, itemStack);

+    	ItemStack content = inventory.getStackInSlot(0);

+    	if(content!=null)

+    	{

+    		UniversalRecipeOutput routput = recipeManager.getOutputFor(null, Arrays.asList(new ItemStack [] {content}));

+    		if(routput!=null && !routput.getFluidOutputs().isEmpty())

+    		{

+				FluidStack fluidStack = routput.getFluidOutputs().get(0).copy();

+				fluidStack.amount *= content.stackSize;

+				itemStack.stackTagCompound = new NBTTagCompound();

+				this.fill(itemStack, fluidStack, true);

+				return itemStack;

+    		}

+    	}

+    	return itemStack;

+    }

+

+    @Override

+	public int fill(ItemStack stack, FluidStack resource, boolean doFill)

+    {

+        if (stack.stackSize != 1)

+        {

+            return 0;

+        }

+        else if (resource == null)

+        {

+            return 0;

+        }

+        else if (!this.canfill(resource.getFluid()))

+        {

+            return 0;

+        }

+        else

+        {

+            NBTTagCompound nbtTagCompound = StackUtil.getOrCreateNbtData(stack);

+            NBTTagCompound fluidTag = nbtTagCompound.getCompoundTag("Fluid");

+            FluidStack fs = FluidStack.loadFluidStackFromNBT(fluidTag);

+

+            if (fs == null)

+            {

+                fs = new FluidStack(resource, 0);

+            }

+

+            if (!fs.isFluidEqual(resource))

+            {

+                return 0;

+            }

+            else

+            {

+                int amount = Math.min(this.capacity - fs.amount, resource.amount);

+

+                if (doFill && amount > 0)

+                {

+                    fs.amount += amount;

+                    fs.writeToNBT(fluidTag);

+                    nbtTagCompound.setTag("Fluid", fluidTag);

+                    if(fs.getFluid().getTemperature()>900)stack.setItemDamage(1);

+                }

+

+                return amount;

+            }

+        }

+    }

+

+    @Override

+	public FluidStack drain(ItemStack stack, int maxDrain, boolean doDrain)

+    {

+        if (stack.stackSize != 1)

+        {

+            return null;

+        }

+        else

+        {

+            NBTTagCompound nbtTagCompound = StackUtil.getOrCreateNbtData(stack);

+            NBTTagCompound fluidTag = nbtTagCompound.getCompoundTag("Fluid");

+            FluidStack fs = FluidStack.loadFluidStackFromNBT(fluidTag);

+

+            if (fs == null)

+            {

+                return null;

+            }

+            else

+            {

+                maxDrain = Math.min(fs.amount, maxDrain);

+

+                if (doDrain)

+                {

+                    fs.amount -= maxDrain;

+

+                    if (fs.amount <= 0)

+                    {

+                        nbtTagCompound.removeTag("Fluid");

+                        stack.setItemDamage(0);

+                    }

+                    else

+                    {

+                        fs.writeToNBT(fluidTag);

+                        nbtTagCompound.setTag("Fluid", fluidTag);

+                    }

+                }

+

+                return new FluidStack(fs, maxDrain);

+            }

+        }

+    }

+    

+	@Override

+	@SideOnly(Side.CLIENT)

+	public void registerIcons(IIconRegister register) 

+	{

+		itemIcon=register.registerIcon(IHLModInfo.MODID + ":crucible");

+		iconHot=register.registerIcon(IHLModInfo.MODID + ":crucibleHot");

+	}

+	

+	@Override

+	@SideOnly(Side.CLIENT)

+    public IIcon getIconFromDamage(int meta)

+    {

+    	switch(meta)

+    	{

+    	case 0:

+   			return this.itemIcon;

+    	case 1:

+   			return this.iconHot;

+   		default:

+   			return this.itemIcon;

+    	}

+    }

+	

+    @Override

+	public boolean onItemUse(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side, float xOffset, float yOffset, float zOffset)

+    {

+        if (!IC2.platform.isSimulating())

+        {

+            return false;

+        }

+        else if (this.interactWithTank(stack, player, world, x, y, z, side))

+        {

+            return true;

+        }

+		return false;

+    }

+    

+

+    private boolean interactWithTank(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side)

+    {

+        if (!IC2.platform.isSimulating())

+        {

+            return false;

+        }

+        else

+        {

+            TileEntity te = world.getTileEntity(x, y, z);

+

+            if (!(te instanceof IFluidHandler))

+            {

+                return false;

+            }

+            else

+            {

+                IFluidHandler handler = (IFluidHandler)te;

+                ForgeDirection dir = ForgeDirection.getOrientation(side);

+                FluidStack fs = this.getFluid(stack);

+                int amount;

+

+                if (fs != null && (!player.isSneaking() || fs.amount >= this.capacity))

+                {

+                    amount = handler.fill(dir, fs, false);

+

+                    if (amount <= 0)

+                    {

+                        return false;

+                    }

+                    else

+                    {

+                        fs = LiquidUtil.drainContainerStack(stack, player, amount, false);

+

+                        if (fs != null && fs.amount > 0)

+                        {

+                            handler.fill(dir, fs, true);

+                            return true;

+                        }

+                        else

+                        {

+                            return false;

+                        }

+                    }

+                }

+                else

+                {

+                    amount = fs == null ? this.capacity : this.capacity - fs.amount;

+                    FluidStack input = handler.drain(dir, amount, false);

+

+                    if (input != null && input.amount > 0)

+                    {

+                        amount = LiquidUtil.fillContainerStack(stack, player, input, false);

+

+                        if (amount <= 0)

+                        {

+                            return false;

+                        }

+                        else

+                        {

+                            handler.drain(dir, amount, true);

+                            return true;

+                        }

+                    }

+                    else

+                    {

+                        return false;

+                    }

+                }

+            }

+        }

+    }

+

+	public static Map<UniversalRecipeInput, UniversalRecipeOutput> getRecipes() {

+		return recipeManager.getRecipes();

+	}

+

+}