From 91b1909427bb0cab0f72505c325b07f8fb39c62e Mon Sep 17 00:00:00 2001 From: Raven Szewczyk Date: Sat, 25 May 2024 14:13:58 +0100 Subject: Move GoodGen sources --- .../goodgenerator/loader/AchievementLoader.java | 4 + .../loader/ComponentAssemblyLineMiscRecipes.java | 503 ++++++ .../loader/ComponentAssemblyLineRecipeLoader.java | 484 ++++++ .../goodgenerator/loader/FuelRecipeLoader.java | 168 ++ .../java/goodgenerator/loader/FuelRodLoader.java | 248 +++ src/main/java/goodgenerator/loader/Loaders.java | 489 ++++++ .../loader/NaquadahReworkRecipeLoader.java | 1376 +++++++++++++++ .../loader/NeutronActivatorLoader.java | 46 + .../java/goodgenerator/loader/RecipeLoader.java | 1466 ++++++++++++++++ .../java/goodgenerator/loader/RecipeLoader_02.java | 1772 ++++++++++++++++++++ 10 files changed, 6556 insertions(+) create mode 100644 src/main/java/goodgenerator/loader/AchievementLoader.java create mode 100644 src/main/java/goodgenerator/loader/ComponentAssemblyLineMiscRecipes.java create mode 100644 src/main/java/goodgenerator/loader/ComponentAssemblyLineRecipeLoader.java create mode 100644 src/main/java/goodgenerator/loader/FuelRecipeLoader.java create mode 100644 src/main/java/goodgenerator/loader/FuelRodLoader.java create mode 100644 src/main/java/goodgenerator/loader/Loaders.java create mode 100644 src/main/java/goodgenerator/loader/NaquadahReworkRecipeLoader.java create mode 100644 src/main/java/goodgenerator/loader/NeutronActivatorLoader.java create mode 100644 src/main/java/goodgenerator/loader/RecipeLoader.java create mode 100644 src/main/java/goodgenerator/loader/RecipeLoader_02.java (limited to 'src/main/java/goodgenerator/loader') diff --git a/src/main/java/goodgenerator/loader/AchievementLoader.java b/src/main/java/goodgenerator/loader/AchievementLoader.java new file mode 100644 index 0000000000..2df30c8752 --- /dev/null +++ b/src/main/java/goodgenerator/loader/AchievementLoader.java @@ -0,0 +1,4 @@ +package goodgenerator.loader; + +public class AchievementLoader { +} diff --git a/src/main/java/goodgenerator/loader/ComponentAssemblyLineMiscRecipes.java b/src/main/java/goodgenerator/loader/ComponentAssemblyLineMiscRecipes.java new file mode 100644 index 0000000000..f83712c7db --- /dev/null +++ b/src/main/java/goodgenerator/loader/ComponentAssemblyLineMiscRecipes.java @@ -0,0 +1,503 @@ +package goodgenerator.loader; + +import static goodgenerator.util.ItemRefer.Compassline_Casing_EV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_HV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_IV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_LV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_LuV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_MV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_UEV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_UHV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_UIV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_UMV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_UV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_UXV; +import static goodgenerator.util.ItemRefer.Compassline_Casing_ZPM; +import static goodgenerator.util.ItemRefer.Component_Assembly_Line; +import static goodgenerator.util.Log.LOGGER; +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.HOURS; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_RecipeConstants.AssemblyLine; +import static gregtech.api.util.GT_RecipeConstants.RESEARCH_ITEM; +import static gregtech.api.util.GT_RecipeConstants.RESEARCH_TIME; + +import java.util.HashMap; + +import javax.annotation.Nullable; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import org.apache.logging.log4j.Level; + +import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader; +import com.github.technus.tectech.recipe.TT_recipeAdder; + +import cpw.mods.fml.common.registry.GameRegistry; +import goodgenerator.items.MyMaterial; +import goodgenerator.util.StackUtils; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.MaterialsUEVplus; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gtPlusPlus.core.recipe.common.CI; + +public class ComponentAssemblyLineMiscRecipes { + + public static final String[] circuitTierMaterials = { "Primitive", "Basic", "Good", "Advanced", "Data", "Elite", + "Master", "Ultimate", "Superconductor", "Infinite", "Bio", "Optical", "Piko", "Quantum" }; + + static final HashMap NameToTier = new HashMap<>(); + + static void run() { + for (int i = 0; i < circuitTierMaterials.length; i++) NameToTier.put(circuitTierMaterials[i], i); + // Cry about it + NameToTier.put("Nano", 11); + + generateCasingRecipes(); + generateWrapRecipes(); + // Try and find the ZPM Fluid solidifier + ItemStack solidifier; + try { + Class c = Class.forName("com.dreammaster.gthandler.CustomItemList"); + Object maybeSolidifier = c.getMethod("valueOf", String.class) + .invoke(null, "FluidSolidifierZPM"); + solidifier = (ItemStack) (c.getMethod("get", long.class, Object[].class) + .invoke(maybeSolidifier, 16L, null)); + if (GT_Utility.isStackValid(solidifier)) LOGGER.log(Level.INFO, "ZPM Fluid Solidifier found."); + else throw new NullPointerException(); + } catch (Exception e) { + LOGGER.log(Level.ERROR, "ZPM Fluid Solidifier not found, falling back to IV.", e); + solidifier = ItemList.Machine_IV_FluidSolidifier.get(16); + } + + // The controller itself + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, Compassline_Casing_EV.get(1)) + .metadata(RESEARCH_TIME, 1 * HOURS) + .itemInputs( + ItemList.Machine_Multi_Assemblyline.get(16L), + ItemList.Casing_Assembler.get(16L), + ItemList.Casing_Gearbox_TungstenSteel.get(32L), + ComponentType.Robot_Arm.getComponent(8) + .get(16), + ComponentType.Conveyor_Module.getComponent(8) + .get(32), + ComponentType.Electric_Motor.getComponent(7) + .get(32), + GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.Polybenzimidazole, 16), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Iridium, 32), + solidifier, + getALCircuit(8, 16), + getALCircuit(7, 20), + getALCircuit(6, 24)) + .fluidInputs( + new FluidStack(FluidRegistry.getFluid("molten.indalloy140"), 144 * 12), + Materials.Naquadria.getMolten(144 * 16), + Materials.Lubricant.getFluid(5000)) + .itemOutputs(Component_Assembly_Line.get(1)) + .eut(TierEU.RECIPE_UHV / 2) + .duration(30 * SECONDS) + .addTo(AssemblyLine); + } + + /** Recipes for the Component Assembly Line Casings */ + private static void generateCasingRecipes() { + int t = 1; + // lv 1 + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Steel, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Steel, 4), + ComponentType.Robot_Arm.getComponent(t) + .get(4), + ComponentType.Electric_Piston.getComponent(t) + .get(8), + ComponentType.Electric_Motor.getComponent(t) + .get(10), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Steel, 4), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.Tin, 6), + getCircuit(t, 16)) + .fluidInputs(Materials.SolderingAlloy.getMolten(144 * (t + 1))) + .itemOutputs(Compassline_Casing_LV.get(1)) + .duration(16 * SECONDS) + .eut(GT_Values.VP[t]) + .addTo(assemblerRecipes); + // mv 2 + t++; + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Aluminium, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Aluminium, 4), + ComponentType.Robot_Arm.getComponent(t) + .get(4), + ComponentType.Electric_Piston.getComponent(t) + .get(8), + ComponentType.Electric_Motor.getComponent(t) + .get(10), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Aluminium, 4), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.AnyCopper, 6), + getCircuit(t, 8), + getCircuit(t - 1, 16)) + .fluidInputs(Materials.SolderingAlloy.getMolten(144 * (t + 1))) + .itemOutputs(Compassline_Casing_MV.get(1)) + .duration(16 * SECONDS) + .eut(GT_Values.VP[t]) + .addTo(assemblerRecipes); + // hv 3 + t++; + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.StainlessSteel, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.StainlessSteel, 4), + ComponentType.Robot_Arm.getComponent(t) + .get(4), + ComponentType.Electric_Piston.getComponent(t) + .get(8), + ComponentType.Electric_Motor.getComponent(t) + .get(10), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.StainlessSteel, 4), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.Gold, 6), + getCircuit(t, 8), + getCircuit(t - 1, 16)) + .fluidInputs(Materials.SolderingAlloy.getMolten(144 * (t + 1))) + .itemOutputs(Compassline_Casing_HV.get(1)) + .duration(16 * SECONDS) + .eut(GT_Values.VP[t]) + .addTo(assemblerRecipes); + // ev 4 + t++; + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Titanium, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Titanium, 4), + ComponentType.Robot_Arm.getComponent(t) + .get(4), + ComponentType.Electric_Piston.getComponent(t) + .get(8), + ComponentType.Electric_Motor.getComponent(t) + .get(10), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Titanium, 4), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.Aluminium, 6), + getCircuit(t, 8), + getCircuit(t - 1, 16)) + .fluidInputs(Materials.SolderingAlloy.getMolten(144 * (t + 1))) + .itemOutputs(Compassline_Casing_EV.get(1)) + .duration(16 * SECONDS) + .eut(GT_Values.VP[t]) + .addTo(assemblerRecipes); + // iv 5 + t++; + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.TungstenSteel, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.TungstenSteel, 4), + ComponentType.Robot_Arm.getComponent(t) + .get(4), + ComponentType.Electric_Piston.getComponent(t) + .get(8), + ComponentType.Electric_Motor.getComponent(t) + .get(10), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.TungstenSteel, 4), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.Tungsten, 6), + getCircuit(t, 8), + getCircuit(t - 1, 16)) + .fluidInputs(Materials.SolderingAlloy.getMolten(144 * (t + 1))) + .itemOutputs(Compassline_Casing_IV.get(1)) + .duration(16 * SECONDS) + .eut(GT_Values.VP[t]) + .addTo(assemblerRecipes); + + Fluid sold = FluidRegistry.getFluid("molten.indalloy140"); + // Assline Recipes! + // luv 6 + t++; + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, Compassline_Casing_IV.get(1)) + .metadata(RESEARCH_TIME, (2250 << t) * TICKS) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Europium, 1), + WerkstoffLoader.LuVTierMaterial.get(OrePrefixes.plateDense, 6), + ComponentType.Robot_Arm.getComponent(t) + .get(8), + ComponentType.Electric_Piston.getComponent(t) + .get(10), + ComponentType.Electric_Motor.getComponent(t) + .get(16), + WerkstoffLoader.LuVTierMaterial.get(OrePrefixes.gearGt, 4), + WerkstoffLoader.LuVTierMaterial.get(OrePrefixes.gearGtSmall, 16), + GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.VanadiumGallium, 8), + getALCircuit(t, 8), + getALCircuit(t - 1, 16)) + .fluidInputs( + new FluidStack(sold, 144 * t * 4), + CI.getTieredFluid(t, 144 * t * 2), + StackUtils.getTieredFluid(t, 144 * t), + Materials.Lubricant.getFluid(1000 * (t - 2))) + .itemOutputs(Compassline_Casing_LuV.get(1)) + .eut(TierEU.RECIPE_IV) + .duration(30 * SECONDS) + .addTo(AssemblyLine); + // zpm 7 + t++; + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, Compassline_Casing_LuV.get(1)) + .metadata(RESEARCH_TIME, (2250 << t) * TICKS) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Iridium, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Iridium, 6), + ComponentType.Robot_Arm.getComponent(t) + .get(8), + ComponentType.Electric_Piston.getComponent(t) + .get(10), + ComponentType.Electric_Motor.getComponent(t) + .get(16), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Iridium, 4), + GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, Materials.Iridium, 16), + GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.Naquadah, 8), + getALCircuit(t, 8), + getALCircuit(t - 1, 16)) + .fluidInputs( + new FluidStack(sold, 144 * t * 4), + CI.getTieredFluid(t, 144 * t * 2), + StackUtils.getTieredFluid(t, 144 * t), + Materials.Lubricant.getFluid(1000 * (t - 2))) + .itemOutputs(Compassline_Casing_ZPM.get(1)) + .eut(TierEU.RECIPE_LuV) + .duration(30 * SECONDS) + .addTo(AssemblyLine); + // uv 8 + t++; + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, Compassline_Casing_ZPM.get(1)) + .metadata(RESEARCH_TIME, (2250 << t) * TICKS) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Osmium, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Osmium, 6), + ComponentType.Robot_Arm.getComponent(t) + .get(8), + ComponentType.Electric_Piston.getComponent(t) + .get(10), + ComponentType.Electric_Motor.getComponent(t) + .get(16), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Osmium, 4), + GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, Materials.Osmium, 16), + GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.NaquadahAlloy, 8), + getALCircuit(t, 8), + getALCircuit(t - 1, 16)) + .fluidInputs( + new FluidStack(sold, 144 * t * 4), + CI.getTieredFluid(t, 144 * t * 2), + StackUtils.getTieredFluid(t, 144 * t), + Materials.Lubricant.getFluid(1000 * (t - 2))) + .itemOutputs(Compassline_Casing_UV.get(1)) + .eut(TierEU.RECIPE_ZPM) + .duration(30 * SECONDS) + .addTo(AssemblyLine); + // uhv 9 + t++; + TT_recipeAdder.addResearchableAssemblylineRecipe( + Compassline_Casing_UV.get(1), + 375 << (t - 2), + 1 << (t - 3), + (int) TierEU.RECIPE_UV, + 1, + new Object[] { GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.CosmicNeutronium, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.CosmicNeutronium, 6), + ComponentType.Robot_Arm.getComponent(t) + .get(8), + ComponentType.Electric_Piston.getComponent(t) + .get(10), + ComponentType.Electric_Motor.getComponent(t) + .get(16), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.CosmicNeutronium, 4), + GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, Materials.CosmicNeutronium, 16), + GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.Bedrockium, 8), getALCircuit(t, 8), + getALCircuit(t - 1, 16) }, + new FluidStack[] { new FluidStack(sold, 144 * t * 4), CI.getTieredFluid(t, 144 * t * 2), + StackUtils.getTieredFluid(t, 144 * t), Materials.Lubricant.getFluid(1000 * (t - 2)) }, + Compassline_Casing_UHV.get(1), + 50 * SECONDS, + (int) TierEU.RECIPE_UV); + sold = FluidRegistry.getFluid("molten.mutatedlivingsolder"); + // uev 10 + t++; + TT_recipeAdder.addResearchableAssemblylineRecipe( + Compassline_Casing_UHV.get(1), + 375 << (t - 2), + 1 << (t - 3), + (int) TierEU.RECIPE_UHV, + 1, + new Object[] { GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Infinity, 6), + ComponentType.Robot_Arm.getComponent(t) + .get(8), + ComponentType.Electric_Piston.getComponent(t) + .get(10), + ComponentType.Electric_Motor.getComponent(t) + .get(16), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Infinity, 4), + GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, Materials.Infinity, 16), + GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.Draconium, 8), getALCircuit(t, 8), + getALCircuit(t - 1, 16) }, + new FluidStack[] { new FluidStack(sold, 144 * t * 4), CI.getTieredFluid(t, 144 * t * 2), + StackUtils.getTieredFluid(t, 144 * t), Materials.Lubricant.getFluid(1000 * (t - 2)) }, + Compassline_Casing_UEV.get(1), + 50 * SECONDS, + (int) TierEU.RECIPE_UHV); + // uiv 11 + t++; + TT_recipeAdder.addResearchableAssemblylineRecipe( + Compassline_Casing_UEV.get(1), + 375 << (t - 2), + 1 << (t - 3), + (int) TierEU.RECIPE_UEV, + 1, + new Object[] { GT_OreDictUnificator.get(OrePrefixes.frameGt, MaterialsUEVplus.TranscendentMetal, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.TranscendentMetal, 6), + ComponentType.Robot_Arm.getComponent(t) + .get(8), + ComponentType.Electric_Piston.getComponent(t) + .get(10), + ComponentType.Electric_Motor.getComponent(t) + .get(16), + GT_OreDictUnificator.get(OrePrefixes.gearGt, MaterialsUEVplus.TranscendentMetal, 4), + GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, MaterialsUEVplus.TranscendentMetal, 16), + GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.NetherStar, 8), getALCircuit(t, 8), + getALCircuit(t - 1, 16) }, + new FluidStack[] { new FluidStack(sold, 144 * t * 4), CI.getTieredFluid(t, 144 * t * 2), + StackUtils.getTieredFluid(t, 144 * t), Materials.Lubricant.getFluid(1000 * (t - 2)) }, + Compassline_Casing_UIV.get(1), + 50 * SECONDS, + (int) TierEU.RECIPE_UEV); + // umv 12 + t++; + TT_recipeAdder.addResearchableAssemblylineRecipe( + Compassline_Casing_UIV.get(1), + 375 << (t - 2), + 1 << (t - 3), + (int) TierEU.RECIPE_UIV, + 1, + new Object[] { GT_OreDictUnificator.get(OrePrefixes.frameGt, MaterialsUEVplus.SpaceTime, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.SpaceTime, 6), + ComponentType.Robot_Arm.getComponent(t) + .get(8), + ComponentType.Electric_Piston.getComponent(t) + .get(10), + ComponentType.Electric_Motor.getComponent(t) + .get(16), + GT_OreDictUnificator.get(OrePrefixes.gearGt, MaterialsUEVplus.SpaceTime, 4), + GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, MaterialsUEVplus.SpaceTime, 16), + GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.Quantium, 8), getALCircuit(t, 8), + getALCircuit(t - 1, 16) }, + new FluidStack[] { new FluidStack(sold, 144 * t * 4), CI.getTieredFluid(t - 1, 144 * t * 2), + StackUtils.getTieredFluid(t, 144 * t), Materials.Lubricant.getFluid(1000 * (t - 2)) }, + Compassline_Casing_UMV.get(1), + 50 * 20, + (int) TierEU.RECIPE_UIV); + // uxv 13 + t++; + TT_recipeAdder.addResearchableAssemblylineRecipe( + Compassline_Casing_UMV.get(1), + 375 << (t - 2), + 1 << (t - 3), + (int) TierEU.RECIPE_UMV, + 1, + new Object[] { + GT_OreDictUnificator + .get(OrePrefixes.frameGt, MaterialsUEVplus.MagnetohydrodynamicallyConstrainedStarMatter, 1), + GT_OreDictUnificator + .get(OrePrefixes.plateDense, MaterialsUEVplus.MagnetohydrodynamicallyConstrainedStarMatter, 3), + MyMaterial.shirabon.get(OrePrefixes.plateDense, 3), ComponentType.Robot_Arm.getComponent(t) + .get(8), + ComponentType.Electric_Piston.getComponent(t) + .get(10), + ComponentType.Electric_Motor.getComponent(t) + .get(16), + GT_OreDictUnificator + .get(OrePrefixes.gearGt, MaterialsUEVplus.MagnetohydrodynamicallyConstrainedStarMatter, 2), + MyMaterial.shirabon.get(OrePrefixes.gearGt, 2), + GT_OreDictUnificator + .get(OrePrefixes.gearGtSmall, MaterialsUEVplus.MagnetohydrodynamicallyConstrainedStarMatter, 8), + MyMaterial.shirabon.get(OrePrefixes.gearGtSmall, 8), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.Infinity, 4), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, MaterialsUEVplus.SpaceTime, 4), getALCircuit(t, 8), + getALCircuit(t - 1, 16) }, + new FluidStack[] { new FluidStack(sold, 144 * t * 4), + MaterialsUEVplus.BlackDwarfMatter.getMolten(144 * t * 2), MaterialsUEVplus.Eternity.getMolten(144 * t), + Materials.Lubricant.getFluid(1000 * (t - 2)) }, + Compassline_Casing_UXV.get(1), + 50 * SECONDS, + (int) TierEU.RECIPE_UMV); + } + + private static void generateWrapRecipes() { + for (int i = 0; i <= 11; i++) { + GT_Values.RA.stdBuilder() + .itemInputs(getCircuit(i, 16), GT_Utility.getIntegratedCircuit(16)) + .fluidInputs(Materials.SolderingAlloy.getMolten(72L)) + .itemOutputs(new ItemStack(Loaders.circuitWrap, 1, i)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(assemblerRecipes); + } + GT_Values.RA.stdBuilder() + .itemInputs( + GameRegistry.findItemStack("dreamcraft", "item.PikoCircuit", 16), + GT_Utility.getIntegratedCircuit(16)) + .fluidInputs(Materials.SolderingAlloy.getMolten(72L)) + .itemOutputs(new ItemStack(Loaders.circuitWrap, 1, 12)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GameRegistry.findItemStack("dreamcraft", "item.QuantumCircuit", 16), + GT_Utility.getIntegratedCircuit(16)) + .fluidInputs(Materials.SolderingAlloy.getMolten(72L)) + .itemOutputs(new ItemStack(Loaders.circuitWrap, 1, 13)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(assemblerRecipes); + } + + @SuppressWarnings("unused") + private enum ComponentType { + + Electric_Motor, + Electric_Piston, + Robot_Arm, + Electric_Pump, + Field_Generator, + Conveyor_Module, + Emitter, + Sensor; + + public ItemList getComponent(int tier) { + if (tier < 0 || tier > GT_Values.VN.length) throw new IllegalArgumentException("Tier is out of range!"); + return ItemList.valueOf(this.name() + "_" + GT_Values.VN[tier]); + } + } + + private static ItemStack getCircuit(int tier, long amount) { + return GT_OreDictUnificator.get(OrePrefixes.circuit, getCircuitMaterial(tier), amount); + } + + private static Object[] getALCircuit(int tier, int amount) { + return new Object[] { OrePrefixes.circuit.get(getCircuitMaterial(tier)), amount }; + } + + @Nullable + public static Materials getCircuitMaterial(int tier) { + return Materials.getRealMaterial(circuitTierMaterials[tier]); + } +} diff --git a/src/main/java/goodgenerator/loader/ComponentAssemblyLineRecipeLoader.java b/src/main/java/goodgenerator/loader/ComponentAssemblyLineRecipeLoader.java new file mode 100644 index 0000000000..f1b16089d9 --- /dev/null +++ b/src/main/java/goodgenerator/loader/ComponentAssemblyLineRecipeLoader.java @@ -0,0 +1,484 @@ +package goodgenerator.loader; + +import static goodgenerator.util.StackUtils.getTotalItems; +import static goodgenerator.util.StackUtils.mergeStacks; +import static goodgenerator.util.StackUtils.multiplyAndSplitIntoStacks; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.stream.Collectors; + +import javax.annotation.Nullable; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.oredict.OreDictionary; + +import org.apache.commons.lang3.tuple.Pair; + +import goodgenerator.util.MyRecipeAdder; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.MaterialsUEVplus; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.objects.ItemData; +import gregtech.api.recipe.RecipeMaps; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; +import gregtech.common.items.GT_IntegratedCircuit_Item; + +public class ComponentAssemblyLineRecipeLoader { + + private static final String[] compPrefixes = { "Electric_Motor_", "Electric_Piston_", "Electric_Pump_", + "Robot_Arm_", "Conveyor_Module_", "Emitter_", "Sensor_", "Field_Generator_", }; + private static final String[] blacklistedDictPrefixes = { "circuit" }; + private static final String[] softBlacklistedDictPrefixes = { "Any", "crafting", "nanite" }; + private static final String moltenMHDCSM = "molten.magnetohydrodynamicallyconstrainedstarmatter"; + + private static LinkedHashMap, Pair> allAssemblerRecipes; + private static LinkedHashMap, Pair> allAsslineRecipes; + + private static final HashMap magnetoConversionMultipliers = new HashMap<>(); + private static final HashMap conversion = new HashMap<>(); + + private static final int INPUT_MULTIPLIER = 48; + private static final int OUTPUT_MULTIPLIER = 64; + private static final int FLUID_CONVERSION_STACKSIZE_THRESHOLD = 64; + + public static void run() { + ComponentAssemblyLineMiscRecipes.run(); + conversion.put(OrePrefixes.cableGt01, OrePrefixes.cableGt16); + conversion.put(OrePrefixes.wireGt01, OrePrefixes.wireGt16); + conversion.put(OrePrefixes.cableGt02, OrePrefixes.cableGt16); + conversion.put(OrePrefixes.wireGt02, OrePrefixes.wireGt16); + conversion.put(OrePrefixes.cableGt04, OrePrefixes.cableGt16); + conversion.put(OrePrefixes.wireGt04, OrePrefixes.wireGt16); + conversion.put(OrePrefixes.cableGt08, OrePrefixes.cableGt16); + conversion.put(OrePrefixes.wireGt08, OrePrefixes.wireGt16); + conversion.put(OrePrefixes.plate, OrePrefixes.plateDense); + conversion.put(OrePrefixes.foil, OrePrefixes.plate); + conversion.put(OrePrefixes.stick, OrePrefixes.stickLong); + conversion.put(OrePrefixes.gearGtSmall, OrePrefixes.gearGt); + magnetoConversionMultipliers.put(OrePrefixes.frameGt, 1.0); + magnetoConversionMultipliers.put(OrePrefixes.plate, 1.0); + magnetoConversionMultipliers.put(OrePrefixes.plateDense, 3.0); + magnetoConversionMultipliers.put(OrePrefixes.stick, 1.0 / 2.0); + magnetoConversionMultipliers.put(OrePrefixes.round, 1.0 / 8.0); + magnetoConversionMultipliers.put(OrePrefixes.bolt, 1.0 / 8.0); + magnetoConversionMultipliers.put(OrePrefixes.screw, 1.0 / 8.0); + magnetoConversionMultipliers.put(OrePrefixes.ring, 1.0 / 4.0); + magnetoConversionMultipliers.put(OrePrefixes.foil, 1.0 / 8.0); + magnetoConversionMultipliers.put(OrePrefixes.gearGtSmall, 1.0); + magnetoConversionMultipliers.put(OrePrefixes.rotor, 2.0); + magnetoConversionMultipliers.put(OrePrefixes.stickLong, 1.0); + magnetoConversionMultipliers.put(OrePrefixes.gearGt, 2.0); + magnetoConversionMultipliers.put(OrePrefixes.wireFine, 1.0 / 8.0); + findAllRecipes(); + generateAssemblerRecipes(); + generateAsslineRecipes(); + } + + /** Normal assembler recipes (LV-IV) */ + private static void generateAssemblerRecipes() { + allAssemblerRecipes.forEach((recipeList, info) -> { + for (GT_Recipe recipe : recipeList) { + if (recipe != null) { + ArrayList fixedInputs = new ArrayList<>(); + ArrayList fixedFluids = new ArrayList<>(); + + for (int j = 0; j < recipe.mInputs.length; j++) { + ItemStack input = recipe.mInputs[j]; + if (GT_Utility.isStackValid(input) && !(input.getItem() instanceof GT_IntegratedCircuit_Item)) + fixedInputs.addAll(multiplyAndSplitIntoStacks(input, INPUT_MULTIPLIER)); + } + for (int j = 0; j < recipe.mFluidInputs.length; j++) { + FluidStack currFluid = recipe.mFluidInputs[j].copy(); + currFluid.amount = currFluid.amount * INPUT_MULTIPLIER; + fixedFluids.add(currFluid); + } + + fixedInputs = compactItems(fixedInputs, info.getRight()); + replaceIntoFluids(fixedInputs, fixedFluids, 64); + int tier = info.getRight(); + int energy = (int) Math.min(Integer.MAX_VALUE - 7, GT_Values.VP[tier - 1]); + MyRecipeAdder.instance.addComponentAssemblyLineRecipe( + fixedInputs.toArray(new ItemStack[0]), + fixedFluids.toArray(new FluidStack[0]), + info.getLeft() + .get(OUTPUT_MULTIPLIER), + recipe.mDuration * INPUT_MULTIPLIER, + energy, + info.getRight()); + } + } + }); + } + + /** Assembly Line Recipes (LuV+) **/ + private static void generateAsslineRecipes() { + allAsslineRecipes.forEach((recipeList, info) -> { + for (GT_Recipe.GT_Recipe_AssemblyLine recipe : recipeList) { + if (recipe != null) { + int componentCircuit = -1; + for (int i = 0; i < compPrefixes.length; i++) if (info.getLeft() + .toString() + .startsWith(compPrefixes[i])) componentCircuit = i + 1; + if (componentCircuit == -1) { + throw new NullPointerException( + "Wrong circuit. Comp: " + info.getLeft() + .toString()); + } + final boolean addProgrammedCircuit = componentCircuit <= 7; + // Arrays of the item and fluid inputs, that are updated to be multiplied and/or condensed in the + // following code + ArrayList fixedInputs = new ArrayList<>(); + ArrayList fixedFluids = new ArrayList<>(); + + // Multiplies the original fluid inputs + for (int j = 0; j < recipe.mFluidInputs.length; j++) { + FluidStack currFluid = recipe.mFluidInputs[j].copy(); + currFluid.amount *= (double) INPUT_MULTIPLIER; + fixedFluids.add(currFluid); + } + + // First pass. + for (ItemStack input : recipe.mInputs) { + if (GT_Utility.isStackValid(input)) { + int count = input.stackSize; + // Mulitplies the input by its multiplier, and adjusts the stacks accordingly + if (!(input.getItem() instanceof GT_IntegratedCircuit_Item)) { + + ItemData data = GT_OreDictUnificator.getAssociation(input); + // trying to fix some circuit oredicting issues + + if (data != null && data.mPrefix == OrePrefixes.circuit) fixedInputs.addAll( + multiplyAndSplitIntoStacks( + GT_OreDictUnificator.get(data.mPrefix, data.mMaterial.mMaterial, count), + INPUT_MULTIPLIER)); + else fixedInputs.addAll(multiplyAndSplitIntoStacks(input, INPUT_MULTIPLIER)); + } + } + } + fixedInputs = compactItems(fixedInputs, info.getRight()); + replaceIntoFluids(fixedInputs, fixedFluids, FLUID_CONVERSION_STACKSIZE_THRESHOLD); + // If it overflows then it tries REALLY HARD to cram as much stuff into there. + if (fixedInputs.size() > (addProgrammedCircuit ? 8 : 9)) + replaceIntoFluids(fixedInputs, fixedFluids, FLUID_CONVERSION_STACKSIZE_THRESHOLD / 2); + if (addProgrammedCircuit) fixedInputs.add(GT_Utility.getIntegratedCircuit(componentCircuit)); + + addEternityForMHDCSM(fixedFluids); + MyRecipeAdder.instance.addComponentAssemblyLineRecipe( + fixedInputs.toArray(new ItemStack[0]), + fixedFluids.toArray(new FluidStack[0]), + info.getLeft() + .get(OUTPUT_MULTIPLIER), // The component output + recipe.mDuration * INPUT_MULTIPLIER, // Takes as long as this many + recipe.mEUt, + info.getRight()); // Casing tier + + // Add a second recipe using Styrene-Butadiene + // Rubber instead of Silicone Rubber. + // This relies on silicone rubber being first in + // @allSyntheticRubber so it's quite fragile, but + // it's also the least invasive change. + if (swapSiliconeForStyreneButadiene(fixedFluids)) { + MyRecipeAdder.instance.addComponentAssemblyLineRecipe( + fixedInputs.toArray(new ItemStack[0]), + fixedFluids.toArray(new FluidStack[0]), + info.getLeft() + .get(OUTPUT_MULTIPLIER), // The component output + recipe.mDuration * INPUT_MULTIPLIER, // Takes as long as this many + recipe.mEUt, + info.getRight()); // Casing tier + } + } + } + }); + } + + /** + * Looks for a matching FluidStack and merges the amount of the converted fluid with the one it found. Otherwise, it + * will add the converted to the fluid inputs. + */ + private static void replaceIntoFluids(List inputs, List fluidOutputs, int threshold) { + HashMap totals = getTotalItems(inputs.toArray(new ItemStack[0])); + ArrayList newInputs = new ArrayList<>(); + for (ItemStack input : totals.keySet()) { + int count = totals.get(input); + boolean isConverted = false; + if (OreDictionary.getOreIDs(input).length > 0 && count > threshold) { + FluidStack foundFluidStack = tryConvertItemStackToFluidMaterial(input); + + ItemData data = GT_OreDictUnificator.getAssociation(input); + + // Prevents the uncraftable molten magnetic samarium from being converted into fluid during auto + // generation + if (data != null && data.mMaterial.mMaterial == Materials.SamariumMagnetic) { + input = GT_OreDictUnificator.get(data.mPrefix, Materials.Samarium, 1); + foundFluidStack = tryConvertItemStackToFluidMaterial(input); + } else if (data != null && data.mMaterial.mMaterial == Materials.TengamAttuned) { + input = GT_OreDictUnificator.get(data.mPrefix, Materials.TengamPurified, 1); + foundFluidStack = tryConvertItemStackToFluidMaterial(input); + } + + if (foundFluidStack != null) { + foundFluidStack.amount *= count; + boolean alreadyHasFluid = false; + for (FluidStack fluidstack : fluidOutputs) { + if (foundFluidStack.getFluid() + .equals(fluidstack.getFluid())) { + fluidstack.amount += foundFluidStack.amount; + alreadyHasFluid = true; + break; + } + } + if (!alreadyHasFluid) { + fluidOutputs.add(foundFluidStack); + } + isConverted = true; + } + } + if (!isConverted) { + newInputs.add(GT_Utility.copyAmountUnsafe(count, input)); + } + } + inputs.clear(); + inputs.addAll(newInputs); + } + + /** + * Tries to convert {@code input} into its molten form. Because the internal names for material fluids in GT5u, + * GT++, and BartWorks follow the same naming scheme, this method should work for any {@code ItemStack} from any of + * the 3 material systems. + */ + @Nullable + private static FluidStack tryConvertItemStackToFluidMaterial(ItemStack input) { + ArrayList oreDicts = new ArrayList<>(); + for (int id : OreDictionary.getOreIDs(input)) { + oreDicts.add(OreDictionary.getOreName(id)); + } + oreDictLoop: for (String dict : oreDicts) { + for (String blacklistedPrefix : blacklistedDictPrefixes) { + if (dict.startsWith(blacklistedPrefix)) { + return null; + } + } + for (String blacklistedPrefix : softBlacklistedDictPrefixes) { + if (dict.startsWith(blacklistedPrefix)) { + continue oreDictLoop; + } + } + OrePrefixes orePrefix; + try { + orePrefix = OrePrefixes.valueOf(findBestPrefix(dict)); + } catch (Exception e) { + continue; + } + + String strippedOreDict = dict.substring( + orePrefix.toString() + .length()); + + // Prevents things like AnyCopper or AnyIron from messing the search up. + if (strippedOreDict.contains("Any")) continue; + if (strippedOreDict.contains("PTMEG")) return FluidRegistry.getFluidStack( + "molten.silicone", + (int) (orePrefix.mMaterialAmount / (GT_Values.M / 144)) * input.stackSize); + return FluidRegistry.getFluidStack( + "molten." + strippedOreDict.toLowerCase(), + (int) (orePrefix.mMaterialAmount / (GT_Values.M / 144)) * input.stackSize); + } + return null; + } + + /** + * Gives the longest Ore Prefix that the OreDictionary string starts with. This makes it the most accurate prefix. + * For example: If your OreDictionary is something like {@code gearGtSmallSpaceTime}, a conventional search would + * return something like {@code gearGt} instead of {@code gearGtSmall}. This makes the longer String the most + * accurate. + * + * @param oreDict The Ore Dictionary entry + * @return The longest ore prefix that the OreDict string starts with. This makes it the most accurate prefix. + */ + private static String findBestPrefix(String oreDict) { + int longestPrefixLength = 0; + String matchingPrefix = null; + for (OrePrefixes prefix : OrePrefixes.values()) { + String name = prefix.toString(); + if (oreDict.startsWith(name)) { + if (name.length() > longestPrefixLength) { + longestPrefixLength = name.length(); + matchingPrefix = name; + } + } + } + return matchingPrefix; + } + + /** + * Transforms each {@code ItemStack}, if possible, into a more compact form. For example, a stack of 16 1x cables, + * when passed into the {@code items} array, will be converted into a single 16x cable. Also handles GraviStar and + * neutronium nanite conversion. + */ + private static ArrayList compactItems(List items, int tier) { + ArrayList stacks = new ArrayList<>(); + HashMap totals = getTotalItems(items); + for (ItemStack itemstack : totals.keySet()) { + int totalItems = totals.get(itemstack); + ItemData data = GT_OreDictUnificator.getAssociation(itemstack); + boolean isCompacted = false; + + for (String dict : Arrays.stream(OreDictionary.getOreIDs(itemstack)) + .mapToObj(OreDictionary::getOreName) + .collect(Collectors.toList())) { + if (dict.startsWith("circuit")) { + stacks.addAll(getWrappedCircuits(itemstack, totalItems, dict)); + isCompacted = true; + break; + } + if (dict.contains("Magneto")) { + stacks.addAll(getMagnetoConversion(itemstack, totalItems)); + isCompacted = true; + break; + } + } + + if (data != null && !isCompacted) { + OrePrefixes goInto = conversion.get(data.mPrefix); + if (goInto != null && GT_OreDictUnificator.get(goInto, data.mMaterial.mMaterial, 1) != null) { + compactorHelper(data, goInto, stacks, totalItems); + isCompacted = true; + } + } + if (GT_Utility.areStacksEqual(itemstack, ItemList.Gravistar.get(1)) && tier >= 9) { + stacks.addAll(multiplyAndSplitIntoStacks(ItemList.NuclearStar.get(1), totalItems / 16)); + isCompacted = true; + } + if (GT_Utility + .areStacksEqual(itemstack, GT_OreDictUnificator.get(OrePrefixes.nanite, Materials.Neutronium, 1))) { + stacks.addAll( + multiplyAndSplitIntoStacks( + GT_OreDictUnificator.get(OrePrefixes.nanite, Materials.Gold, 1), + totalItems / 16)); + isCompacted = true; + } + if (!isCompacted) stacks.addAll(multiplyAndSplitIntoStacks(itemstack, totalItems)); + } + stacks = mergeStacks(stacks); + return stacks; + } + + /** A helper method for compacting items */ + private static void compactorHelper(ItemData data, OrePrefixes compactInto, ArrayList output, + int total) { + int materialRatio = (int) ((double) compactInto.mMaterialAmount / data.mPrefix.mMaterialAmount); + output.addAll( + multiplyAndSplitIntoStacks( + GT_OreDictUnificator.get(compactInto, data.mMaterial.mMaterial, 1), + total / materialRatio)); + } + + /** + * Searches the Assembler and Assembly line registry for all the base component recipes. + */ + private static void findAllRecipes() { + allAssemblerRecipes = new LinkedHashMap<>(); + allAsslineRecipes = new LinkedHashMap<>(); + for (String compPrefix : compPrefixes) { + for (int t = 1; t <= 13; t++) { + String vName = GT_Values.VN[t]; + ItemList currentComponent = ItemList.valueOf(compPrefix + vName); + if (currentComponent.hasBeenSet()) { + if (t < 6) { + ArrayList foundRecipes = new ArrayList<>(); + for (GT_Recipe recipe : RecipeMaps.assemblerRecipes.getAllRecipes()) { + if (GT_Utility.areStacksEqual(currentComponent.get(1), recipe.mOutputs[0])) { + foundRecipes.add(recipe); + } + } + allAssemblerRecipes.put(foundRecipes, Pair.of(currentComponent, t)); + } else { + ArrayList foundRecipes = new ArrayList<>(); + for (GT_Recipe.GT_Recipe_AssemblyLine recipe : GT_Recipe.GT_Recipe_AssemblyLine.sAssemblylineRecipes) { + if (GT_Utility.areStacksEqual(currentComponent.get(1), recipe.mOutput)) { + foundRecipes.add(recipe); + } + } + allAsslineRecipes.put(foundRecipes, Pair.of(currentComponent, t)); + } + } + } + } + } + + private static List getWrappedCircuits(ItemStack item, int total, String oreDict) { + ArrayList stacks = new ArrayList<>(); + String circuitMaterial = oreDict.substring(7); + int tier = ComponentAssemblyLineMiscRecipes.NameToTier.get(circuitMaterial); + if (total >= 16) + stacks.addAll(multiplyAndSplitIntoStacks(new ItemStack(Loaders.circuitWrap, 1, tier), total / 16)); + else stacks.addAll(multiplyAndSplitIntoStacks(item, total)); + + return stacks; + } + + private static List getMagnetoConversion(ItemStack item, int total) { + ArrayList stacks = new ArrayList<>(); + ItemData data = GT_OreDictUnificator.getAssociation(item); + if (data == null) { + return stacks; + } + if (total >= FLUID_CONVERSION_STACKSIZE_THRESHOLD) { + double multiplier = magnetoConversionMultipliers.get(data.mPrefix); + stacks.addAll( + getWrappedCircuits( + GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Infinite, 1), + (int) (total * multiplier), + "circuitInfinite")); + } + stacks.addAll(multiplyAndSplitIntoStacks(item, total)); + return stacks; + } + + private static void addEternityForMHDCSM(ArrayList fluidInputs) { + boolean eternity = false; + boolean mhdcsm = false; + int mhdcsmAmount = 0; + + for (FluidStack fluidstack : fluidInputs) { + if (fluidstack.getFluid() + .equals(FluidRegistry.getFluid(moltenMHDCSM))) { + mhdcsm = true; + mhdcsmAmount = fluidstack.amount; + } + if (fluidstack.getFluid() + .equals(FluidRegistry.getFluid("molten.eternity"))) { + eternity = true; + } + } + + if (mhdcsm && !eternity) { + // 576 * 48 is substracted because uxv parts have 576L mhdcsm fluid (not solid, so no EIC conversion needed) + // in their assline recipes and each CoAl recipe has 48x recipe inputs + fluidInputs.add(MaterialsUEVplus.Eternity.getMolten(mhdcsmAmount - 576 * 48)); + } + } + + private static boolean swapSiliconeForStyreneButadiene(ArrayList fluidInputs) { + for (int i = 0; i < fluidInputs.size(); i++) { + FluidStack fluidstack = fluidInputs.get(i); + if (fluidstack.getFluid() + .equals(FluidRegistry.getFluid("molten.silicone"))) { + fluidInputs.set(i, FluidRegistry.getFluidStack("molten.styrenebutadienerubber", fluidstack.amount)); + return true; + } + } + return false; + } +} diff --git a/src/main/java/goodgenerator/loader/FuelRecipeLoader.java b/src/main/java/goodgenerator/loader/FuelRecipeLoader.java new file mode 100644 index 0000000000..2a1981b201 --- /dev/null +++ b/src/main/java/goodgenerator/loader/FuelRecipeLoader.java @@ -0,0 +1,168 @@ +package goodgenerator.loader; + +import static goodgenerator.main.GG_Config_Loader.NaquadahFuelTime; +import static goodgenerator.main.GG_Config_Loader.NaquadahFuelVoltage; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader; + +import goodgenerator.items.MyMaterial; +import goodgenerator.util.ItemRefer; +import goodgenerator.util.MyRecipeAdder; +import gregtech.api.enums.Materials; +import gregtech.api.enums.MaterialsUEVplus; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gtPlusPlus.core.material.ELEMENT; + +public class FuelRecipeLoader { + + public static void RegisterFuel() { + // MyRecipeAdder.instance.addLiquidMentalFuel(Materials.NaquadahEnriched.getMolten(1L),Materials.Naquadah.getMolten(1L),32768,100); + // MyRecipeAdder.instance.addLiquidMentalFuel(Materials.Naquadria.getMolten(1L),Materials.Naquadah.getMolten(1L),262144,120); + MyRecipeAdder.instance.addLiquidMentalFuel( + MyMaterial.uraniumBasedLiquidFuelExcited.getFluidOrGas(1), + MyMaterial.uraniumBasedLiquidFuelDepleted.getFluidOrGas(1), + NaquadahFuelVoltage[0], + NaquadahFuelTime[0]); + MyRecipeAdder.instance.addLiquidMentalFuel( + MyMaterial.thoriumBasedLiquidFuelExcited.getFluidOrGas(1), + MyMaterial.thoriumBasedLiquidFuelDepleted.getFluidOrGas(1), + NaquadahFuelVoltage[1], + NaquadahFuelTime[1]); + MyRecipeAdder.instance.addLiquidMentalFuel( + MyMaterial.plutoniumBasedLiquidFuelExcited.getFluidOrGas(1), + MyMaterial.plutoniumBasedLiquidFuelDepleted.getFluidOrGas(1), + NaquadahFuelVoltage[2], + NaquadahFuelTime[2]); + MyRecipeAdder.instance.addLiquidMentalFuel( + MyMaterial.naquadahBasedFuelMkI.getFluidOrGas(1), + MyMaterial.naquadahBasedFuelMkIDepleted.getFluidOrGas(1), + NaquadahFuelVoltage[3], + NaquadahFuelTime[3]); + MyRecipeAdder.instance.addLiquidMentalFuel( + MyMaterial.naquadahBasedFuelMkII.getFluidOrGas(1), + MyMaterial.naquadahBasedFuelMkIIDepleted.getFluidOrGas(1), + NaquadahFuelVoltage[4], + NaquadahFuelTime[4]); + MyRecipeAdder.instance.addLiquidMentalFuel( + MyMaterial.naquadahBasedFuelMkIII.getFluidOrGas(1), + MyMaterial.naquadahBasedFuelMkIIIDepleted.getFluidOrGas(1), + NaquadahFuelVoltage[5], + NaquadahFuelTime[5]); + MyRecipeAdder.instance.addLiquidMentalFuel( + MyMaterial.naquadahBasedFuelMkIV.getFluidOrGas(1), + MyMaterial.naquadahBasedFuelMkIVDepleted.getFluidOrGas(1), + NaquadahFuelVoltage[6], + NaquadahFuelTime[6]); + MyRecipeAdder.instance.addLiquidMentalFuel( + MyMaterial.naquadahBasedFuelMkV.getFluidOrGas(1), + MyMaterial.naquadahBasedFuelMkVDepleted.getFluidOrGas(1), + NaquadahFuelVoltage[7], + NaquadahFuelTime[7]); + MyRecipeAdder.instance.addLiquidMentalFuel( + MyMaterial.naquadahBasedFuelMkVI.getFluidOrGas(1), + MyMaterial.naquadahBasedFuelMkVIDepleted.getFluidOrGas(1), + NaquadahFuelVoltage[8], + NaquadahFuelTime[8]); + // MK III Naquadah Fuel + MyRecipeAdder.instance.addNaquadahFuelRefineRecipe( + new FluidStack[] { MyMaterial.heavyNaquadahFuel.getFluidOrGas(800), + MyMaterial.lightNaquadahFuel.getFluidOrGas(1000), }, + new ItemStack[] { MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.dust, 4), + WerkstoffLoader.Tiberium.get(OrePrefixes.dust, 27), ItemRefer.High_Density_Uranium.get(2), + ItemRefer.High_Density_Plutonium.get(1), }, + MyMaterial.naquadahBasedFuelMkIII.getFluidOrGas(100), + 1100000, + 100, + 1); + + // Alternative higher tier recipe + MyRecipeAdder.instance.addNaquadahFuelRefineRecipe( + new FluidStack[] { MyMaterial.heavyNaquadahFuel.getFluidOrGas(800), + MyMaterial.lightNaquadahFuel.getFluidOrGas(1000), }, + new ItemStack[] { MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.dust, 8), + GT_ModHandler.getModItem("miscutils", "itemDustChromaticGlass", 9), + ItemRefer.High_Density_Uranium.get(2), ItemRefer.High_Density_Plutonium.get(1), }, + MyMaterial.naquadahBasedFuelMkIII.getFluidOrGas(200), + 2100000, + 100, + 1); + // MK IV Naquadah Fuel + MyRecipeAdder.instance.addNaquadahFuelRefineRecipe( + new FluidStack[] { MyMaterial.naquadahBasedFuelMkIII.getFluidOrGas(2000), + Materials.Praseodymium.getMolten(9216L) }, + new ItemStack[] { MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.dust, 27), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.NetherStar, 64), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.DraconiumAwakened, 64), + MyMaterial.orundum.get(OrePrefixes.dust, 32), }, + MyMaterial.naquadahBasedFuelMkIV.getFluidOrGas(250), + 46000000, + 160, + 2); + + // Alternate higher tier recipe + MyRecipeAdder.instance.addNaquadahFuelRefineRecipe( + new FluidStack[] { MyMaterial.naquadahBasedFuelMkIII.getFluidOrGas(2000), + new FluidStack(FluidRegistry.getFluid("molten.hypogen"), 1440) }, + new ItemStack[] { MyMaterial.extremelyUnstableNaquadah.get(OrePrefixes.dust, 27), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Bedrockium, 64), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.DraconiumAwakened, 64), + MyMaterial.orundum.get(OrePrefixes.dust, 64), }, + MyMaterial.naquadahBasedFuelMkIV.getFluidOrGas(500), + 75000000, + 160, + 2); + + // MK V Naquadah Fuel + MyRecipeAdder.instance.addNaquadahFuelRefineRecipe( + new FluidStack[] { MyMaterial.naquadahBasedFuelMkIV.getFluidOrGas(2000), + FluidRegistry.getFluidStack("heavyradox", 1000), }, + new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Infinity, 16), + MyMaterial.atomicSeparationCatalyst.get(OrePrefixes.dust, 32), }, + MyMaterial.naquadahBasedFuelMkV.getFluidOrGas(500), + 100000000, + 200, + 2); + + // Alternate higher tier recipe + MyRecipeAdder.instance.addNaquadahFuelRefineRecipe( + new FluidStack[] { MyMaterial.naquadahBasedFuelMkIV.getFluidOrGas(2000), + FluidRegistry.getFluidStack("heavyradox", 1000), }, + new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.dust, MaterialsUEVplus.SpaceTime, 8), + GT_OreDictUnificator.get(OrePrefixes.dust, MaterialsUEVplus.TranscendentMetal, 16), + MyMaterial.atomicSeparationCatalyst.get(OrePrefixes.dust, 48), }, + MyMaterial.naquadahBasedFuelMkV.getFluidOrGas(750), + 300000000, + 200, + 3); + + // MK VI Naquadah Fuel + MyRecipeAdder.instance.addNaquadahFuelRefineRecipe( + new FluidStack[] { MyMaterial.naquadahBasedFuelMkV.getFluidOrGas(2000), + FluidRegistry.getFluidStack("molten.shirabon", 1440), }, + new ItemStack[] { ELEMENT.STANDALONE.ASTRAL_TITANIUM.getDust(64), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Tritanium, 32), }, + MyMaterial.naquadahBasedFuelMkVI.getFluidOrGas(500), + 320000000, + 240, + 3); + + // Alternate higher tier recipe + MyRecipeAdder.instance.addNaquadahFuelRefineRecipe( + new FluidStack[] { MyMaterial.naquadahBasedFuelMkV.getFluidOrGas(2000), + FluidRegistry.getFluidStack("molten.shirabon", 1440), }, + new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.dust, MaterialsUEVplus.WhiteDwarfMatter, 8), + ELEMENT.STANDALONE.CELESTIAL_TUNGSTEN.getDust(64), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Tritanium, 48), }, + MyMaterial.naquadahBasedFuelMkVI.getFluidOrGas(750), + 530000000, + 240, + 4); + + } +} diff --git a/src/main/java/goodgenerator/loader/FuelRodLoader.java b/src/main/java/goodgenerator/loader/FuelRodLoader.java new file mode 100644 index 0000000000..9654479861 --- /dev/null +++ b/src/main/java/goodgenerator/loader/FuelRodLoader.java @@ -0,0 +1,248 @@ +package goodgenerator.loader; + +import static goodgenerator.util.DescTextLocalization.addText; + +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +import cpw.mods.fml.common.registry.GameRegistry; +import goodgenerator.items.DepletedFuelRod; +import goodgenerator.items.FuelRod; +import goodgenerator.main.GoodGenerator; + +public class FuelRodLoader { + + public static Item rodCompressedUraniumDepleted; + public static Item rodCompressedUraniumDepleted_2; + public static Item rodCompressedUraniumDepleted_4; + public static Item rodCompressedPlutoniumDepleted; + public static Item rodCompressedPlutoniumDepleted_2; + public static Item rodCompressedPlutoniumDepleted_4; + public static Item rodLiquidUraniumDepleted; + public static Item rodLiquidUraniumDepleted_2; + public static Item rodLiquidUraniumDepleted_4; + public static Item rodLiquidPlutoniumDepleted; + public static Item rodLiquidPlutoniumDepleted_2; + public static Item rodLiquidPlutoniumDepleted_4; + public static Item rodCompressedUranium; + public static Item rodCompressedUranium_2; + public static Item rodCompressedUranium_4; + public static Item rodCompressedPlutonium; + public static Item rodCompressedPlutonium_2; + public static Item rodCompressedPlutonium_4; + public static Item rodLiquidUranium; + public static Item rodLiquidUranium_2; + public static Item rodLiquidUranium_4; + public static Item rodLiquidPlutonium; + public static Item rodLiquidPlutonium_2; + public static Item rodLiquidPlutonium_4; + + public static void RegisterRod() { + rodCompressedUraniumDepleted = new DepletedFuelRod( + "rodCompressedUraniumDepleted", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 100); + rodCompressedUraniumDepleted_2 = new DepletedFuelRod( + "rodCompressedUraniumDepleted2", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 200); + rodCompressedUraniumDepleted_4 = new DepletedFuelRod( + "rodCompressedUraniumDepleted4", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 400); + rodCompressedPlutoniumDepleted = new DepletedFuelRod( + "rodCompressedPlutoniumDepleted", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 120); + rodCompressedPlutoniumDepleted_2 = new DepletedFuelRod( + "rodCompressedPlutoniumDepleted2", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 240); + rodCompressedPlutoniumDepleted_4 = new DepletedFuelRod( + "rodCompressedPlutoniumDepleted4", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 480); + rodLiquidUraniumDepleted = new DepletedFuelRod( + "rodLiquidUraniumDepleted", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 800); + rodLiquidUraniumDepleted_2 = new DepletedFuelRod( + "rodLiquidUraniumDepleted2", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 1600); + rodLiquidUraniumDepleted_4 = new DepletedFuelRod( + "rodLiquidUraniumDepleted4", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 3200); + rodLiquidPlutoniumDepleted = new DepletedFuelRod( + "rodLiquidPlutoniumDepleted", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 1000); + rodLiquidPlutoniumDepleted_2 = new DepletedFuelRod( + "rodLiquidPlutoniumDepleted2", + addText("depletedfuelrod.tooltip", 1), + GoodGenerator.GG, + 2000); + rodLiquidPlutoniumDepleted_4 = new DepletedFuelRod( + "rodLiquidPlutoniumDepleted4", + addText("depletedfuelrod.toolti