package tconstruct.library.crafting; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.List; import net.minecraft.block.Block; import net.minecraft.item.ItemStack; import net.minecraftforge.fluids.FluidStack; /** Melting and hacking, churn and burn */ public class Smeltery { public static Smeltery instance = new Smeltery(); private HashMap, FluidStack> smeltingList = new HashMap, FluidStack>(); private HashMap, Integer> temperatureList = new HashMap, Integer>(); private HashMap, ItemStack> renderIndex = new HashMap, ItemStack>(); private ArrayList alloys = new ArrayList(); /** Adds mappings between an itemstack and an output liquid * Example: Smeltery.addMelting(Block.oreIron, 0, 600, new FluidStack(liquidMetalStill.blockID, TConstruct.ingotLiquidValue * 2, 0)); * * @param stack The itemstack to liquify * @param temperature How hot the block should be before liquifying. Max temp in the Smeltery is 800, other structures may vary * @param output The result of the process in liquid form */ public static void addMelting (ItemStack stack, int temperature, FluidStack output) { addMelting(stack, stack.itemID, stack.getItemDamage(), temperature, output); } /** Adds mappings between a block and its liquid * Example: Smeltery.addMelting(Block.oreIron, 0, 600, new FluidStack(liquidMetalStill.blockID, TConstruct.ingotLiquidValue * 2, 0)); * * @param blockID The ID of the block to liquify and render * @param metadata The metadata of the block to liquify and render * @param temperature How hot the block should be before liquifying. Max temp in the Smeltery is 800, other structures may vary * @param output The result of the process in liquid form */ public static void addMelting (Block block, int metadata, int temperature, FluidStack output) { addMelting(new ItemStack(block, 1, metadata), block.blockID, metadata, temperature, output); } /** Adds mappings between an input and its liquid. * Renders with the given input's block ID and metadata * Example: Smeltery.addMelting(Block.oreIron, 0, 600, new FluidStack(liquidMetalStill.blockID, TConstruct.ingotLiquidValue * 2, 0)); * * @param input The item to liquify * @param blockID The ID of the block to render * @param metadata The metadata of the block to render * @param temperature How hot the block should be before liquifying * @param liquid The result of the process */ public static void addMelting (ItemStack input, int blockID, int metadata, int temperature, FluidStack liquid) { instance.smeltingList.put(Arrays.asList(input.itemID, input.getItemDamage()), liquid); instance.temperatureList.put(Arrays.asList(input.itemID, input.getItemDamage()), temperature); instance.renderIndex.put(Arrays.asList(input.itemID, input.getItemDamage()), new ItemStack(blockID, input.stackSize, metadata)); } /** Adds an alloy mixing recipe. * Example: Smeltery.addAlloyMixing(new FluidStack(bronzeID, 2, 0), new FluidStack(copperID, 3, 0), new FluidStack(tinID, 1, 0)); * The example mixes 3 copper with 1 tin to make 2 bronze * * @param result The output of the combination of mixers. The quantity is used for amount of a successful mix * @param mixers the liquids to be mixed. Quantities are used as ratios */ public static void addAlloyMixing (FluidStack result, FluidStack... mixers) { ArrayList inputs = new ArrayList(); for (FluidStack liquid : mixers) inputs.add(liquid); instance.alloys.add(new AlloyMix(result, inputs)); } /** * Used to get the resulting temperature from a source ItemStack * @param item The Source ItemStack * @return The result temperature */ public static Integer getLiquifyTemperature (ItemStack item) { if (item == null) return 20; Integer temp = instance.temperatureList.get(Arrays.asList(item.itemID, item.getItemDamage())); if (temp == null) return 20; else return temp; } /** * Used to get the resulting temperature from a source Block * @param item The Source ItemStack * @return The result ItemStack */ public static Integer getLiquifyTemperature (int blockID, int metadata) { return instance.temperatureList.get(Arrays.asList(blockID, metadata)); } /** * Used to get the resulting ItemStack from a source ItemStack * @param item The Source ItemStack * @return The result ItemStack */ public static FluidStack getSmelteryResult (ItemStack item) { if (item == null) return null; FluidStack stack = (FluidStack) instance.smeltingList.get(Arrays.asList(item.itemID, item.getItemDamage())); if (stack == null) return null; return stack.copy(); } /** * Used to get the resulting ItemStack from a source Block * @param item The Source ItemStack * @return The result ItemStack */ public static FluidStack getSmelteryResult (int blockID, int metadata) { FluidStack stack = (FluidStack) instance.smeltingList.get(Arrays.asList(blockID, metadata)); if (stack == null) return null; return stack.copy(); } public static ItemStack getRenderIndex (ItemStack input) { return instance.renderIndex.get(Arrays.asList(input.itemID, input.getItemDamage())); } public static ArrayList mixMetals (ArrayList moltenMetal) { ArrayList liquids = new ArrayList(); for (AlloyMix alloy : instance.alloys) { FluidStack liquid = alloy.mix(moltenMetal); if (liquid != null) liquids.add(liquid); } return liquids; } public static HashMap, FluidStack> getSmeltingList () { return instance.smeltingList; } public static HashMap, Integer> getTemperatureList () { return instance.temperatureList; } public static HashMap, ItemStack> getRenderIndex () { return instance.renderIndex; } public static ArrayList getAlloyList () { return instance.alloys; } }