Move GoodGen sources

9 files changed, 1653 insertions, 0 deletions

diff --git a/src/main/java/goodgenerator/util/CharExchanger.java b/src/main/java/goodgenerator/util/CharExchanger.java
new file mode 100644
index 0000000000..96019eecd1
--- /dev/null
+++ b/src/main/java/goodgenerator/util/CharExchanger.java
@@ -0,0 +1,52 @@
+package goodgenerator.util;
+
+import net.minecraft.util.EnumChatFormatting;
+
+public class CharExchanger {
+
+    public static final String[] tierName = new String[] { EnumChatFormatting.RED + "ULV" + EnumChatFormatting.RESET,
+        EnumChatFormatting.GRAY + "LV" + EnumChatFormatting.RESET,
+        EnumChatFormatting.AQUA + "MV" + EnumChatFormatting.RESET,
+        EnumChatFormatting.GOLD + "HV" + EnumChatFormatting.RESET,
+        EnumChatFormatting.DARK_PURPLE + "EV" + EnumChatFormatting.RESET,
+        EnumChatFormatting.DARK_BLUE + "IV" + EnumChatFormatting.RESET,
+        EnumChatFormatting.LIGHT_PURPLE + "LuV" + EnumChatFormatting.RESET,
+        EnumChatFormatting.WHITE + "ZPM" + EnumChatFormatting.RESET,
+        EnumChatFormatting.DARK_AQUA + "UV" + EnumChatFormatting.RESET,
+        EnumChatFormatting.DARK_RED + "UHV" + EnumChatFormatting.RESET,
+        EnumChatFormatting.GREEN + "UEV" + EnumChatFormatting.RESET, };
+
+    public static char shifter(int unicode) {
+        return (char) unicode;
+    }
+
+    public static String formatNumber(String exp) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < exp.length(); ++i) {
+            if (Character.isDigit(exp.charAt(i))) {
+                int cnt = 0, prt = i;
+                while (i < exp.length() && Character.isDigit(exp.charAt(i))) {
+                    i++;
+                    cnt++;
+                }
+                while (prt < exp.length() && Character.isDigit(exp.charAt(prt))) {
+                    sb.append(exp.charAt(prt));
+                    prt++;
+                    cnt--;
+                    if (cnt % 3 == 0 && cnt != 0) sb.append(",");
+                }
+            }
+            if (i < exp.length()) sb.append(exp.charAt(i));
+        }
+        return sb.toString();
+    }
+
+    public static String[] genString(String content, int len) {
+        String[] ret = new String[len];
+        while (len > 0) {
+            len--;
+            ret[len] = content;
+        }
+        return ret;
+    }
+}
diff --git a/src/main/java/goodgenerator/util/CrackRecipeAdder.java b/src/main/java/goodgenerator/util/CrackRecipeAdder.java
new file mode 100644
index 0000000000..dddb7fe69d
--- /dev/null
+++ b/src/main/java/goodgenerator/util/CrackRecipeAdder.java
@@ -0,0 +1,624 @@
+package goodgenerator.util;
+
+import static gregtech.api.recipe.RecipeMaps.blastFurnaceRecipes;
+import static gregtech.api.recipe.RecipeMaps.crackingRecipes;
+import static gregtech.api.recipe.RecipeMaps.distillationTowerRecipes;
+import static gregtech.api.recipe.RecipeMaps.distilleryRecipes;
+import static gregtech.api.recipe.RecipeMaps.extruderRecipes;
+import static gregtech.api.recipe.RecipeMaps.fluidSolidifierRecipes;
+import static gregtech.api.recipe.RecipeMaps.wiremillRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+import static gregtech.api.util.GT_RecipeBuilder.TICKS;
+import static gregtech.api.util.GT_RecipeConstants.COIL_HEAT;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+import com.github.bartimaeusnek.bartworks.system.material.Werkstoff;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.TierEU;
+import gregtech.api.metatileentity.implementations.GT_MetaPipeEntity_Cable;
+import gregtech.api.metatileentity.implementations.GT_MetaPipeEntity_Fluid;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_RecipeBuilder;
+import gregtech.api.util.GT_Utility;
+
+public class CrackRecipeAdder {
+
+    static float[] coe1 = { 1.25f, 1.2f, 1.1f, 0.9f, 0.85f, 0.8f, 0.75f };
+    static float[] coe2 = { 1.4f, 1.25f, 1.2f, 0.8f, 0.75f, 0.7f, 0.65f };
+    static float[] coe3 = { 1.6f, 1.5f, 1.45f, 0.7f, 0.6f, 0.55f, 0.45f };
+
+    public static void crackerAdder(FluidStack inputFluid, FluidStack cracker, FluidStack[] outputFluids,
+        ItemStack outputItem, int num, int EUt, int Duration) {
+
+        String name;
+        FluidStack[] actOutput = new FluidStack[num];
+        name = inputFluid.getFluid()
+            .getName()
+            .replaceAll(" ", "");
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(1))
+            .fluidInputs(inputFluid, cracker)
+            .fluidOutputs(FluidRegistry.getFluidStack("lightlycracked" + name, 1000))
+            .duration(Math.max((long) (Duration * 0.8), 1L) * TICKS)
+            .eut(EUt)
+            .addTo(crackingRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(2))
+            .fluidInputs(inputFluid, cracker)
+            .fluidOutputs(FluidRegistry.getFluidStack("moderatelycracked" + name, 1000))
+            .duration(Math.max((long) (Duration), 1L) * TICKS)
+            .eut(EUt)
+            .addTo(crackingRecipes);
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.getIntegratedCircuit(3))
+            .fluidInputs(inputFluid, cracker)
+            .fluidOutputs(FluidRegistry.getFluidStack("heavilycracked" + name, 1000))
+            .duration(Math.max((long) (Duration * 1.2), 1L) * TICKS)
+            .eut(EUt)
+            .addTo(crackingRecipes);
+
+        for (int i = num - 1, j = 0; i >= 0; i--, j++) {
+            Fluid tmp1 = outputFluids[i].getFluid();
+            int tmp2 = (int) (outputFluids[i].amount * coe1[i]);
+            actOutput[j] = new FluidStack(tmp1, tmp2);
+        }
+
+        addUniversalDistillationRecipe(
+            FluidRegistry.getFluidStack("lightlycracked" + name, 1000),
+            actOutput,
+            outputItem,
+            Duration / 2,
+            EUt / 3);
+
+        for (int i = num - 1, j = 0; i >= 0; i--, j++) {
+            Fluid tmp1 = outputFluids[i].getFluid();
+            int tmp2 = (int) (outputFluids[i].amount * coe2[i]);
+            actOutput[j] = new FluidStack(tmp1, tmp2);
+        }
+
+        addUniversalDistillationRecipe(
+            FluidRegistry.getFluidStack("moderatelycracked" + name, 1000),
+            actOutput,
+            outputItem,
+            Duration / 2,
+            EUt / 3);
+
+        for (int i = num - 1, j = 0; i >= 0; i--, j++) {
+            Fluid tmp1 = outputFluids[i].getFluid();
+            int tmp2 = (int) (outputFluids[i].amount * coe3[i]);
+            actOutput[j] = new FluidStack(tmp1, tmp2);
+        }
+
+        addUniversalDistillationRecipe(
+            FluidRegistry.getFluidStack("heavilycracked" + name, 1000),
+            actOutput,
+            outputItem,
+            Duration / 2,
+            EUt / 3);
+    }
+
+    public static void reAddBlastRecipe(Werkstoff material, int duration, int EUt, int level, boolean gas) {
+        ItemStack input = material.get(OrePrefixes.dust, 1);
+        ItemStack output = level > 1750 ? material.get(OrePrefixes.ingotHot, 1) : material.get(OrePrefixes.ingot, 1);
+        if (gas) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(input, GT_Utility.getIntegratedCircuit(11))
+                .fluidInputs(Materials.Helium.getGas(1000))
+                .itemOutputs(output)
+                .duration(duration * TICKS)
+                .eut(EUt)
+                .metadata(COIL_HEAT, level)
+                .addTo(blastFurnaceRecipes);
+        } else {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(input, GT_Utility.getIntegratedCircuit(1))
+                .itemOutputs(output)
+                .duration(duration * TICKS)
+                .eut(EUt)
+                .metadata(COIL_HEAT, level)
+                .addTo(blastFurnaceRecipes);
+        }
+    }
+
+    public static void addUniversalDistillationRecipewithCircuit(FluidStack aInput, ItemStack[] aCircuit,
+        FluidStack[] aOutputs, ItemStack aOutput2, int aDuration, long aEUt) {
+        for (int i = 0; i < Math.min(aOutputs.length, 11); i++) {
+            GT_RecipeBuilder buildDistillation = GT_Values.RA.stdBuilder()
+                .itemInputs(GT_Utility.getIntegratedCircuit(i + 1));
+            if (aOutput2 != GT_Values.NI) {
+                buildDistillation.itemOutputs(aOutput2);
+            }
+            buildDistillation.fluidInputs(aInput)
+                .fluidOutputs(aOutputs[i])
+                .duration(2 * aDuration)
+                .eut(aEUt / 4)
+                .addTo(distilleryRecipes);
+        }
+        GT_RecipeBuilder buildDT = GT_Values.RA.stdBuilder()
+            .itemInputs(aCircuit);
+        if (aOutput2 != GT_Values.NI) {
+            buildDT.itemOutputs(aOutput2);
+        }
+        buildDT.fluidInputs(aInput)
+            .fluidOutputs(aOutputs)
+            .duration(aDuration)
+            .eut(aEUt)
+            .addTo(distillationTowerRecipes);
+    }
+
+    public static void addUniversalDistillationRecipe(FluidStack aInput, FluidStack[] aOutputs, ItemStack aOutput2,
+        int aDuration, long aEUt) {
+        for (int i = 0; i < Math.min(aOutputs.length, 11); i++) {
+            GT_RecipeBuilder buildDistillation = GT_Values.RA.stdBuilder()
+                .itemInputs(GT_Utility.getIntegratedCircuit(i + 1));
+            if (aOutput2 != GT_Values.NI) {
+                buildDistillation.itemOutputs(aOutput2);
+            }
+            buildDistillation.fluidInputs(aInput)
+                .fluidOutputs(aOutputs[i])
+                .duration(2 * aDuration)
+                .eut(aEUt / 4)
+                .addTo(distilleryRecipes);
+        }
+        GT_RecipeBuilder buildDT = GT_Values.RA.stdBuilder();
+        if (aOutput2 != GT_Values.NI) {
+            buildDT.itemOutputs(aOutput2);
+        }
+        buildDT.fluidInputs(aInput)
+            .fluidOutputs(aOutputs)
+            .duration(aDuration)
+            .eut(aEUt)
+            .addTo(distillationTowerRecipes);
+    }
+
+    public static FluidStack copyFluidWithAmount(FluidStack fluid, int amount) {
+        if (fluid == null || amount <= 0) return null;
+        return new FluidStack(fluid.getFluid(), amount);
+    }
+
+    public static void registerPipe(int ID, Werkstoff material, int flow, int temp, boolean gas) {
+        String unName = material.getDefaultName()
+            .replace(" ", "_");
+        String Name = material.getDefaultName();
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.pipeTiny.get(material.getBridgeMaterial()),
+            new GT_MetaPipeEntity_Fluid(
+                ID,
+                "GT_Pipe_" + unName + "_Tiny",
+                "Tiny " + Name + " Fluid Pipe",
+                0.25F,
+                material.getBridgeMaterial(),
+                flow / 6,
+                temp,
+                gas).getStackForm(1L));
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.pipeSmall.get(material.getBridgeMaterial()),
+            new GT_MetaPipeEntity_Fluid(
+                ID + 1,
+                "GT_Pipe_" + unName + "_Small",
+                "Small " + Name + " Fluid Pipe",
+                0.375F,
+                material.getBridgeMaterial(),
+                flow / 3,
+                temp,
+                gas).getStackForm(1L));
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.pipeMedium.get(material.getBridgeMaterial()),
+            new GT_MetaPipeEntity_Fluid(
+                ID + 2,
+                "GT_Pipe_" + unName,
+                Name + " Fluid Pipe",
+                0.5F,
+                material.getBridgeMaterial(),
+                flow,
+                temp,
+                gas).getStackForm(1L));
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.pipeLarge.get(material.getBridgeMaterial()),
+            new GT_MetaPipeEntity_Fluid(
+                ID + 3,
+                "GT_Pipe_" + unName + "_Large",
+                "Large " + Name + " Fluid Pipe",
+                0.75F,
+                material.getBridgeMaterial(),
+                flow * 2,
+                temp,
+                gas).getStackForm(1L));
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.pipeHuge.get(material.getBridgeMaterial()),
+            new GT_MetaPipeEntity_Fluid(
+                ID + 4,
+                "GT_Pipe_" + unName + "_Huge",
+                "Huge " + Name + " Fluid Pipe",
+                0.875F,
+                material.getBridgeMaterial(),
+                flow * 4,
+                temp,
+                gas).getStackForm(1L));
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 1), ItemList.Shape_Extruder_Pipe_Tiny.get(0))
+            .itemOutputs(material.get(OrePrefixes.pipeTiny, 2))
+            .duration(
+                material.getStats()
+                    .getMass() * TICKS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(extruderRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 1), ItemList.Shape_Extruder_Pipe_Small.get(0))
+            .itemOutputs(material.get(OrePrefixes.pipeSmall, 1))
+            .duration(
+                material.getStats()
+                    .getMass() * 2
+                    * TICKS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(extruderRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 3), ItemList.Shape_Extruder_Pipe_Medium.get(0))
+            .itemOutputs(material.get(OrePrefixes.pipeMedium, 1))
+            .duration(
+                material.getStats()
+                    .getMass() * 6
+                    * TICKS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(extruderRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 6), ItemList.Shape_Extruder_Pipe_Large.get(0))
+            .itemOutputs(material.get(OrePrefixes.pipeLarge, 1))
+            .duration(
+                material.getStats()
+                    .getMass() * 12
+                    * TICKS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(extruderRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 12), ItemList.Shape_Extruder_Pipe_Huge.get(0))
+            .itemOutputs(material.get(OrePrefixes.pipeHuge, 1))
+            .duration(
+                material.getStats()
+                    .getMass() * 24
+                    * TICKS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(extruderRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemList.Shape_Mold_Pipe_Tiny.get(0))
+            .fluidInputs(material.getMolten(72))
+            .itemOutputs(material.get(OrePrefixes.pipeTiny, 1))
+            .duration(
+                material.getStats()
+                    .getMass() * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(fluidSolidifierRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemList.Shape_Mold_Pipe_Small.get(0))
+            .fluidInputs(material.getMolten(144))
+            .itemOutputs(material.get(OrePrefixes.pipeSmall, 1))
+            .duration(
+                material.getStats()
+                    .getMass() * 2
+                    * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(fluidSolidifierRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemList.Shape_Mold_Pipe_Medium.get(0))
+            .fluidInputs(material.getMolten(432))
+            .itemOutputs(material.get(OrePrefixes.pipeMedium, 1))
+            .duration(
+                material.getStats()
+                    .getMass() * 6
+                    * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(fluidSolidifierRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemList.Shape_Mold_Pipe_Large.get(0))
+            .fluidInputs(material.getMolten(864))
+            .itemOutputs(material.get(OrePrefixes.pipeLarge, 1))
+            .duration(
+                material.getStats()
+                    .getMass() * 12
+                    * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(fluidSolidifierRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(ItemList.Shape_Mold_Pipe_Huge.get(0))
+            .fluidInputs(material.getMolten(1728))
+            .itemOutputs(material.get(OrePrefixes.pipeHuge, 1))
+            .duration(
+                material.getStats()
+                    .getMass() * 24
+                    * TICKS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(fluidSolidifierRecipes);
+    }
+
+    public static void registerWire(int ID, Werkstoff material, int aAmperage, int aVoltage, int aLoss, boolean cover) {
+        String unName = material.getDefaultName()
+            .replace(" ", "_")
+            .toLowerCase();
+        String Name = material.getDefaultName();
+        String aTextWire1 = "wire.";
+        String aTextCable1 = "cable.";
+        String aTextWire2 = " Wire";
+        String aTextCable2 = " Cable";
+        int aLossInsulated = aLoss / 4;
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.wireGt01,
+            material.getBridgeMaterial(),
+            new GT_MetaPipeEntity_Cable(
+                ID + 0,
+                aTextWire1 + unName + ".01",
+                "1x " + Name + aTextWire2,
+                0.125F,
+                material.getBridgeMaterial(),
+                aLoss,
+                1L * aAmperage,
+                aVoltage,
+                false,
+                true).getStackForm(1L));
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.wireGt02,
+            material.getBridgeMaterial(),
+            new GT_MetaPipeEntity_Cable(
+                ID + 1,
+                aTextWire1 + unName + ".02",
+                "2x " + Name + aTextWire2,
+                0.25F,
+                material.getBridgeMaterial(),
+                aLoss,
+                2L * aAmperage,
+                aVoltage,
+                false,
+                true).getStackForm(1L));
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.wireGt04,
+            material.getBridgeMaterial(),
+            new GT_MetaPipeEntity_Cable(
+                ID + 2,
+                aTextWire1 + unName + ".04",
+                "4x " + Name + aTextWire2,
+                0.375F,
+                material.getBridgeMaterial(),
+                aLoss,
+                4L * aAmperage,
+                aVoltage,
+                false,
+                true).getStackForm(1L));
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.wireGt08,
+            material.getBridgeMaterial(),
+            new GT_MetaPipeEntity_Cable(
+                ID + 3,
+                aTextWire1 + unName + ".08",
+                "8x " + Name + aTextWire2,
+                0.5F,
+                material.getBridgeMaterial(),
+                aLoss,
+                8L * aAmperage,
+                aVoltage,
+                false,
+                true).getStackForm(1L));
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.wireGt12,
+            material.getBridgeMaterial(),
+            new GT_MetaPipeEntity_Cable(
+                ID + 4,
+                aTextWire1 + unName + ".12",
+                "12x " + Name + aTextWire2,
+                0.625F,
+                material.getBridgeMaterial(),
+                aLoss,
+                12L * aAmperage,
+                aVoltage,
+                false,
+                true).getStackForm(1L));
+        GT_OreDictUnificator.registerOre(
+            OrePrefixes.wireGt16,
+            material.getBridgeMaterial(),
+            new GT_MetaPipeEntity_Cable(
+                ID + 5,
+                aTextWire1 + unName + ".16",
+                "16x " + Name + aTextWire2,
+                0.75F,
+                material.getBridgeMaterial(),
+                aLoss,
+                16L * aAmperage,
+                aVoltage,
+                false,
+                true).getStackForm(1L));
+        if (cover) {
+            GT_OreDictUnificator.registerOre(
+                OrePrefixes.cableGt01,
+                material.getBridgeMaterial(),
+                new GT_MetaPipeEntity_Cable(
+                    ID + 6,
+                    aTextCable1 + unName + ".01",
+                    "1x " + Name + aTextCable2,
+                    0.25F,
+                    material.getBridgeMaterial(),
+                    aLossInsulated,
+                    1L * aAmperage,
+                    aVoltage,
+                    true,
+                    false).getStackForm(1L));
+            GT_OreDictUnificator.registerOre(
+                OrePrefixes.cableGt02,
+                material.getBridgeMaterial(),
+                new GT_MetaPipeEntity_Cable(
+                    ID + 7,
+                    aTextCable1 + unName + ".02",
+                    "2x " + Name + aTextCable2,
+                    0.375F,
+                    material.getBridgeMaterial(),
+                    aLossInsulated,
+                    2L * aAmperage,
+                    aVoltage,
+                    true,
+                    false).getStackForm(1L));
+            GT_OreDictUnificator.registerOre(
+                OrePrefixes.cableGt04,
+                material.getBridgeMaterial(),
+                new GT_MetaPipeEntity_Cable(
+                    ID + 8,
+                    aTextCable1 + unName + ".04",
+                    "4x " + Name + aTextCable2,
+                    0.5F,
+                    material.getBridgeMaterial(),
+                    aLossInsulated,
+                    4L * aAmperage,
+                    aVoltage,
+                    true,
+                    false).getStackForm(1L));
+            GT_OreDictUnificator.registerOre(
+                OrePrefixes.cableGt08,
+                material.getBridgeMaterial(),
+                new GT_MetaPipeEntity_Cable(
+                    ID + 9,
+                    aTextCable1 + unName + ".08",
+                    "8x " + Name + aTextCable2,
+                    0.625F,
+                    material.getBridgeMaterial(),
+                    aLossInsulated,
+                    8L * aAmperage,
+                    aVoltage,
+                    true,
+                    false).getStackForm(1L));
+            GT_OreDictUnificator.registerOre(
+                OrePrefixes.cableGt12,
+                material.getBridgeMaterial(),
+                new GT_MetaPipeEntity_Cable(
+                    ID + 10,
+                    aTextCable1 + unName + ".12",
+                    "12x " + Name + aTextCable2,
+                    0.75F,
+                    material.getBridgeMaterial(),
+                    aLossInsulated,
+                    12L * aAmperage,
+                    aVoltage,
+                    true,
+                    false).getStackForm(1L));
+            GT_OreDictUnificator.registerOre(
+                OrePrefixes.cableGt16,
+                material.getBridgeMaterial(),
+                new GT_MetaPipeEntity_Cable(
+                    ID + 11,
+                    aTextCable1 + unName + ".16",
+                    "16x " + Name + aTextCable2,
+                    0.875F,
+                    material.getBridgeMaterial(),
+                    aLossInsulated,
+                    16L * aAmperage,
+                    aVoltage,
+                    true,
+                    false).getStackForm(1L));
+        }
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 1), GT_Utility.getIntegratedCircuit(1))
+            .itemOutputs(material.get(OrePrefixes.wireGt01, 2))
+            .duration(5 * SECONDS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 1), GT_Utility.getIntegratedCircuit(2))
+            .itemOutputs(material.get(OrePrefixes.wireGt02, 1))
+            .duration(7 * SECONDS + 10 * TICKS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 2), GT_Utility.getIntegratedCircuit(4))
+            .itemOutputs(material.get(OrePrefixes.wireGt04, 1))
+            .duration(10 * SECONDS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 4), GT_Utility.getIntegratedCircuit(8))
+            .itemOutputs(material.get(OrePrefixes.wireGt08, 1))
+            .duration(12 * SECONDS + 10 * TICKS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 6), GT_Utility.getIntegratedCircuit(12))
+            .itemOutputs(material.get(OrePrefixes.wireGt12, 1))
+            .duration(15 * SECONDS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 8), GT_Utility.getIntegratedCircuit(16))
+            .itemOutputs(material.get(OrePrefixes.wireGt16, 1))
+            .duration(17 * SECONDS + 10 * TICKS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.stick, 1), GT_Utility.getIntegratedCircuit(1))
+            .itemOutputs(material.get(OrePrefixes.wireGt01, 1))
+            .duration(2 * SECONDS + 10 * TICKS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.stick, 2), GT_Utility.getIntegratedCircuit(2))
+            .itemOutputs(material.get(OrePrefixes.wireGt02, 1))
+            .duration(5 * SECONDS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.stick, 4), GT_Utility.getIntegratedCircuit(4))
+            .itemOutputs(material.get(OrePrefixes.wireGt04, 1))
+            .duration(7 * SECONDS + 10 * TICKS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.stick, 8), GT_Utility.getIntegratedCircuit(8))
+            .itemOutputs(material.get(OrePrefixes.wireGt08, 1))
+            .duration(10 * SECONDS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.stick, 12), GT_Utility.getIntegratedCircuit(12))
+            .itemOutputs(material.get(OrePrefixes.wireGt12, 1))
+            .duration(12 * SECONDS + 10 * TICKS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.stick, 16), GT_Utility.getIntegratedCircuit(16))
+            .itemOutputs(material.get(OrePrefixes.wireGt16, 1))
+            .duration(15 * SECONDS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 1), GT_Utility.getIntegratedCircuit(3))
+            .itemOutputs(material.get(OrePrefixes.wireFine, 8))
+            .duration(5 * SECONDS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.stick, 1), GT_Utility.getIntegratedCircuit(3))
+            .itemOutputs(material.get(OrePrefixes.wireFine, 4))
+            .duration(2 * SECONDS + 10 * TICKS)
+            .eut(4)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.wireGt01, 1), GT_Utility.getIntegratedCircuit(1))
+            .itemOutputs(material.get(OrePrefixes.wireFine, 4))
+            .duration(10 * SECONDS)
+            .eut(8)
+            .addTo(wiremillRecipes);
+        GT_Values.RA.stdBuilder()
+            .itemInputs(material.get(OrePrefixes.ingot, 1), ItemList.Shape_Extruder_Wire.get(0))
+            .itemOutputs(material.get(OrePrefixes.wireGt01, 2))
+            .duration(
+                material.getStats()
+                    .getMass() * 8
+                    * TICKS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(extruderRecipes);
+    }
+}
diff --git a/src/main/java/goodgenerator/util/DescTextLocalization.java b/src/main/java/goodgenerator/util/DescTextLocalization.java
new file mode 100644
index 0000000000..3470737d6b
--- /dev/null
+++ b/src/main/java/goodgenerator/util/DescTextLocalization.java
@@ -0,0 +1,22 @@
+package goodgenerator.util;
+
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.StatCollector;
+
+public class DescTextLocalization {
+
+    public static final String BLUE_PRINT_INFO = "Follow the" + EnumChatFormatting.BLUE
+        + " Structure"
+        + EnumChatFormatting.DARK_BLUE
+        + "Lib"
+        + EnumChatFormatting.GRAY
+        + " hologram projector to build the main structure.";
+
+    public static String[] addText(String preFix, int length) {
+        String[] text = new String[length];
+        for (int i = 0; i < length; i++) {
+            text[i] = StatCollector.translateToLocal(preFix + "." + i);
+        }
+        return text;
+    }
+}
diff --git a/src/main/java/goodgenerator/util/ItemRefer.java b/src/main/java/goodgenerator/util/ItemRefer.java
new file mode 100644
index 0000000000..400199ef03
--- /dev/null
+++ b/src/main/java/goodgenerator/util/ItemRefer.java
@@ -0,0 +1,221 @@
+package goodgenerator.util;
+
+import static goodgenerator.loader.FuelRodLoader.*;
+import static goodgenerator.loader.Loaders.*;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+
+import gregtech.api.util.GT_Utility;
+import ic2.core.Ic2Items;
+
+public final class ItemRefer {
+
+    public static ItemRefer NULL = getItemStack(_null_);
+
+    public static ItemRefer Radiation_Protection_Plate = getItemStack(radiationProtectionPlate);
+    public static ItemRefer Wrapped_Uranium_Ingot = getItemStack(wrappedUraniumIngot);
+    public static ItemRefer High_Density_Uranium_Nugget = getItemStack(highDensityUraniumNugget);
+    public static ItemRefer High_Density_Uranium = getItemStack(highDensityUranium);
+    public static ItemRefer Wrapped_Thorium_Ingot = getItemStack(wrappedThoriumIngot);
+    public static ItemRefer High_Density_Thorium_Nugget = getItemStack(highDensityThoriumNugget);
+    public static ItemRefer High_Density_Thorium = getItemStack(highDensityThorium);
+    public static ItemRefer Wrapped_Plutonium_Ingot = getItemStack(wrappedPlutoniumIngot);
+    public static ItemRefer High_Density_Plutonium_Nugget = getItemStack(highDensityPlutoniumNugget);
+    public static ItemRefer High_Density_Plutonium = getItemStack(highDensityPlutonium);
+    public static ItemRefer Raw_Atomic_Separation_Catalyst = getItemStack(rawAtomicSeparationCatalyst);
+    public static ItemRefer Advanced_Radiation_Protection_Plate = getItemStack(advancedRadiationProtectionPlate);
+    public static ItemRefer Aluminum_Nitride_Dust = getItemStack(aluminumNitride);
+    public static ItemRefer Special_Ceramics_Dust = getItemStack(specialCeramics);
+    public static ItemRefer Special_Ceramics_Plate = getItemStack(specialCeramicsPlate);
+    public static ItemRefer Radioactive_Waste = getItemStack(radioactiveWaste);
+    public static ItemRefer Plastic_Case = getItemStack(plasticCase);
+    public static ItemRefer Quartz_Wafer = getItemStack(quartzWafer);
+    public static ItemRefer Micro_Heater = getItemStack(microHeater);
+    public static ItemRefer Quartz_Crystal_Resonator = getItemStack(quartzCrystalResonator);
+    public static ItemRefer Inverter = getItemStack(inverter);
+    public static ItemRefer Neutron_Source = getItemStack(neutronSource);
+    public static ItemRefer Naquadah_Mass = getItemStack(naquadahMass);
+    public static ItemRefer Enriched_Naquadah_Mass = getItemStack(enrichedNaquadahMass);
+    public static ItemRefer Naquadria_Mass = getItemStack(naquadriaMass);
+    public static ItemRefer Advanced_Fuel_Rod = getItemStack(advancedFuelRod);
+    public static ItemRefer Fuel_Rod_U_Depleted_1 = getItemStack(rodCompressedUraniumDepleted);
+    public static ItemRefer Fuel_Rod_U_Depleted_2 = getItemStack(rodCompressedUraniumDepleted_2);
+    public static ItemRefer Fuel_Rod_U_Depleted_4 = getItemStack(rodCompressedUraniumDepleted_4);
+    public static ItemRefer Fuel_Rod_U_1 = getItemStack(rodCompressedUranium);
+    public static ItemRefer Fuel_Rod_U_2 = getItemStack(rodCompressedUranium_2);
+    public static ItemRefer Fuel_Rod_U_4 = getItemStack(rodCompressedUranium_4);
+    public static ItemRefer Fuel_Rod_Pu_Depleted_1 = getItemStack(rodCompressedPlutoniumDepleted);
+    public static ItemRefer Fuel_Rod_Pu_Depleted_2 = getItemStack(rodCompressedPlutoniumDepleted_2);
+    public static ItemRefer Fuel_Rod_Pu_Depleted_4 = getItemStack(rodCompressedPlutoniumDepleted_4);
+    public static ItemRefer Fuel_Rod_Pu_1 = getItemStack(rodCompressedPlutonium);
+    public static ItemRefer Fuel_Rod_Pu_2 = getItemStack(rodCompressedPlutonium_2);
+    public static ItemRefer Fuel_Rod_Pu_4 = getItemStack(rodCompressedPlutonium_4);
+    public static ItemRefer Fuel_Rod_LU_Depleted_1 = getItemStack(rodLiquidUraniumDepleted);
+    public static ItemRefer Fuel_Rod_LU_Depleted_2 = getItemStack(rodLiquidUraniumDepleted_2);
+    public static ItemRefer Fuel_Rod_LU_Depleted_4 = getItemStack(rodLiquidUraniumDepleted_4);
+    public static ItemRefer Fuel_Rod_LU_1 = getItemStack(rodLiquidUranium);
+    public static ItemRefer Fuel_Rod_LU_2 = getItemStack(rodLiquidUranium_2);
+    public static ItemRefer Fuel_Rod_LU_4 = getItemStack(rodLiquidUranium_4);
+    public static ItemRefer Fuel_Rod_LPu_Depleted_1 = getItemStack(rodLiquidPlutoniumDepleted);
+    public static ItemRefer Fuel_Rod_LPu_Depleted_2 = getItemStack(rodLiquidPlutoniumDepleted_2);
+    public static ItemRefer Fuel_Rod_LPu_Depleted_4 = getItemStack(rodLiquidPlutoniumDepleted_4);
+    public static ItemRefer Fuel_Rod_LPu_1 = getItemStack(rodLiquidPlutonium);
+    public static ItemRefer Fuel_Rod_LPu_2 = getItemStack(rodLiquidPlutonium_2);
+    public static ItemRefer Fuel_Rod_LPu_4 = getItemStack(rodLiquidPlutonium_4);
+    public static ItemRefer Fluid_Storage_Core_T1 = getItemStack(fluidCore, 0);
+    public static ItemRefer Fluid_Storage_Core_T2 = getItemStack(fluidCore, 1);
+    public static ItemRefer Fluid_Storage_Core_T3 = getItemStack(fluidCore, 2);
+    public static ItemRefer Fluid_Storage_Core_T4 = getItemStack(fluidCore, 3);
+    public static ItemRefer Fluid_Storage_Core_T5 = getItemStack(fluidCore, 4);
+    public static ItemRefer Fluid_Storage_Core_T6 = getItemStack(fluidCore, 5);
+    public static ItemRefer Fluid_Storage_Core_T7 = getItemStack(fluidCore, 6);
+    public static ItemRefer Fluid_Storage_Core_T8 = getItemStack(fluidCore, 7);
+    public static ItemRefer Fluid_Storage_Core_T9 = getItemStack(fluidCore, 8);
+    public static ItemRefer Fluid_Storage_Core_T10 = getItemStack(fluidCore, 9);
+    public static ItemRefer Essentia_Upgrade_Empty = getItemStack(upgradeEssentia, 0);
+    public static ItemRefer Essentia_Upgrade_Air = getItemStack(upgradeEssentia, 1);
+    public static ItemRefer Essentia_Upgrade_Thermal = getItemStack(upgradeEssentia, 2);
+    public static ItemRefer Essentia_Upgrade_Unstable = getItemStack(upgradeEssentia, 3);
+    public static ItemRefer Essentia_Upgrade_Victus = getItemStack(upgradeEssentia, 4);
+    public static ItemRefer Essentia_Upgrade_Tainted = getItemStack(upgradeEssentia, 5);
+    public static ItemRefer Essentia_Upgrade_Mechanics = getItemStack(upgradeEssentia, 6);
+    public static ItemRefer Essentia_Upgrade_Spirit = getItemStack(upgradeEssentia, 7);
+    public static ItemRefer Essentia_Upgrade_Radiation = getItemStack(upgradeEssentia, 8);
+    public static ItemRefer Essentia_Upgrade_Electric = getItemStack(upgradeEssentia, 9);
+    public static ItemRefer High_Energy_Mixture = getItemStack(highEnergyMixture);
+    public static ItemRefer Salty_Root = getItemStack(saltyRoot);
+    public static ItemRefer HiC_T1 = getItemStack(huiCircuit, 0);
+    public static ItemRefer HiC_T2 = getItemStack(huiCircuit, 1);
+    public static ItemRefer HiC_T3 = getItemStack(huiCircuit, 2);
+    public static ItemRefer HiC_T4 = getItemStack(huiCircuit, 3);
+    public static ItemRefer HiC_T5 = getItemStack(huiCircuit, 4);
+    public static ItemRefer IC2_Ir_Plate = getItemStack(Ic2Items.iridiumPlate);
+    public static ItemRefer IC2_Glass = getItemStack(Ic2Items.reinforcedGlass);
+
+    public static ItemRefer Field_Restriction_Casing = getItemStack(MAR_Casing);
+    public static ItemRefer Naquadah_Fuel_Refinery_Casing = getItemStack(FRF_Casings);
+    public static ItemRefer Field_Restriction_Coil_T1 = getItemStack(FRF_Coil_1);
+    public static ItemRefer Field_Restriction_Coil_T2 = getItemStack(FRF_Coil_2);
+    public static ItemRefer Field_Restriction_Coil_T3 = getItemStack(FRF_Coil_3);
+    public static ItemRefer Field_Restriction_Coil_T4 = getItemStack(FRF_Coil_4);
+    public static ItemRefer Radiation_Proof_Steel_Frame_Box = getItemStack(radiationProtectionSteelFrame);
+    public static ItemRefer Field_Restriction_Glass = getItemStack(fieldRestrictingGlass);
+    public static ItemRefer Raw_Cylinder = getItemStack(rawCylinder);
+    public static ItemRefer Titanium_Plated_Cylinder = getItemStack(titaniumPlatedCylinder);
+    public static ItemRefer Magic_Casing = getItemStack(magicCasing);
+    public static ItemRefer Speeding_Pipe = getItemStack(speedingPipe);
+    public static ItemRefer Essentia_Cell_T1 = getItemStack(essentiaCell, 0);
+    public static ItemRefer Essentia_Cell_T2 = getItemStack(essentiaCell, 1);
+    public static ItemRefer Essentia_Cell_T3 = getItemStack(essentiaCell, 2);
+    public static ItemRefer Essentia_Cell_T4 = getItemStack(essentiaCell, 3);
+    public static ItemRefer Essentia_Hatch = getItemStack(essentiaHatch);
+    public static ItemRefer YOTTank_Casing = getItemStack(yottaFluidTankCasing);
+    public static ItemRefer YOTTank_Cell_T1 = getItemStack(yottaFluidTankCell, 0);
+    public static ItemRefer YOTTank_Cell_T2 = getItemStack(yottaFluidTankCell, 1);
+    public static ItemRefer YOTTank_Cell_T3 = getItemStack(yottaFluidTankCell, 2);
+    public static ItemRefer YOTTank_Cell_T4 = getItemStack(yottaFluidTankCell, 3);
+    public static ItemRefer YOTTank_Cell_T5 = getItemStack(yottaFluidTankCell, 4);
+    public static ItemRefer YOTTank_Cell_T6 = getItemStack(yottaFluidTankCell, 5);
+    public static ItemRefer YOTTank_Cell_T7 = getItemStack(yottaFluidTankCell, 6);
+    public static ItemRefer YOTTank_Cell_T8 = getItemStack(yottaFluidTankCell, 7);
+    public static ItemRefer YOTTank_Cell_T9 = getItemStack(yottaFluidTankCell, 8);
+    public static ItemRefer YOTTank_Cell_T10 = getItemStack(yottaFluidTankCell, 9);
+    public static ItemRefer SC_Turbine_Casing = getItemStack(supercriticalFluidTurbineCasing);
+    public static ItemRefer Pressure_Resistant_Wall = getItemStack(pressureResistantWalls);
+    public static ItemRefer Precise_Electronic_Unit_T1 = getItemStack(preciseUnitCasing, 0);
+    public static ItemRefer Precise_Electronic_Unit_T2 = getItemStack(preciseUnitCasing, 1);
+    public static ItemRefer Precise_Electronic_Unit_T3 = getItemStack(preciseUnitCasing, 2);
+    public static ItemRefer Compact_Fusion_Coil_T0 = getItemStack(compactFusionCoil, 0);
+    public static ItemRefer Compact_Fusion_Coil_T1 = getItemStack(compactFusionCoil, 1);
+    public static ItemRefer Compact_Fusion_Coil_T2 = getItemStack(compactFusionCoil, 2);
+    public static ItemRefer Compact_Fusion_Coil_T3 = getItemStack(compactFusionCoil, 3);
+    public static ItemRefer Compact_Fusion_Coil_T4 = getItemStack(compactFusionCoil, 4);
+    public static ItemRefer Essentia_Filter_Casing = getItemStack(essentiaFilterCasing);
+    public static ItemRefer Essentia_Output_Hatch = getItemStack(essentiaOutputHatch);
+    public static ItemRefer Essentia_Output_Hatch_ME = getItemStack(essentiaOutputHatch_ME);
+
+    public static ItemRefer Large_Naquadah_Reactor = getItemStack(MAR);
+    public static ItemRefer Naquadah_Fuel_Refinery = getItemStack(FRF);
+    public static ItemRefer Universal_Chemical_Fuel_Engine = getItemStack(UCFE);
+    public static ItemRefer Large_Essentia_Generator = getItemStack(LEG);
+    public static ItemRefer YOTTank = getItemStack(YFT);
+    public static ItemRefer Combustion_Generator_EV = getItemStack(Generator_Diesel[0]);
+    public static ItemRefer Combustion_Generator_IV = getItemStack(Generator_Diesel[1]);
+    public static ItemRefer SC_Fluid_Turbine = getItemStack(SCTurbine);
+    public static ItemRefer Extreme_Heat_Exchanger = getItemStack(XHE);
+    public static ItemRefer Precise_Assembler = getItemStack(PA);
+    public static ItemRefer Compact_Fusion_MK1 = getItemStack(LFC[0]);
+    public static ItemRefer Compact_Fusion_MK2 = getItemStack(LFC[1]);
+    public static ItemRefer Compact_Fusion_MK3 = getItemStack(LFC[2]);
+    public static ItemRefer Compact_Fusion_MK4 = getItemStack(LFC[3]);
+    public static ItemRefer Compact_Fusion_MK5 = getItemStack(LFC[4]);
+    public static ItemRefer Large_Essentia_Smeltery = getItemStack(LES);
+    public static ItemRefer Coolant_Tower = getItemStack(CT);
+    public static ItemRefer Component_Assembly_Line = getItemStack(CompAssline);
+
+    public static ItemRefer Compassline_Casing_LV = getItemStack(componentAssemblylineCasing, 0);
+    public static ItemRefer Compassline_Casing_MV = getItemStack(componentAssemblylineCasing, 1);
+    public static ItemRefer Compassline_Casing_HV = getItemStack(componentAssemblylineCasing, 2);
+    public static ItemRefer Compassline_Casing_EV = getItemStack(componentAssemblylineCasing, 3);
+    public static ItemRefer Compassline_Casing_IV = getItemStack(componentAssemblylineCasing, 4);
+    public static ItemRefer Compassline_Casing_LuV = getItemStack(componentAssemblylineCasing, 5);
+    public static ItemRefer Compassline_Casing_ZPM = getItemStack(componentAssemblylineCasing, 6);
+    public static ItemRefer Compassline_Casing_UV = getItemStack(componentAssemblylineCasing, 7);
+    public static ItemRefer Compassline_Casing_UHV = getItemStack(componentAssemblylineCasing, 8);
+    public static ItemRefer Compassline_Casing_UEV = getItemStack(componentAssemblylineCasing, 9);
+    public static ItemRefer Compassline_Casing_UIV = getItemStack(componentAssemblylineCasing, 10);
+    public static ItemRefer Compassline_Casing_UMV = getItemStack(componentAssemblylineCasing, 11);
+    public static ItemRefer Compassline_Casing_UXV = getItemStack(componentAssemblylineCasing, 12);
+    public static ItemRefer Compassline_Casing_MAX = getItemStack(componentAssemblylineCasing, 13);
+
+    private Item mItem = null;
+    private Block mBlock = null;
+    private ItemStack mItemStack = null;
+    private int mMeta = 0;
+
+    private static ItemRefer getItemStack(ItemStack itemStack) {
+        if (itemStack == null) return NULL;
+        return new ItemRefer(itemStack);
+    }
+
+    private static ItemRefer getItemStack(Item item) {
+        return getItemStack(item, 0);
+    }
+
+    private static ItemRefer getItemStack(Item item, int meta) {
+        if (item == null) return NULL;
+        return new ItemRefer(item, meta);
+    }
+
+    private static ItemRefer getItemStack(Block block) {
+        return getItemStack(block, 0);
+    }
+
+    private static ItemRefer getItemStack(Block block, int meta) {
+        if (block == null) return NULL;
+        return new ItemRefer(block, meta);
+    }
+
+    private ItemRefer(Item item, int meta) {
+        mItem = item;
+        mMeta = meta;
+    }
+
+    private ItemRefer(Block block, int meta) {
+        mBlock = block;
+        mMeta = meta;
+    }
+
+    private ItemRefer(ItemStack itemStack) {
+        mItemStack = itemStack;
+    }
+
+    public ItemStack get(int amount) {
+        if (mItem != null) return new ItemStack(mItem, amount, mMeta);
+        if (mBlock != null) return new ItemStack(mBlock, amount, mMeta);
+        if (mItemStack != null) return GT_Utility.copyAmount(amount, mItemStack);
+        return new ItemStack(_null_, amount, 0);
+    }
+}
diff --git a/src/main/java/goodgenerator/util/Log.java b/src/main/java/goodgenerator/util/Log.java
new file mode 100644
index 0000000000..4cf9e40484
--- /dev/null
+++ b/src/main/java/goodgenerator/util/Log.java
@@ -0,0 +1,9 @@
+package goodgenerator.util;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class Log {
+
+    public static final Logger LOGGER = LogManager.getLogger("GoodGenerator");
+}
diff --git a/src/main/java/goodgenerator/util/MaterialFix.java b/src/main/java/goodgenerator/util/MaterialFix.java
new file mode 100644
index 0000000000..32827b18b2
--- /dev/null
+++ b/src/main/java/goodgenerator/util/MaterialFix.java
@@ -0,0 +1,393 @@
+package goodgenerator.util;
+
+import static gregtech.api.recipe.RecipeMaps.benderRecipes;
+import static gregtech.api.recipe.RecipeMaps.fluidExtractionRecipes;
+import static gregtech.api.recipe.RecipeMaps.fluidSolidifierRecipes;
+import static gregtech.api.recipe.RecipeMaps.hammerRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+import static gregtech.api.util.GT_RecipeBuilder.TICKS;
+
+import com.github.bartimaeusnek.bartworks.system.material.Werkstoff;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.TierEU;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Utility;
+
+public class MaterialFix {
+
+    public static void MaterialFluidExtractionFix(Werkstoff material) {
+        if (material.hasItemType(OrePrefixes.ingot)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.ingot))
+                .fluidOutputs(material.getMolten(144))
+                .duration(1 * SECONDS + 12 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+            GT_Values.RA.stdBuilder()
+                .itemInputs(ItemList.Shape_Mold_Ingot.get(0))
+                .fluidInputs(material.getMolten(144))
+                .itemOutputs(material.get(OrePrefixes.ingot))
+                .duration(1 * SECONDS + 12 * TICKS)
+                .eut(TierEU.RECIPE_MV / 2)
+                .addTo(fluidSolidifierRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.plate)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.plate))
+                .fluidOutputs(material.getMolten(144))
+                .duration(1 * SECONDS + 12 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+            GT_Values.RA.stdBuilder()
+                .itemInputs(ItemList.Shape_Mold_Plate.get(0))
+                .fluidInputs(material.getMolten(144))
+                .itemOutputs(material.get(OrePrefixes.plate))
+                .duration(1 * SECONDS + 12 * TICKS)
+                .eut(TierEU.RECIPE_MV / 2)
+                .addTo(fluidSolidifierRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.gearGtSmall)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.gearGtSmall))
+                .fluidOutputs(material.getMolten(144))
+                .duration(1 * SECONDS + 12 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.stickLong)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.stickLong))
+                .fluidOutputs(material.getMolten(144))
+                .duration(1 * SECONDS + 12 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.spring)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.spring))
+                .fluidOutputs(material.getMolten(144))
+                .duration(1 * SECONDS + 12 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.stick)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.stick))
+                .fluidOutputs(material.getMolten(72))
+                .duration(16 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.itemCasing)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.itemCasing))
+                .fluidOutputs(material.getMolten(72))
+                .duration(16 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.wireGt01)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.wireGt01))
+                .fluidOutputs(material.getMolten(72))
+                .duration(16 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.cableGt01)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.cableGt01))
+                .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Ash, 2))
+                .fluidOutputs(material.getMolten(72))
+                .duration(16 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.foil)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.foil))
+                .fluidOutputs(material.getMolten(36))
+                .duration(8 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.springSmall)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.springSmall))
+                .fluidOutputs(material.getMolten(36))
+                .duration(8 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.ring)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.ring))
+                .fluidOutputs(material.getMolten(36))
+                .duration(8 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.bolt)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.bolt))
+                .fluidOutputs(material.getMolten(18))
+                .duration(4 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.wireFine)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.wireFine))
+                .fluidOutputs(material.getMolten(18))
+                .duration(4 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.round)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.round))
+                .fluidOutputs(material.getMolten(16))
+                .duration(4 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.screw)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.screw))
+                .fluidOutputs(material.getMolten(16))
+                .duration(4 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.nugget)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.nugget))
+                .fluidOutputs(material.getMolten(16))
+                .duration(4 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.rotor)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.rotor))
+                .fluidOutputs(material.getMolten(612))
+                .duration(136 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+        if (material.hasItemType(OrePrefixes.gearGt)) {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(material.get(OrePrefixes.gearGt))
+                .fluidOutputs(material.getMolten(576))
+                .duration(128 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+        }
+    }
+
+    public static void addRecipeForMultiItems() {
+        for (Werkstoff tMaterial : Werkstoff.werkstoffHashSet) {
+            if (tMaterial == null) continue;
+            if (tMaterial.hasItemType(OrePrefixes.plateDouble) && tMaterial.hasItemType(OrePrefixes.ingotDouble)) {
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(tMaterial.get(OrePrefixes.plate, 2), GT_Utility.getIntegratedCircuit(2))
+                    .itemOutputs(tMaterial.get(OrePrefixes.plateDouble, 1))
+                    .duration(
+                        Math.max(
+                            tMaterial.getStats()
+                                .getMass() * 2,
+                            1L) * TICKS)
+                    .eut(TierEU.RECIPE_MV / 2)
+                    .addTo(benderRecipes);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(tMaterial.get(OrePrefixes.ingotDouble, 1), GT_Utility.getIntegratedCircuit(1))
+                    .itemOutputs(tMaterial.get(OrePrefixes.plateDouble, 1))
+                    .duration(
+                        Math.max(
+                            tMaterial.getStats()
+                                .getMass(),
+                            1L) * TICKS)
+                    .eut(TierEU.RECIPE_MV / 2)
+                    .addTo(benderRecipes);
+                GT_ModHandler.addCraftingRecipe(
+                    tMaterial.get(OrePrefixes.plateDouble, 1),
+                    new Object[] { "P", "P", "h", 'P', tMaterial.get(OrePrefixes.plate, 1) });
+                GT_ModHandler.addCraftingRecipe(
+                    tMaterial.get(OrePrefixes.ingotDouble, 1),
+                    new Object[] { "P", "P", "h", 'P', tMaterial.get(OrePrefixes.ingot, 1) });
+            }
+            if (tMaterial.hasItemType(OrePrefixes.plateTriple) && tMaterial.hasItemType(OrePrefixes.ingotTriple)) {
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(tMaterial.get(OrePrefixes.plate, 3), GT_Utility.getIntegratedCircuit(3))
+                    .itemOutputs(tMaterial.get(OrePrefixes.plateTriple, 1))
+                    .duration(
+                        Math.max(
+                            tMaterial.getStats()
+                                .getMass() * 3,
+                            1L) * TICKS)
+                    .eut(TierEU.RECIPE_MV / 2)
+                    .addTo(benderRecipes);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(tMaterial.get(OrePrefixes.ingot, 3), GT_Utility.getIntegratedCircuit(3))
+                    .itemOutputs(tMaterial.get(OrePrefixes.plateTriple, 1))
+                    .duration(
+                        Math.max(
+                            tMaterial.getStats()
+                                .getMass() * 3,
+                            1L) * TICKS)
+                    .eut(TierEU.RECIPE_MV / 2)
+                    .addTo(benderRecipes);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(tMaterial.get(OrePrefixes.ingotTriple, 1), GT_Utility.getIntegratedCircuit(1))
+                    .itemOutputs(tMaterial.get(OrePrefixes.plateTriple, 1))
+                    .duration(
+                        Math.max(
+                            tMaterial.getStats()
+                                .getMass(),
+                            1L) * TICKS)
+                    .eut(TierEU.RECIPE_MV / 2)
+                    .addTo(benderRecipes);
+                GT_ModHandler.addCraftingRecipe(
+                    tMaterial.get(OrePrefixes.plateTriple, 1),
+                    new Object[] { "B", "P", "h", 'P', tMaterial.get(OrePrefixes.plate, 1), 'B',
+                        tMaterial.get(OrePrefixes.plateDouble, 1) });
+                GT_ModHandler.addCraftingRecipe(
+                    tMaterial.get(OrePrefixes.ingotTriple, 1),
+                    new Object[] { "B", "P", "h", 'P', tMaterial.get(OrePrefixes.ingot, 1), 'B',
+                        tMaterial.get(OrePrefixes.ingotDouble, 1) });
+            }
+            if (tMaterial.hasItemType(OrePrefixes.plateDense)) {
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(tMaterial.get(OrePrefixes.plate, 9), GT_Utility.getIntegratedCircuit(9))
+                    .itemOutputs(tMaterial.get(OrePrefixes.plateDense, 1))
+                    .duration(
+                        Math.max(
+                            tMaterial.getStats()
+                                .getMass() * 9,
+                            1L) * TICKS)
+                    .eut(TierEU.RECIPE_MV / 2)
+                    .addTo(benderRecipes);
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(tMaterial.get(OrePrefixes.ingot, 9), GT_Utility.getIntegratedCircuit(9))
+                    .itemOutputs(tMaterial.get(OrePrefixes.plateDense, 1))
+                    .duration(
+                        Math.max(
+                            tMaterial.getStats()
+                                .getMass() * 9,
+                            1L) * TICKS)
+                    .eut(TierEU.RECIPE_MV / 2)
+                    .addTo(benderRecipes);
+
+                if (tMaterial.hasItemType(OrePrefixes.plateTriple) && tMaterial.hasItemType(OrePrefixes.ingotTriple)) {
+                    GT_Values.RA.stdBuilder()
+                        .itemInputs(tMaterial.get(OrePrefixes.plateTriple, 3), GT_Utility.getIntegratedCircuit(3))
+                        .itemOutputs(tMaterial.get(OrePrefixes.plateDense, 1))
+                        .duration(
+                            Math.max(
+                                tMaterial.getStats()
+                                    .getMass() * 3,
+                                1L) * TICKS)
+                        .eut(TierEU.RECIPE_MV / 2)
+                        .addTo(benderRecipes);
+                    GT_Values.RA.stdBuilder()
+                        .itemInputs(tMaterial.get(OrePrefixes.ingotTriple, 3), GT_Utility.getIntegratedCircuit(3))
+                        .itemOutputs(tMaterial.get(OrePrefixes.plateDense, 1))
+                        .duration(
+                            Math.max(
+                                tMaterial.getStats()
+                                    .getMass() * 3,
+                                1L) * TICKS)
+                        .eut(TierEU.RECIPE_MV / 2)
+                        .addTo(benderRecipes);
+                }
+            }
+            if (tMaterial.hasItemType(OrePrefixes.stick)) {
+                if (tMaterial.hasItemType(OrePrefixes.cellMolten)) {
+                    GT_Values.RA.stdBuilder()
+                        .itemInputs(ItemList.Shape_Mold_Rod.get(0))
+                        .fluidInputs(tMaterial.getMolten(72))
+                        .itemOutputs(tMaterial.get(OrePrefixes.stick, 1))
+                        .duration(
+                            Math.max(
+                                tMaterial.getStats()
+                                    .getMass() >> 1,
+                                1L) * TICKS)
+                        .eut(TierEU.RECIPE_HV)
+                        .addTo(fluidSolidifierRecipes);
+                }
+            }
+            if (tMaterial.hasItemType(OrePrefixes.stickLong)) {
+                if (tMaterial.hasItemType(OrePrefixes.cellMolten)) {
+                    GT_Values.RA.stdBuilder()
+                        .itemInputs(ItemList.Shape_Mold_Rod_Long.get(0))
+                        .fluidInputs(tMaterial.getMolten(144))
+                        .itemOutputs(tMaterial.get(OrePrefixes.stickLong, 1))
+                        .duration(
+                            Math.max(
+                                tMaterial.getStats()
+                                    .getMass(),
+                                1L) * TICKS)
+                        .eut(TierEU.RECIPE_HV)
+                        .addTo(fluidSolidifierRecipes);
+                }
+                if (tMaterial.hasItemType(OrePrefixes.stick)) {
+                    GT_ModHandler.addCraftingRecipe(
+                        tMaterial.get(OrePrefixes.stickLong, 1),
+                        new Object[] { "PhP", 'P', tMaterial.get(OrePrefixes.stick, 1) });
+                    GT_Values.RA.stdBuilder()
+                        .itemInputs(tMaterial.get(OrePrefixes.stick, 2))
+                        .itemOutputs(tMaterial.get(OrePrefixes.stickLong, 1))
+                        .duration(
+                            Math.max(
+                                tMaterial.getStats()
+                                    .getMass(),
+                                1L) * TICKS)
+                        .eut(TierEU.RECIPE_LV / 2)
+                        .addTo(hammerRecipes);
+                }
+            }
+            if (tMaterial.hasItemType(OrePrefixes.spring)) {
+                GT_ModHandler.addCraftingRecipe(
+                    tMaterial.get(OrePrefixes.spring, 1),
+                    new Object[] { " s ", "fPx", " P ", 'P', tMaterial.get(OrePrefixes.stickLong, 1) });
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(tMaterial.get(OrePrefixes.stickLong, 1), GT_Utility.getIntegratedCircuit(1))
+                    .itemOutputs(tMaterial.get(OrePrefixes.spring, 1))
+                    .duration(
+                        Math.max(
+                            tMaterial.getStats()
+                                .getMass() * 2,
+                            1L) * TICKS)
+                    .eut(TierEU.RECIPE_LV / 2)
+                    .addTo(benderRecipes);
+            }
+            if (tMaterial.hasItemType(OrePrefixes.springSmall)) {
+                GT_ModHandler.addCraftingRecipe(
+                    tMaterial.get(OrePrefixes.springSmall, 1),
+                    new Object[] { " s ", "fPx", 'P', tMaterial.get(OrePrefixes.stick, 1) });
+                GT_Values.RA.stdBuilder()
+                    .itemInputs(tMaterial.get(OrePrefixes.stick, 1), GT_Utility.getIntegratedCircuit(1))
+                    .itemOutputs(tMaterial.get(OrePrefixes.springSmall, 1))
+                    .duration(
+                        Math.max(
+                            tMaterial.getStats()
+                                .getMass(),
+                            1L) * TICKS)
+                    .eut(TierEU.RECIPE_LV / 2)
+                    .addTo(benderRecipes);
+            }
+        }
+        Materials tUHV = Materials.Longasssuperconductornameforuhvwire;
+        GT_Values.RA.stdBuilder()
+            .itemInputs(GT_OreDictUnificator.get(OrePrefixes.stick, tUHV, 2))
+            .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.stickLong, tUHV, 1))
+            .duration(Math.max(tUHV.getMass(), 1L) * TICKS)
+            .eut(TierEU.RECIPE_LV / 2)
+            .addTo(hammerRecipes);
+    }
+}
diff --git a/src/main/java/goodgenerator/util/MyRecipeAdder.java b/src/main/java/goodgenerator/util/MyRecipeAdder.java
new file mode 100644
index 0000000000..6cc0eb585c
--- /dev/null
+++ b/src/main/java/goodgenerator/util/MyRecipeAdder.java
@@ -0,0 +1,72 @@
+package goodgenerator.util;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+import goodgenerator.api.recipe.ExtremeHeatExchangerRecipe;
+import goodgenerator.api.recipe.GoodGeneratorRecipeMaps;
+
+public class MyRecipeAdder {
+
+    public static final MyRecipeAdder instance = new MyRecipeAdder();
+
+    public void addLiquidMentalFuel(FluidStack input, FluidStack output, int EUt, int ticks) {
+        GoodGeneratorRecipeMaps.naquadahReactorFuels
+            .addRecipe(true, null, null, null, new FluidStack[] { input }, new FluidStack[] { output }, ticks, 0, EUt);
+    }
+
+    public void addNaquadahFuelRefineRecipe(FluidStack[] input1, ItemStack[] input2, FluidStack output, int EUt,
+        int ticks, int tier) {
+        GoodGeneratorRecipeMaps.naquadahFuelRefineFactoryRecipes
+            .addRecipe(false, input2, null, null, input1, new FluidStack[] { output }, ticks, EUt, tier);
+    }
+
+    public void addNeutronActivatorRecipe(FluidStack[] input1, ItemStack[] input2, FluidStack[] output1,
+        ItemStack[] output2, int ticks, int maxNKE, int minNKE) {
+        if (maxNKE <= 0) maxNKE = 1;
+        if (maxNKE >= 1100) maxNKE = 1100;
+        if (minNKE < 0) minNKE = 0;
+        if (minNKE >= maxNKE) minNKE = maxNKE - 1;
+        GoodGeneratorRecipeMaps.neutronActivatorRecipes
+            .addRecipe(false, input2, output2, null, input1, output1, ticks, 0, maxNKE * 10000 + minNKE);
+    }
+
+    public void addExtremeHeatExchangerRecipe(FluidStack HotFluid, FluidStack ColdFluid, FluidStack WorkFluid,
+        FluidStack HeatedWorkFluid, FluidStack OverHeatedWorkFluid, int Threshold) {
+        GoodGeneratorRecipeMaps.extremeHeatExchangerFuels.addRecipe(
+            new ExtremeHeatExchangerRecipe(
+                new FluidStack[] { HotFluid, WorkFluid },
+                new FluidStack[] { HeatedWorkFluid, OverHeatedWorkFluid, ColdFluid },
+                Threshold));
+    }
+
+    public void addPreciseAssemblerRecipe(ItemStack[] aItemInputs, FluidStack[] aFluidInputs, ItemStack aOutput,
+        int aEUt, int aDuration, int aTier) {
+        if (aOutput == null) return;
+        GoodGeneratorRecipeMaps.preciseAssemblerRecipes.addRecipe(
+            false,
+            aItemInputs,
+            new ItemStack[] { aOutput },
+            null,
+            null,
+            aFluidInputs,
+            null,
+            aDuration,
+            aEUt,
+            aTier);
+    }
+
+    public void addComponentAssemblyLineRecipe(ItemStack[] ItemInputArray, FluidStack[] FluidInputArray,
+        ItemStack OutputItem, int aDuration, int aEUt, int casingLevel) {
+        GoodGeneratorRecipeMaps.componentAssemblyLineRecipes.addRecipe(
+            false,
+            ItemInputArray,
+            new ItemStack[] { OutputItem },
+            null,
+            FluidInputArray,
+            null,
+            aDuration,
+            aEUt,
+            casingLevel);
+    }
+}
diff --git a/src/main/java/goodgenerator/util/StackUtils.java b/src/main/java/goodgenerator/util/StackUtils.java
new file mode 100644
index 0000000000..2784828117
--- /dev/null
+++ b/src/main/java/goodgenerator/util/StackUtils.java
@@ -0,0 +1,143 @@
+package goodgenerator.util;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidContainerRegistry;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+import appeng.api.AEApi;
+import appeng.api.storage.data.IAEFluidStack;
+import goodgenerator.items.MyMaterial;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.MaterialsUEVplus;
+import gregtech.api.util.GT_Utility;
+
+public class StackUtils {
+
+    /**
+     * Multiplies one ItemStack by a multiplier, and splits it into as many full stacks as it needs to.
+     *
+     * @param stack      The ItemStack you want to multiply
+     * @param multiplier The number the stack is multiplied by
+     * @return A List of stacks that, in total, are the same as the input ItemStack after it has been multiplied.
+     */
+    public static List<ItemStack> multiplyAndSplitIntoStacks(ItemStack stack, int multiplier) {
+        int totalItems = stack.stackSize * multiplier;
+        ArrayList<ItemStack> stacks = new ArrayList<>();
+        if (totalItems >= 64) {
+            for (int i = 0; i < totalItems / 64; i++) {
+                stacks.add(GT_Utility.copyAmount(64, stack));
+            }
+        }
+        if (totalItems % 64 > 0) {
+            stacks.add(GT_Utility.copyAmount(totalItems % 64, stack));
+        }
+        return stacks;
+    }
+
+    /**
+     * Merges the ItemStacks in the array into full stacks.
+     */
+    public static ArrayList<ItemStack> mergeStacks(List<ItemStack> stacks) {
+        ArrayList<ItemStack> output = new ArrayList<>();
+        for (int index = 0; index < stacks.size(); index++) {
+            ItemStack i = stacks.get(index);
+            int newSize = i.stackSize;
+            for (int j = index + 1; j < stacks.size(); j++) {
+                ItemStack is2 = stacks.get(j);
+                if (GT_Utility.areStacksEqual(i, is2)) {
+                    newSize += is2.stackSize;
+                    stacks.remove(j);
+                    j--;
+                }
+            }
+            output.add(GT_Utility.copyAmountUnsafe(newSize, i));
+        }
+        return output;
+    }
+
+    /**
+     * Turns the {@code items} List into a {@code HashMap} containing each unique {@code ItemStack} as the key, and a
+     * value representing the total amount of the respective {@code ItemStack} in the List.
+     */
+    public static HashMap<ItemStack, Integer> getTotalItems(List<ItemStack> items) {
+        HashMap<ItemStack, Integer> totals = new HashMap<>();
+        itemLoop: for (ItemStack item : items) {
+            int t = items.stream()
+                .filter(i2 -> GT_Utility.areStacksEqual(item, i2))
+                .mapToInt(i -> i.stackSize)
+                .sum();
+            for (ItemStack i2 : totals.keySet()) if (GT_Utility.areStacksEqual(item, i2)) continue itemLoop;
+            totals.put(GT_Utility.copyAmount(1, item), t);
+        }
+        return totals;
+    }
+
+    /**
+     * Turns the {@code items} Array into a {@code HashMap} containing each unique {@code ItemStack} as the key, and a
+     * value representing the total amount of the respective {@code ItemStack} in the Array.
+     */
+    public static HashMap<ItemStack, Integer> getTotalItems(ItemStack[] items) {
+        return getTotalItems(Arrays.asList(items));
+    }
+
+    public static FluidStack getTieredFluid(int aTier, int aAmount) {
+        switch (aTier) {
+            case 0: // ULV
+                return Materials.RedAlloy.getMolten(aAmount);
+            case 1: // LV
+                return Materials.TinAlloy.getMolten(aAmount);
+            case 2: // MV
+                return Materials.RoseGold.getMolten(aAmount);
+            case 3: // HV
+                return MyMaterial.zircaloy4.getMolten(aAmount);
+            case 4: // EV
+                return MyMaterial.incoloy903.getMolten(aAmount);
+            case 5: // IV
+                return MyMaterial.titaniumBetaC.getMolten(aAmount);
+            case 6: // LuV
+                return MyMaterial.artheriumSn.getMolten(aAmount);
+            case 7: // ZPM
+                return MyMaterial.dalisenite.getMolten(aAmount);
+            case 8: // UV
+                return MyMaterial.tairitsu.getMolten(aAmount);
+            case 9: // UHV
+                return MyMaterial.preciousMetalAlloy.getMolten(aAmount);
+            case 10: // UEV
+                return MyMaterial.enrichedNaquadahAlloy.getMolten(aAmount);
+            case 11: // UIV
+                return MyMaterial.metastableOganesson.getMolten(aAmount);
+            case 12: // UMV
+                return MaterialsUEVplus.SpaceTime.getMolten(aAmount);
+            default:
+                return MyMaterial.shirabon.getMolten(aAmount);
+        }
+    }
+
+    // === Copied from AE2FC to avoid hard dep ===
+
+    public static IAEFluidStack createAEFluidStack(Fluid fluid) {
+        return createAEFluidStack(new FluidStack(fluid, FluidContainerRegistry.BUCKET_VOLUME));
+    }
+
+    public static IAEFluidStack createAEFluidStack(Fluid fluid, long amount) {
+        return createAEFluidStack(fluid.getID(), amount);
+    }
+
+    public static IAEFluidStack createAEFluidStack(FluidStack fluid) {
+        return AEApi.instance()
+            .storage()
+            .createFluidStack(fluid);
+    }
+
+    public static IAEFluidStack createAEFluidStack(int fluidId, long amount) {
+        return createAEFluidStack(new FluidStack(FluidRegistry.getFluid(fluidId), 1)).setStackSize(amount);
+    }
+
+}
diff --git a/src/main/java/goodgenerator/util/StructureHelper.java b/src/main/java/goodgenerator/util/StructureHelper.java
new file mode 100644
index 0000000000..e66ac9f9ee
--- /dev/null
+++ b/src/main/java/goodgenerator/util/StructureHelper.java
@@ -0,0 +1,117 @@
+package goodgenerator.util;
+
+import java.util.Arrays;
+import java.util.function.BiConsumer;
+import java.util.function.BiPredicate;
+import java.util.function.Function;
+
+import net.minecraft.block.Block;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+
+import com.gtnewhorizon.structurelib.StructureLibAPI;
+import com.gtnewhorizon.structurelib.structure.IStructureElement;
+
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.metatileentity.BaseMetaPipeEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaPipeEntity_Frame;
+import gregtech.api.util.GT_OreDictUnificator;
+
+public class StructureHelper {
+
+    public static <T> IStructureElement<T> addFrame(Materials aMaterials) {
+        return new IStructureElement<T>() {
+
+            private IIcon[] mIcons;
+
+            @Override
+            public boolean check(T t, World world, int x, int y, int z) {
+                TileEntity tBlock = world.getTileEntity(x, y, z);
+                if (tBlock instanceof BaseMetaPipeEntity) {
+                    BaseMetaPipeEntity tFrame = (BaseMetaPipeEntity) tBlock;
+                    if (tFrame.isInvalidTileEntity()) return false;
+                    if (tFrame.getMetaTileEntity() instanceof GT_MetaPipeEntity_Frame) {
+                        return ((GT_MetaPipeEntity_Frame) tFrame.getMetaTileEntity()).mMaterial == aMaterials;
+                    }
+                }
+                return false;
+            }
+
+            @Override
+            public boolean spawnHint(T t, World world, int x, int y, int z, ItemStack trigger) {
+                if (mIcons == null) {
+                    mIcons = new IIcon[6];
+                    Arrays.fill(mIcons, aMaterials.mIconSet.mTextures[OrePrefixes.frameGt.mTextureIndex].getIcon());
+                }
+                StructureLibAPI.hintParticleTinted(world, x, y, z, mIcons, aMaterials.mRGBa);
+                return true;
+            }
+
+            @Override
+            public boolean placeBlock(T t, World world, int x, int y, int z, ItemStack trigger) {
+                ItemStack tFrame = GT_OreDictUnificator.get(OrePrefixes.frameGt, aMaterials, 1);
+                if (tFrame.getItem() instanceof ItemBlock) {
+                    ItemBlock tFrameStackItem = (ItemBlock) tFrame.getItem();
+                    return tFrameStackItem
+                        .placeBlockAt(tFrame, null, world, x, y, z, 6, 0, 0, 0, Items.feather.getDamage(tFrame));
+                }
+                return false;
+            }
+        };
+    }
+
+    // Only support to use meta to tier
+    public static <T> IStructureElement<T> addTieredBlock(Block aBlock, BiConsumer<T, Integer> aSetTheFuckingMeta,
+        Function<T, Integer> aGetTheFuckingMeta, int maxMeta) {
+        return addTieredBlock(aBlock, (t, i) -> {
+            aSetTheFuckingMeta.accept(t, i);
+            return true;
+        }, aGetTheFuckingMeta, maxMeta);
+    }
+
+    public static <T> IStructureElement<T> addTieredBlock(Block aBlock, BiPredicate<T, Integer> aSetTheFuckingMeta,
+        Function<T, Integer> aGetTheFuckingMeta, int maxMeta) {
+
+        return new IStructureElement<T>() {
+
+            @Override
+            public boolean check(T t, World world, int x, int y, int z) {
+                Block tBlock = world.getBlock(x, y, z);
+                if (aBlock == tBlock) {
+                    Integer currentMeta = aGetTheFuckingMeta.apply(t);
+                    int newMeta = tBlock.getDamageValue(world, x, y, z) + 1;
+                    if (newMeta > maxMeta) return false;
+                    if (currentMeta == 0) {
+                        return aSetTheFuckingMeta.test(t, newMeta);
+                    } else {
+                        return currentMeta == newMeta;
+                    }
+                }
+                return false;
+            }
+
+            @Override
+            public boolean spawnHint(T t, World world, int x, int y, int z, ItemStack trigger) {
+                StructureLibAPI.hintParticle(world, x, y, z, aBlock, getMeta(trigger));
+                return true;
+            }
+
+            @Override
+            public boolean placeBlock(T t, World world, int x, int y, int z, ItemStack trigger) {
+                return world.setBlock(x, y, z, aBlock, getMeta(trigger), 3);
+            }
+
+            private int getMeta(ItemStack trigger) {
+                int meta = trigger.stackSize - 1;
+                if (meta <= 0) meta = 0;
+                if (meta >= maxMeta) meta = maxMeta - 1;
+                return meta;
+            }
+        };
+    }
+}