Move GoodGen sources

10 files changed, 6556 insertions, 0 deletions

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<String, Integer> 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<List<GT_Recipe>, Pair<ItemList, Integer>> allAssemblerRecipes;
+    private static LinkedHashMap<List<GT_Recipe.GT_Recipe_AssemblyLine>, Pair<ItemList, Integer>> allAsslineRecipes;
+
+    private static final HashMap<OrePrefixes, Double> magnetoConversionMultipliers = new HashMap<>();
+    private static final HashMap<OrePrefixes, OrePrefixes> 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<ItemStack> fixedInputs = new ArrayList<>();
+                    ArrayList<FluidStack> 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<ItemStack> fixedInputs = new ArrayList<>();
+                    ArrayList<FluidStack> 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