diff options
Diffstat (limited to 'src/main/java/gtPlusPlus/xmod/tinkers')
4 files changed, 736 insertions, 0 deletions
diff --git a/src/main/java/gtPlusPlus/xmod/tinkers/HANDLER_Tinkers.java b/src/main/java/gtPlusPlus/xmod/tinkers/HANDLER_Tinkers.java new file mode 100644 index 0000000000..1023d0325f --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/tinkers/HANDLER_Tinkers.java @@ -0,0 +1,30 @@ +package gtPlusPlus.xmod.tinkers; + +import static gregtech.api.enums.Mods.TinkerConstruct; + +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; + +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.xmod.tinkers.material.BaseTinkersMaterial; +import gtPlusPlus.xmod.tinkers.util.TinkersDryingRecipe; +import gtPlusPlus.xmod.tinkers.util.TinkersUtils; + +public class HANDLER_Tinkers { + + public static AutoMap<BaseTinkersMaterial> mTinkerMaterials = new AutoMap<>(); + + public static void postInit() { + if (TinkerConstruct.isModLoaded()) { + + Fluid pyrotheumFluid = FluidRegistry.getFluid("pyrotheum"); + if (pyrotheumFluid != null) { + // Enable Pyrotheum as Fuel for the Smeltery + TinkersUtils.addSmelteryFuel(pyrotheumFluid, 5000, 70); // pyrotheum lasts 3.5 seconds per 15 mb + } + + // Generate Drying Rack recipes + TinkersDryingRecipe.generateAllDryingRecipes(); + } + } +} diff --git a/src/main/java/gtPlusPlus/xmod/tinkers/material/BaseTinkersMaterial.java b/src/main/java/gtPlusPlus/xmod/tinkers/material/BaseTinkersMaterial.java new file mode 100644 index 0000000000..f57aa64263 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/tinkers/material/BaseTinkersMaterial.java @@ -0,0 +1,200 @@ +package gtPlusPlus.xmod.tinkers.material; + +import static gregtech.api.enums.Mods.TinkerConstruct; +import static gtPlusPlus.core.util.math.MathUtils.safeCast_LongToInt; + +import java.util.HashMap; + +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.fluids.Fluid; + +import cpw.mods.fml.common.event.FMLInterModComms; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.xmod.tinkers.HANDLER_Tinkers; +import gtPlusPlus.xmod.tinkers.util.TinkersUtils; + +public class BaseTinkersMaterial { + + private static HashMap<String, Integer> aInternalMaterialIdMap = new HashMap<>(); + private static int aNextFreeID; + + public final String mLocalName; + + private final String mUnlocalName; + private final int mID; + private final Material mMaterial; + + static { + aNextFreeID = (Short.MAX_VALUE / 2) + 420; + } + + public BaseTinkersMaterial(Material aMaterial) { + mLocalName = aMaterial.getLocalizedName(); + mUnlocalName = "material.gtpp." + Utils.sanitizeString(mLocalName); + mMaterial = aMaterial; + mID = aNextFreeID++; + Logger.INFO("[TiCon] Assigning ID " + mID + " to " + mLocalName + "."); + aInternalMaterialIdMap.put(mUnlocalName, mID); + HANDLER_Tinkers.mTinkerMaterials.put(this); + } + + public String getUnlocalName() { + return mUnlocalName; + } + + private static int calcDurability(Material aMaterial) { + return safeCast_LongToInt(aMaterial.vDurability); + } + + private static int calcMiningSpeed(Material aMaterial) { + return (aMaterial.vHarvestLevel * 2) + aMaterial.vTier; + } + + private static int calcHarvestLevel(Material aMaterial) { + return aMaterial.vHarvestLevel; + } + + private static int calcAttack(Material aMaterial) { + return aMaterial.vHarvestLevel + aMaterial.vTier + aMaterial.vRadiationLevel; + } + + private static float calcHandleModifier(Material aMaterial) { + return 1f; + } + + private static int calcReinforced(Material aMaterial) { + return aMaterial.getMeltingPointC() / 3600; + } + + private static int calcBowProjectileSpeed(Material aMaterial) { + return aMaterial.vHarvestLevel + 2; + } + + private static int calcBowDrawSpeed(Material aMaterial) { + return aMaterial.vHarvestLevel + 8; + } + + private static float calcProjectileMass(Material aMaterial) { + return (aMaterial.getMeltingPointC() / 1800) * 0.1f; + } + + private static float calcProjectileFragility(Material aMaterial) { + return 0f; + } + + private static String calcStyle(Material aMaterial) { + String aReturn; + int aTemp = aMaterial.getMeltingPointC(); + if (aTemp < 3600) { + aReturn = "" + EnumChatFormatting.WHITE; + } else if (aTemp >= 3600) { + aReturn = "" + EnumChatFormatting.YELLOW; + } else if (aTemp >= (3600 * 2)) { + aReturn = "" + EnumChatFormatting.GREEN; + } else if (aTemp >= (3600 * 3)) { + aReturn = "" + EnumChatFormatting.RED; + } else if (aTemp >= (3600 * 4)) { + aReturn = "" + EnumChatFormatting.DARK_RED; + } else { + aReturn = "" + EnumChatFormatting.GOLD; + } + return aReturn; + } + + private static int calcColour(Material aMaterial) { + return aMaterial.getRgbAsHex(); + } + + public void generate() { + + Logger.INFO("[TiCon] Trying to generate Material: " + mLocalName); + int id = mID; + if (id > 0) { + + NBTTagCompound tag = new NBTTagCompound(); + tag.setInteger("Id", id); + tag.setString("Name", mUnlocalName); + tag.setString("localizationString", mLocalName); + tag.setInteger("Durability", calcDurability(mMaterial)); // 97 + tag.setInteger("MiningSpeed", calcMiningSpeed(mMaterial)); // 150 + tag.setInteger("HarvestLevel", calcHarvestLevel(mMaterial)); // 1 + tag.setInteger("Attack", calcAttack(mMaterial)); // 0 + tag.setFloat("HandleModifier", calcHandleModifier(mMaterial)); // 1.0f + tag.setInteger("Reinforced", calcReinforced(mMaterial)); // 0 + tag.setFloat("Bow_ProjectileSpeed", calcBowProjectileSpeed(mMaterial)); // 3.0f + tag.setInteger("Bow_DrawSpeed", calcBowDrawSpeed(mMaterial)); // 18 + tag.setFloat("Projectile_Mass", calcProjectileMass(mMaterial)); // 0.69f + tag.setFloat("Projectile_Fragility", calcProjectileFragility(mMaterial)); // 0.2f + tag.setString("Style", calcStyle(mMaterial)); + tag.setInteger("Color", calcColour(mMaterial)); + + boolean generate = generateRecipes(mMaterial, id); + + if (generate) { + Logger.INFO("[TiCon] Sending IMC: addMaterial - " + mLocalName + "."); + FMLInterModComms.sendMessage(TinkerConstruct.ID, "addMaterial", tag); + + ItemStack itemstack = mMaterial.getIngot(1); + tag = new NBTTagCompound(); + tag.setInteger("MaterialId", id); + NBTTagCompound item = new NBTTagCompound(); + itemstack.writeToNBT(item); + tag.setTag("Item", item); + tag.setInteger("Value", 2); // What is value for? + + Logger.INFO("[TiCon] Sending IMC: addPartBuilderMaterial - " + mLocalName + "."); + FMLInterModComms.sendMessage(TinkerConstruct.ID, "addPartBuilderMaterial", tag); + + tag = new NBTTagCompound(); + tag.setInteger("MaterialId", id); + tag.setInteger("Value", 2); // What is value for? + item = new NBTTagCompound(); + itemstack.writeToNBT(item); + tag.setTag("Item", item); + + Logger.INFO("[TiCon] Sending IMC: addMaterialItem - " + mLocalName + "."); + FMLInterModComms.sendMessage(TinkerConstruct.ID, "addMaterialItem", tag); + } + } + } + + private boolean generateRecipes(Material aMaterial, int aID) { + + Block aMatBlock; + Integer aMelt; + Fluid aFluid; + + try { + aMatBlock = aMaterial.getBlock(); + aMelt = aMaterial.getMeltingPointC(); + aFluid = aMaterial.getFluidStack(0) + .getFluid(); + } catch (Throwable t) { + return false; + } + + if (aMatBlock == null || aMelt == null || aFluid == null) { + return false; + } + + TinkersUtils.registerFluidType(mLocalName, aMatBlock, 0, aMelt, aFluid, true); + TinkersUtils.addMelting(aMaterial.getBlock(1), aMatBlock, 0, aMelt, aMaterial.getFluidStack(144 * 9)); + TinkersUtils.addMelting(aMaterial.getIngot(1), aMatBlock, 0, aMelt, aMaterial.getFluidStack(144)); + if (aMelt <= 3600) { + ItemStack ingotcast = TinkersUtils.getPattern(1); + TinkersUtils + .addBasinRecipe(aMaterial.getBlock(1), aMaterial.getFluidStack(144 * 9), (ItemStack) null, true, 100); + TinkersUtils + .addCastingTableRecipe(aMaterial.getIngot(1), aMaterial.getFluidStack(144), ingotcast, false, 50); + } + + TinkersUtils.generateCastingRecipes(aMaterial, aID); + + return true; + } +} 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..33dad51510 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/tinkers/util/TinkersDryingRecipe.java @@ -0,0 +1,129 @@ +package gtPlusPlus.xmod.tinkers.util; + +import static gregtech.api.enums.Mods.TinkerConstruct; + +import java.lang.reflect.Field; +import java.util.List; + +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; + +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.recipe.common.CI; +import gtPlusPlus.core.util.reflect.ReflectionUtils; + +public class TinkersDryingRecipe { + + public static AutoMap<TinkersDryingRecipe> recipes = new AutoMap<>(); + + 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 || TinkerConstruct.isModLoaded()) { + 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..8b173d5b62 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/tinkers/util/TinkersUtils.java @@ -0,0 +1,377 @@ +package gtPlusPlus.xmod.tinkers.util; + +import static gregtech.api.enums.Mods.TinkerConstruct; + +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 net.minecraft.block.Block; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; + +import gregtech.api.enums.Materials; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.core.util.reflect.ReflectionUtils; + +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<>(); + + 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[] {}); + } + + private static void setTiConDataInstance() { + if (!TinkerConstruct.isModLoaded()) { + return; + } + + if (mSmelteryInstance == null) { + if (mClass_Smeltery != null) { + try { + mSmelteryInstance = ReflectionUtils.getField(mClass_Smeltery, "instance") + .get(null); + } catch (IllegalArgumentException | IllegalAccessException ignored) {} + } + } + if (mTinkersRegistryInstance == null) { + if (mClass_TConstructRegistry != null) { + try { + mTinkersRegistryInstance = ReflectionUtils.getField(mClass_TConstructRegistry, "instance") + .get(null); + } catch (IllegalArgumentException | IllegalAccessException ignored) {} + } + } + } + + /** + * 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 }); + } + + 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 void 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); + } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException ignored) {} + } + + public static void 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); + } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException ignored) {} + } + + public static void 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); + } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException ignored) {} + } + + public static void 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); + } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException ignored) {} + } + + /** + * 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[] {}); + } else if (aType == 1) { + m = ReflectionUtils.getMethod(mTinkersRegistryInstance, "getBasinCasting", new Class[] {}); + } // 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 ignored) {} + } + } + if (mTinkerMetalPattern != null) { + return new ItemStack(mTinkerMetalPattern, aType, 0); + } + 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<>(); + 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; + } + + 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<>(); + } + + public static void generateCastingRecipes(Material aMaterial, int aID) { + + List<CastingRecipeHandler> newRecipies = new LinkedList<>(); + + 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; + } + } + + Object ft; + try { + ft = mMethod_getFluidType.invoke(null, aMaterial.getLocalizedName()); + for (CastingRecipeHandler newRecipy : newRecipies) { + CastingRecipeHandler recipe = new CastingRecipeHandler(newRecipy); + 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(); + } + + } + + 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 ItemStack getResult() { + return this.output.copy(); + } + } +} |