Move sources and resources

2 files changed, 664 insertions, 0 deletions

diff --git a/src/main/java/gtPlusPlus/xmod/tinkers/util/TinkersDryingRecipe.java b/src/main/java/gtPlusPlus/xmod/tinkers/util/TinkersDryingRecipe.java
new file mode 100644
index 0000000000..8bc7ffef29
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/tinkers/util/TinkersDryingRecipe.java
@@ -0,0 +1,120 @@
+package gtPlusPlus.xmod.tinkers.util;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+
+import gregtech.api.enums.GT_Values;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.lib.LoadedMods;
+import gtPlusPlus.core.recipe.common.CI;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+
+public class TinkersDryingRecipe {
+	
+    public static AutoMap<TinkersDryingRecipe> recipes = new AutoMap<TinkersDryingRecipe>();
+
+	public final int time;
+	public final ItemStack input;
+	public final ItemStack result;
+	
+	public static void generateAllDryingRecipes() {
+		List<?> aRecipes = TinkersUtils.getDryingRecipes();
+		if (aRecipes != null && aRecipes.size() > 0) {
+			for (Object o : aRecipes) {
+				Logger.INFO("Trying to generate recipe using object of type "+o.getClass().getSimpleName());
+				generateFromTinkersRecipeObject(o);
+			}
+		}
+		else {
+			Logger.INFO("Error generating Drying recipes, map was either null or empty. Null? "+(aRecipes != null)+", Size: "+aRecipes.size());
+		}
+		if (!recipes.isEmpty()) {
+			Logger.INFO("Adding "+recipes.size()+" drying rack recipes to the dehydrator.");
+			for (TinkersDryingRecipe r : recipes) {
+				CORE.RA.addDehydratorRecipe(
+						new ItemStack[] {
+								CI.getNumberedCircuit(16),
+								r.input
+						},
+						GT_Values.NF,
+						GT_Values.NF,
+						new ItemStack[] {r.result},
+						new int[] {},
+						r.time/10,
+						30);
+			}
+		}
+	}
+
+	public static TinkersDryingRecipe generateFromTinkersRecipeObject(Object o) {
+		Field aTime;
+		Field aInput;
+		Field aOutput;
+		Class aTinkerClass = ReflectionUtils.getClass("tconstruct.library.crafting.DryingRackRecipes.DryingRecipe");//o.getClass();
+		if (aTinkerClass == null || !LoadedMods.TiCon) {
+			Logger.INFO("Error generating Drying Recipe, could not find class. Exists? "+ReflectionUtils.doesClassExist("tconstruct.library.crafting.DryingRackRecipes.DryingRecipe"));
+			Class clazz = ReflectionUtils.getClass("tconstruct.library.crafting.DryingRackRecipes");
+			Class[] y = clazz.getDeclaredClasses();
+			if (y == null || y.length <= 0) {
+				Logger.INFO("No hidden inner classes.");
+				return null;				
+			}
+			else {
+				boolean found = false;
+				for (Class h : y) {
+					Logger.INFO("Found hidden inner class: "+h.getCanonicalName());
+					if (h.getSimpleName().toLowerCase().equals("dryingrecipe")) {
+						Logger.INFO("Found correct recipe. Caching at correct location.");
+						ReflectionUtils.mCachedClasses.put("tconstruct.library.crafting.DryingRackRecipes.DryingRecipe", h);
+						aTinkerClass = h;
+						found = true;
+						break;						
+					}
+				}
+				if (!found) {
+					return null;
+				}
+			}			
+		}
+		aTime = ReflectionUtils.getField(aTinkerClass, "time");
+		aInput = ReflectionUtils.getField(aTinkerClass, "input");
+		aOutput = ReflectionUtils.getField(aTinkerClass, "result");
+		try {
+			int time_internal = aTime.getInt(o);
+			ItemStack input_internal = (ItemStack) aInput.get(o);
+			ItemStack result_internal = (ItemStack) aOutput.get(o);
+			return new TinkersDryingRecipe(input_internal, time_internal, result_internal);
+		} catch (Throwable b) {
+			b.printStackTrace();
+		}
+		return null;
+	}
+
+	public TinkersDryingRecipe(final ItemStack input, final int time, final ItemStack result) {
+		this.time = time;
+		this.input = input;
+		this.result = result;
+		Logger.INFO("Generating Drying Recipe. Input: "+input.getDisplayName()+", Output: "+result.getDisplayName());
+		recipes.add(this);
+	}
+
+	public boolean matches(ItemStack input) {
+		if (input.hasTagCompound()) {
+			input = input.copy();
+			input.getTagCompound().removeTag("frypanKill");
+			if (input.getTagCompound().hasNoTags()) {
+				input.setTagCompound((NBTTagCompound) null);
+			}
+		}
+		return ItemStack.areItemStacksEqual(this.input, input);
+	}
+
+	public ItemStack getResult() {
+		return this.result.copy();
+	}
+}
diff --git a/src/main/java/gtPlusPlus/xmod/tinkers/util/TinkersUtils.java b/src/main/java/gtPlusPlus/xmod/tinkers/util/TinkersUtils.java
new file mode 100644
index 0000000000..cf3284bfae
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/tinkers/util/TinkersUtils.java
@@ -0,0 +1,544 @@
+package gtPlusPlus.xmod.tinkers.util;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+
+import gregtech.api.enums.Materials;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.core.lib.LoadedMods;
+import gtPlusPlus.core.material.Material;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+
+public class TinkersUtils {
+
+	private static final Class<?> mClass_Smeltery;
+	private static final Class<?> mClass_TConstructRegistry;	
+	private static final Class<?> mClass_ToolMaterial;	
+	private static final Class<?> mClass_IPattern;
+	private static final Class<?> mClass_DynamicToolPart;
+	private static final Class<?> mClass_FluidType;
+	private static final Class<?> mClass_CastingRecipe;
+	private static final Class<?> mClass_TinkerSmeltery;
+	
+	private static final Field mField_MoltenIronFluid;
+	
+	private static final Method mMethod_getFluidType;
+	private static final Method mMethod_getCastingRecipes;
+
+	private static Object mSmelteryInstance;	
+	private static Object mTinkersRegistryInstance;
+	
+	private static final HashMap<String, Method> mMethodCache = new LinkedHashMap<String, Method>();
+		
+	
+	static {		
+		mClass_Smeltery = ReflectionUtils.getClass("tconstruct.library.crafting.Smeltery");
+		mClass_TConstructRegistry = ReflectionUtils.getClass("tconstruct.library.TConstructRegistry");
+		
+		mClass_ToolMaterial = ReflectionUtils.getClass("tconstruct.library.tools.ToolMaterial");	
+		mClass_IPattern = ReflectionUtils.getClass("tconstruct.library.util.IPattern");
+		mClass_DynamicToolPart = ReflectionUtils.getClass("tconstruct.library.tools.DynamicToolPart");
+		mClass_FluidType = ReflectionUtils.getClass("tconstruct.library.crafting.FluidType");
+		mClass_CastingRecipe = ReflectionUtils.getClass("tconstruct.library.crafting.CastingRecipe");
+		mClass_TinkerSmeltery = ReflectionUtils.getClass("tconstruct.smeltery.TinkerSmeltery");
+		
+		mField_MoltenIronFluid = ReflectionUtils.getField(mClass_TinkerSmeltery, "moltenIronFluid");	
+		
+		mMethod_getFluidType = ReflectionUtils.getMethod(mClass_FluidType, "getFluidType", String.class);
+		mMethod_getCastingRecipes = ReflectionUtils.getMethod(getCastingInstance(0), "getCastingRecipes", new Class[] {});		
+	}
+	
+	
+	/**
+	 * 
+	 * @param aSwitch - The Registry to return
+	 */
+	private static void setTiConDataInstance() {
+		if (!LoadedMods.TiCon) {
+			return;
+		} else {
+			if (mSmelteryInstance == null) {
+				if (mClass_Smeltery != null) {
+					try {
+						mSmelteryInstance = ReflectionUtils.getField(mClass_Smeltery, "instance").get(null);
+					} catch (IllegalArgumentException | IllegalAccessException e) {
+					}
+				}
+			}
+			if (mTinkersRegistryInstance == null) {
+				if (mClass_TConstructRegistry != null) {
+					try {
+						mTinkersRegistryInstance = ReflectionUtils.getField(mClass_TConstructRegistry, "instance").get(null);
+					} catch (IllegalArgumentException | IllegalAccessException e) {
+					}
+				}
+			}
+		}
+	}
+
+	public static final boolean isTiConFirstInOD() {
+		if (LoadedMods.TiCon) {
+			try {
+				return (boolean) ReflectionUtils.getField(ReflectionUtils.getClass("PHConstruct"), "tconComesFirst").get(null);
+			} catch (IllegalArgumentException | IllegalAccessException e) {
+			}
+		}
+		return false;
+	}
+
+	public static final boolean stopTiconLoadingFirst() {
+		if (isTiConFirstInOD()) {
+			try {
+				ReflectionUtils.setFinalFieldValue(ReflectionUtils.getClass("PHConstruct"), "tconComesFirst", false);
+				if ((boolean) ReflectionUtils.getField(ReflectionUtils.getClass("PHConstruct"), "tconComesFirst").get(null) == false) {
+					return true;
+				}
+				//Did not work, let's see where TiCon uses this and prevent it.
+				else {
+					ItemUtils.getNonTinkersDust("", 1);
+				}
+			}
+			catch (Exception e) {}
+		}		
+		return false;
+	}
+
+	/**
+	 * Add a new fluid as a valid Smeltery fuel.
+	 * @param fluid The fluid.
+	 * @param power The temperature of the fluid. This also influences the melting speed. Lava is 1000.
+	 * @param duration How long one "portion" of liquid fuels the smeltery. Lava is 10.
+	 */
+	public static void addSmelteryFuel (Fluid fluid, int power, int duration){
+		setTiConDataInstance();
+		ReflectionUtils.invokeVoid(mSmelteryInstance, "addSmelteryFuel", new Class[] {Fluid.class, int.class, int.class}, new Object[] {fluid, power, duration});
+	}
+
+	/**
+	 * Returns true if the liquid is a valid smeltery fuel.
+	 */
+	public static boolean isSmelteryFuel (Fluid fluid){
+		setTiConDataInstance();
+		return ReflectionUtils.invoke(mSmelteryInstance, "isSmelteryFuel", new Class[] {Fluid.class}, new Object[] {fluid});
+	}
+
+	/**
+	 * Returns the power of a smeltery fuel or 0 if it's not a fuel.
+	 */
+	public static int getFuelPower (Fluid fluid){
+		setTiConDataInstance();
+		return (int) ReflectionUtils.invokeNonBool(mSmelteryInstance, "getFuelPower", new Class[] {Fluid.class}, new Object[] {fluid});
+	}
+
+	/**
+	 * Returns the duration of a smeltery fuel or 0 if it's not a fuel.
+	 */
+	public static int getFuelDuration (Fluid fluid){
+		setTiConDataInstance();
+		return (int) ReflectionUtils.invokeNonBool(mSmelteryInstance, "getFuelDuration", new Class[] {Fluid.class}, new Object[] {fluid});
+	}
+	
+	
+	
+	
+	
+	
+	
+	public static boolean registerFluidType(String name, Block block, int meta, int baseTemperature, Fluid fluid, boolean isToolpart) {
+		if (mMethodCache.get("registerFluidType") == null) {
+			Method m = ReflectionUtils.getMethod(ReflectionUtils.getClass("tconstruct.library.crafting.FluidType"), "registerFluidType", String.class, Block.class, int.class, int.class, Fluid.class, boolean.class);
+			mMethodCache.put("registerFluidType", m);
+		}
+		try {
+			mMethodCache.get("registerFluidType").invoke(null, name, block, meta, baseTemperature, fluid, isToolpart);
+			return true;
+		} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+			return false;
+		}
+	}
+	
+	
+	
+	
+	
+	
+	
+	
+	public static boolean addBaseMeltingRecipes(Material aMaterial) {		
+		return addMelting(aMaterial.getBlock(1), aMaterial.getBlock(), 0, aMaterial.getMeltingPointC(), aMaterial.getFluidStack(144*9)) &&
+		addMelting(aMaterial.getIngot(1), aMaterial.getBlock(), 0, aMaterial.getMeltingPointC(), aMaterial.getFluidStack(144));
+	}
+	
+	public static boolean addMelting(ItemStack input, Block block, int metadata, int temperature, FluidStack liquid) {
+		if (mMethodCache.get("addMelting") == null) {
+			Method m = ReflectionUtils.getMethod(mClass_Smeltery, "addMelting", ItemStack.class, Block.class, int.class, int.class, FluidStack.class);
+			mMethodCache.put("addMelting", m);
+		}
+		try {			
+			mMethodCache.get("addMelting").invoke(null, input, block, metadata, temperature, liquid);
+			return true;
+		} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+			return false;
+		}
+	}
+
+	public static boolean addMelting(Object type, ItemStack input, int temperatureDifference, int fluidAmount) {
+		if (mMethodCache.get("addMelting") == null) {
+			Method m = ReflectionUtils.getMethod(mClass_Smeltery, "addMelting", mClass_FluidType, ItemStack.class, int.class, int.class);
+			mMethodCache.put("addMelting", m);
+		}
+		try {			
+			mMethodCache.get("addMelting").invoke(null, type, input, temperatureDifference, fluidAmount);
+			return true;
+		} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+			return false;
+		}
+	}
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	public static boolean addBaseBasinRecipes(Material aMaterial) {
+		return addBasinRecipe(aMaterial.getBlock(1), aMaterial.getFluidStack(144*9), (ItemStack) null, true, 100);
+	}
+	
+	public static boolean addBasinRecipe(ItemStack output, FluidStack metal, ItemStack cast, boolean consume, int delay) {
+		if (mMethodCache.get("addBasinRecipe") == null) {					
+			Method m = ReflectionUtils.getMethod(ReflectionUtils.getClass("tconstruct.library.crafting.LiquidCasting"), "addCastingRecipe", ItemStack.class, FluidStack.class, ItemStack.class, boolean.class, int.class);
+			mMethodCache.put("addBasinRecipe", m);
+		}
+		try {
+			mMethodCache.get("addBasinRecipe").invoke(getCastingInstance(0), output, metal, cast, consume, delay);
+			return true;
+		} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+			return false;
+		}
+	}
+	
+	
+	
+	
+	
+	
+	
+	public static boolean addBaseCastingRecipes(Material aMaterial) {
+		ItemStack ingotcast = getPattern(1);		
+		return addCastingTableRecipe(aMaterial.getIngot(1), aMaterial.getFluidStack(144), ingotcast, false, 50);
+	}
+	
+	public static boolean addCastingTableRecipe(ItemStack output, FluidStack metal, ItemStack cast, boolean consume, int delay) {		
+		if (mMethodCache.get("addCastingTableRecipe") == null) {					
+			Method m = ReflectionUtils.getMethod(ReflectionUtils.getClass("tconstruct.library.crafting.LiquidCasting"), "addCastingRecipe", ItemStack.class, FluidStack.class, ItemStack.class, boolean.class, int.class);
+			mMethodCache.put("addCastingTableRecipe", m);
+		}
+		try {
+			mMethodCache.get("addCastingTableRecipe").invoke(getCastingInstance(1), output, metal, cast, consume, delay);
+			return true;
+		} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+			return false;
+		}
+	}
+	
+	
+	
+	
+	
+	
+	
+	/**
+	 * 0 For Table, 1 For Basin.
+	 * @param aType - Casting Type
+	 * @return - The casting instance.
+	 */
+	public static Object getCastingInstance(int aType) {
+		
+		setTiConDataInstance();
+		
+		Method m = null;
+		if (aType == 0) {
+			m = ReflectionUtils.getMethod(mTinkersRegistryInstance, "getTableCasting", new Class[] {});			
+			//return ReflectionUtils.invokeVoid(getTiConDataInstance(1), "getTableCasting", new Class[] {}, new Object[] {});			
+		}
+		else if (aType == 1) {
+			m = ReflectionUtils.getMethod(mTinkersRegistryInstance, "getBasinCasting", new Class[] {});
+			//return ReflectionUtils.invokeVoid(getTiConDataInstance(1), "getBasinCasting", new Class[] {}, new Object[] {});			
+		}
+		else {
+			//return null;
+		}
+		
+		if (m != null) {
+			try {
+				return m.invoke(mTinkersRegistryInstance, new Object[] {});
+			} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+				e.printStackTrace();
+			}
+		}
+		return null;
+	}
+	
+	
+	private static Item mTinkerMetalPattern;
+	public static ItemStack getPattern(int aType) {		
+		if (mTinkerMetalPattern == null) {
+			Field m = ReflectionUtils.getField(mClass_TinkerSmeltery, "metalPattern");
+			if (m != null) {
+				try {
+					mTinkerMetalPattern = (Item) m.get(null);
+				} catch (IllegalArgumentException | IllegalAccessException e) {
+				}				
+			}
+		}
+		if (mTinkerMetalPattern != null) {
+			ItemStack ingotCast = new ItemStack(mTinkerMetalPattern, aType, 0);	
+			return ingotCast;
+		}
+		return ItemUtils.getErrorStack(1, "Bad Tinkers Pattern");		
+	}	
+	
+	private static AutoMap<?> mDryingRackRecipes;
+	
+	public static List<?> getDryingRecipes(){		
+		if (mDryingRackRecipes != null) {
+			return mDryingRackRecipes;
+		}		
+		AutoMap<Object> aData = new AutoMap<Object>();
+		int aCount = 0;
+		try {
+			ArrayList<?> recipes = (ArrayList<?>) ReflectionUtils.getField(ReflectionUtils.getClass("tconstruct.library.crafting.DryingRackRecipes"), "recipes").get(null);
+			if (recipes != null) {
+				for (Object o : recipes) {
+					aData.put(o);
+					aCount++;
+				}
+				Logger.INFO("Found "+aCount+" Tinkers drying rack recipes.");
+			}
+			else {
+				Logger.INFO("Failed to find any Tinkers drying rack recipes.");
+			}
+		} catch (IllegalArgumentException | IllegalAccessException e) {
+			Logger.INFO("Failed to find any Tinkers drying rack recipes.");
+		}	
+		mDryingRackRecipes = aData;
+		return aData;
+	}
+	
+	/**
+	 * Generates Tinkers {@link ToolMaterial}'s reflectively.
+	 * @param name
+	 * @param localizationString
+	 * @param level
+	 * @param durability
+	 * @param speed
+	 * @param damage
+	 * @param handle
+	 * @param reinforced
+	 * @param stonebound
+	 * @param style
+	 * @param primaryColor
+	 * @return
+	 */
+	public static Object generateToolMaterial(String name, String localizationString, int level, int durability, int speed, int damage,	float handle, int reinforced, float stonebound, String style, int primaryColor) {
+		try {
+			Constructor<?> constructor = mClass_ToolMaterial.getConstructor(String.class, String.class, int.class, int.class, int.class, int.class, float.class, int.class, float.class, String.class, int.class);
+			Object myObject = constructor.newInstance(name, localizationString, level, durability, speed, damage, handle, reinforced, stonebound, style, primaryColor);
+			return myObject;
+		} catch (Throwable t) {
+			t.printStackTrace();
+			return null;
+		}
+	}
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	public static void addToolMaterial(int id, Object aToolMaterial) {
+		if (mMethodCache.get("addToolMaterial") == null) {					
+			Method m = ReflectionUtils.getMethod(mClass_TConstructRegistry, "addtoolMaterial", int.class, mClass_ToolMaterial);
+			mMethodCache.put("addToolMaterial", m);
+		}
+		try {
+			mMethodCache.get("addToolMaterial").invoke(mClass_TConstructRegistry, id, aToolMaterial);			
+		} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+			
+		}		
+	}
+	
+	public static void addDefaultToolPartMaterial(int id) {
+		if (mMethodCache.get("addDefaultToolPartMaterial") == null) {					
+			Method m = ReflectionUtils.getMethod(mClass_TConstructRegistry, "addDefaultToolPartMaterial", int.class);
+			mMethodCache.put("addDefaultToolPartMaterial", m);
+		}
+		try {
+			mMethodCache.get("addDefaultToolPartMaterial").invoke(mClass_TConstructRegistry, id);			
+		} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {			
+		}
+	}
+	
+	public static void addBowMaterial(int id, int drawspeed, float maxSpeed) {
+		if (mMethodCache.get("addBowMaterial") == null) {					
+			Method m = ReflectionUtils.getMethod(mClass_TConstructRegistry, "addBowMaterial", int.class, int.class, float.class);
+			mMethodCache.put("addBowMaterial", m);
+		}
+		try {
+			mMethodCache.get("addBowMaterial").invoke(mClass_TConstructRegistry, id, drawspeed, maxSpeed);			
+		} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {			
+		}
+	}
+	
+	public static void addArrowMaterial(int id, float mass, float fragility) {
+		if (mMethodCache.get("addArrowMaterial") == null) {					
+			Method m = ReflectionUtils.getMethod(mClass_TConstructRegistry, "addArrowMaterial", int.class, float.class, float.class);
+			mMethodCache.put("addArrowMaterial", m);
+		}
+		try {
+			mMethodCache.get("addArrowMaterial").invoke(mClass_TConstructRegistry, id, mass, fragility);			
+		} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {			
+		}
+	}	
+	
+	public static List<?> getTableCastingRecipes(){		
+		Object aCastingTableHandlerInstance = getCastingInstance(0);		
+		List<?> aTemp;
+		try {
+			aTemp = (List<?>) mMethod_getCastingRecipes.invoke(aCastingTableHandlerInstance, new Object[] {});
+			return aTemp;
+		} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+			e.printStackTrace();
+		}		
+		return new ArrayList<Object>();
+	}
+	
+	public static boolean generateCastingRecipes(Material aMaterial, int aID) {
+		
+		List<CastingRecipeHandler> newRecipies = new LinkedList<CastingRecipeHandler>();		
+        
+			
+			Iterator<?> iterator1 = getTableCastingRecipes().iterator();
+			Fluid aMoltenIron = null;
+			if (aMoltenIron == null) {
+				try {
+					aMoltenIron = (Fluid) mField_MoltenIronFluid.get(null);
+				} catch (IllegalArgumentException | IllegalAccessException e) {
+					e.printStackTrace();
+					aMoltenIron = Materials.Iron.getMolten(0).getFluid();
+				}
+			}
+			while (iterator1.hasNext()) {
+				CastingRecipeHandler recipe = new CastingRecipeHandler(iterator1.next());
+				if (recipe == null || !recipe.valid) {
+					continue;
+				}
+				try {
+					if (recipe.castingMetal.getFluid() == aMoltenIron && recipe.cast != null
+							&& mClass_IPattern.isInstance(recipe.cast.getItem()) && mClass_DynamicToolPart.isInstance(recipe.getResult().getItem())) {
+						newRecipies.add(recipe);
+					}
+				} catch (IllegalArgumentException e) {
+					e.printStackTrace();
+					return false;
+				}
+			}
+			
+			
+			Object ft;
+			try {
+				ft = mMethod_getFluidType.invoke(null, aMaterial.getLocalizedName());
+				Iterator<CastingRecipeHandler> iterator2 = newRecipies.iterator();
+				while (iterator2.hasNext()) {
+					CastingRecipeHandler recipe = new CastingRecipeHandler(iterator2.next());
+					if (!recipe.valid){
+						continue;
+					}
+					//CastingRecipe recipe = (CastingRecipe) i$.next();
+					ItemStack output = recipe.getResult().copy();
+					output.setItemDamage(aID);
+					FluidStack liquid2 = new FluidStack(aMaterial.getFluidStack(0).getFluid(), recipe.castingMetal.amount);
+					addCastingTableRecipe(output, liquid2, recipe.cast, recipe.consumeCast, recipe.coolTime);
+					addMelting(ft, output, 0, liquid2.amount / 2);
+				}
+			} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+				e.printStackTrace();
+				return false;
+			}
+		
+		return true;
+	}
+	
+	private static class CastingRecipeHandler {	
+		
+		public ItemStack output;
+		public FluidStack castingMetal;
+		public ItemStack cast;
+		public boolean consumeCast;
+		public int coolTime;
+		
+		public boolean valid;
+		
+		public CastingRecipeHandler(Object aCastingRecipe) {			
+			if (mClass_CastingRecipe.isInstance(aCastingRecipe)) {				
+				try {
+				Field aF_output = ReflectionUtils.getField(mClass_CastingRecipe, "output");
+				Field aF_castingMetal = ReflectionUtils.getField(mClass_CastingRecipe, "castingMetal");
+				Field aF_cast = ReflectionUtils.getField(mClass_CastingRecipe, "cast");
+				Field aF_consumeCast = ReflectionUtils.getField(mClass_CastingRecipe, "consumeCast");
+				Field aF_coolTime = ReflectionUtils.getField(mClass_CastingRecipe, "coolTime");
+
+				output = (ItemStack) aF_output.get(aCastingRecipe);
+				castingMetal = (FluidStack) aF_castingMetal.get(aCastingRecipe);
+				cast = (ItemStack) aF_cast.get(aCastingRecipe);
+				consumeCast = (boolean) aF_consumeCast.get(aCastingRecipe);
+				coolTime = (int) aF_coolTime.get(aCastingRecipe);
+				valid = true;
+				}
+				catch (Throwable t) {
+					t.printStackTrace();
+					valid = false;
+				}				
+			}	
+			else {
+				valid = false;
+			}
+		}
+
+		public boolean matches(FluidStack metal, ItemStack inputCast) {
+			return this.castingMetal.isFluidEqual(metal) && (this.cast != null && this.cast.getItemDamage() == 32767
+					&& inputCast.getItem() == this.cast.getItem() || ItemStack.areItemStacksEqual(this.cast, inputCast));
+		}
+
+		public ItemStack getResult() {
+			return this.output.copy();
+		}
+		
+	}
+
+}