The Great Renaming (#3014)

* move kekztech to a single root dir

* move detrav to a single root dir

* move gtnh-lanthanides to a single root dir

* move tectech and delete some gross reflection in gt++

* remove more reflection inside gt5u

* delete more reflection in gt++

* fix imports

* move bartworks and bwcrossmod

* fix proxies

* move galactigreg and ggfab

* move gtneioreplugin

* try to fix gt++ bee loader

* apply the rename rules to BW

* apply rename rules to bwcrossmod

* apply rename rules to detrav scanner mod

* apply rename rules to galacticgreg

* apply rename rules to ggfab

* apply rename rules to goodgenerator

* apply rename rules to gtnh-lanthanides

* apply rename rules to gt++

* apply rename rules to kekztech

* apply rename rules to kubatech

* apply rename rules to tectech

* apply rename rules to gt

apply the rename rules to gt

* fix tt import

* fix mui hopefully

* fix coremod except intergalactic

* rename assline recipe class

* fix a class name i stumbled on

* rename StructureUtility to GTStructureUtility to prevent conflict with structurelib

* temporary rename of GTTooltipDataCache to old name

* fix gt client/server proxy names

19 files changed, 3715 insertions, 0 deletions

diff --git a/src/main/java/bartworks/system/material/werkstoff_loaders/IWerkstoffRunnable.java b/src/main/java/bartworks/system/material/werkstoff_loaders/IWerkstoffRunnable.java
new file mode 100644
index 0000000000..8399091f8b
--- /dev/null
+++ b/src/main/java/bartworks/system/material/werkstoff_loaders/IWerkstoffRunnable.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+ * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial
+ * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package bartworks.system.material.werkstoff_loaders;
+
+import bartworks.system.material.Werkstoff;
+
+public interface IWerkstoffRunnable {
+
+    void run(Werkstoff werkstoff);
+}
diff --git a/src/main/java/bartworks/system/material/werkstoff_loaders/recipe/AspectLoader.java b/src/main/java/bartworks/system/material/werkstoff_loaders/recipe/AspectLoader.java
new file mode 100644
index 0000000000..6635db3b3b
--- /dev/null
+++ b/src/main/java/bartworks/system/material/werkstoff_loaders/recipe/AspectLoader.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+ * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial
+ * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package bartworks.system.material.werkstoff_loaders.recipe;
+
+import static gregtech.api.enums.Mods.Thaumcraft;
+
+import java.util.Objects;
+
+import bartworks.system.material.Werkstoff;
+import bartworks.system.material.WerkstoffLoader;
+import bartworks.system.material.werkstoff_loaders.IWerkstoffRunnable;
+import bartworks.util.Pair;
+import bartworks.util.log.DebugLog;
+import bwcrossmod.thaumcraft.util.ThaumcraftHandler;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.TCAspects;
+
+public class AspectLoader implements IWerkstoffRunnable {
+
+    @Override
+    public void run(Werkstoff werkstoff) {
+        if (!Thaumcraft.isModLoaded()) {
+            return;
+        }
+
+        for (OrePrefixes enabledOrePrefixes : WerkstoffLoader.ENABLED_ORE_PREFIXES) {
+            if (werkstoff.hasItemType(enabledOrePrefixes)) {
+                if (enabledOrePrefixes.mMaterialAmount >= 3628800L || enabledOrePrefixes == OrePrefixes.ore) {
+                    DebugLog.log(
+                        "OrePrefix: " + enabledOrePrefixes.name()
+                            + " mMaterialAmount: "
+                            + enabledOrePrefixes.mMaterialAmount / 3628800L);
+                    if (Objects.nonNull(WerkstoffLoader.items.get(enabledOrePrefixes)))
+                        ThaumcraftHandler.AspectAdder.addAspectViaBW(
+                            werkstoff.get(enabledOrePrefixes),
+                            werkstoff.getTCAspects(
+                                enabledOrePrefixes == OrePrefixes.ore ? 1
+                                    : (int) (enabledOrePrefixes.mMaterialAmount / 3628800L)));
+                } else if (enabledOrePrefixes.mMaterialAmount >= 0L
+                    && Objects.nonNull(WerkstoffLoader.items.get(enabledOrePrefixes)))
+                    ThaumcraftHandler.AspectAdder
+                        .addAspectViaBW(werkstoff.get(enabledOrePrefixes), new Pair<>(TCAspects.PERDITIO.mAspect, 1));
+            }
+        }
+    }
+}
diff --git a/src/main/java/bartworks/system/material/werkstoff_loaders/recipe/BlockLoader.java b/src/main/java/bartworks/system/material/werkstoff_loaders/recipe/BlockLoader.java
new file mode 100644
index 0000000000..3637385328
--- /dev/null
+++ b/src/main/java/bartworks/system/material/werkstoff_loaders/recipe/BlockLoader.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+ * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial
+ * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package bartworks.system.material.werkstoff_loaders.recipe;
+
+import static gregtech.api.enums.OrePrefixes.block;
+import static gregtech.api.enums.OrePrefixes.cellMolten;
+import static gregtech.api.enums.OrePrefixes.ingot;
+import static gregtech.api.enums.OrePrefixes.plate;
+import static gregtech.api.recipe.RecipeMaps.cutterRecipes;
+import static gregtech.api.recipe.RecipeMaps.fluidExtractionRecipes;
+import static gregtech.api.util.GTRecipeBuilder.SECONDS;
+import static gregtech.api.util.GTRecipeBuilder.TICKS;
+import static gregtech.api.util.GTRecipeConstants.UniversalArcFurnace;
+
+import bartworks.system.material.Werkstoff;
+import bartworks.system.material.werkstoff_loaders.IWerkstoffRunnable;
+import gregtech.api.enums.GTValues;
+import gregtech.api.enums.TierEU;
+import gregtech.api.recipe.RecipeCategories;
+import gregtech.api.util.GTRecipeConstants;
+
+public class BlockLoader implements IWerkstoffRunnable {
+
+    @Override
+    public void run(Werkstoff werkstoff) {
+        if (!werkstoff.hasItemType(block)) return;
+        if (werkstoff.hasItemType(ingot)) {
+            GTValues.RA.stdBuilder()
+                .itemInputs(werkstoff.get(block))
+                .itemOutputs(werkstoff.get(ingot, 9))
+                .duration(16 * TICKS)
+                .eut(90)
+                .metadata(GTRecipeConstants.RECYCLE, true)
+                .addTo(UniversalArcFurnace);
+        }
+        if (werkstoff.hasItemType(cellMolten)) {
+
+            GTValues.RA.stdBuilder()
+                .itemInputs(werkstoff.get(block))
+                .fluidOutputs(werkstoff.getMolten(1296))
+                .recipeCategory(RecipeCategories.fluidExtractorRecycling)
+                .duration(14 * SECONDS + 8 * TICKS)
+                .eut(8)
+                .addTo(fluidExtractionRecipes);
+
+        }
+        if (werkstoff.hasItemType(plate)) {
+
+            GTValues.RA.stdBuilder()
+                .itemInputs(werkstoff.get(block))
+                .itemOutputs(werkstoff.get(plate, 9))
+                .duration(
+                    (int) Math.max(
+                        werkstoff.getStats()
+                            .getMass() * 10L,
+                        1L))
+                .eut(TierEU.RECIPE_LV)
+                .addTo(cutterRecipes);
+
+        }
+    }
+}
diff --git a/src/main/java/bartworks/system/material/werkstoff_loaders/recipe/CasingLoader.java b/src/main/java/bartworks/system/material/werkstoff_loaders/recipe/CasingLoader.java
new file mode 100644
index 0000000000..06bda56804
--- /dev/null
+++ b/src/main/java/bartworks/system/material/werkstoff_loaders/recipe/CasingLoader.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+ * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial
+ * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package bartworks.system.material.werkstoff_loaders.recipe;
+
+import static gregtech.api.enums.OrePrefixes.blockCasing;
+import static gregtech.api.enums.OrePrefixes.blockCasingAdvanced;
+import static gregtech.api.enums.OrePrefixes.gearGt;
+import static gregtech.api.enums.OrePrefixes.gearGtSmall;
+import static gregtech.api.enums.OrePrefixes.plank;
+import static gregtech.api.enums.OrePrefixes.plate;
+import static gregtech.api.enums.OrePrefixes.plateDouble;
+import static gregtech.api.enums.OrePrefixes.screw;
+import static gregtech.api.recipe.RecipeMaps.assemblerRecipes;
+import static gregtech.api.util.GTRecipeBuilder.SECONDS;
+
+import bartworks.system.material.BWGTMaterialReference;
+import bartworks.system.material.Werkstoff;
+import bartworks.system.material.werkstoff_loaders.IWerkstoffRunnable;
+import gregtech.api.enums.GTValues;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.TierEU;
+import gregtech.api.util.GTModHandler;
+
+public class CasingLoader implements IWerkstoffRunnable {
+
+    @Override
+    public void run(Werkstoff werkstoff) {
+        if (werkstoff == BWGTMaterialReference.Wood /* || werkstoff == BW_GT_MaterialReference.WoodSealed */) {
+            addCasingRecipes(werkstoff, plank);
+        } else {
+            if (!werkstoff.hasGenerationFeature(blockCasing) || !werkstoff.doesOreDictedItemExists(plate)
+                || !werkstoff.doesOreDictedItemExists(screw)
+                || !werkstoff.doesOreDictedItemExists(gearGtSmall)
+                || !werkstoff.doesOreDictedItemExists(gearGt)
+                || !werkstoff.doesOreDictedItemExists(plateDouble)) return;
+
+            addCasingRecipes(werkstoff, plateDouble);
+        }
+    }
+
+    private static void addCasingRecipes(Werkstoff werkstoff, OrePrefixes reboltedCasingsOuterStuff) {
+        GTModHandler.addCraftingRecipe(
+            werkstoff.get(blockCasing),
+            new Object[] { "PSP", "PGP", "PSP", 'P', werkstoff.get(plate), 'S', werkstoff.get(screw), 'G',
+                werkstoff.get(gearGtSmall) });
+
+        GTValues.RA.stdBuilder()
+            .itemInputs(werkstoff.get(plate, 6), werkstoff.get(screw, 2), werkstoff.get(gearGtSmall))
+            .itemOutputs(werkstoff.get(blockCasing))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(assemblerRecipes);
+
+        GTModHandler.addCraftingRecipe(
+            werkstoff.get(blockCasingAdvanced),
+            new Object[] { "PSP", "PGP", "PSP", 'P', werkstoff.get(reboltedCasingsOuterStuff), 'S',
+                werkstoff.get(screw), 'G', werkstoff.get(gearGt) });
+
+        GTValues.RA.stdBuilder()
+            .itemInputs(werkstoff.get(reboltedCasingsOuterStuff, 6), werkstoff.get(screw, 2), werkstoff.get(gearGt))
+            .itemOutputs(werkstoff.get(blockCasingAdvanced))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(assemblerRecipes);
+    }
+}
diff --git a/src/main/java/bartworks/system/material/werkstoff_loaders/recipe/CellLoader.java b/src/main/java/bartworks/system/material/werkstoff_loaders/recipe/CellLoader.java
new file mode 100644
index 0000000000..5458d24244
--- /dev/null
+++ b/src/main/java/bartworks/system/material/werkstoff_loaders/recipe/CellLoader.java
@@ -0,0 +1,330 @@
+/*
+ * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+ * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial
+ * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package bartworks.system.material.werkstoff_loaders.recipe;
+
+import static gregtech.api.enums.Mods.Forestry;
+import static gregtech.api.enums.OrePrefixes.capsule;
+import static gregtech.api.enums.OrePrefixes.cell;
+import static gregtech.api.enums.OrePrefixes.dust;
+import static gregtech.api.recipe.RecipeMaps.fluidCannerRecipes;
+import static gregtech.api.recipe.RecipeMaps.fluidExtractionRecipes;
+import static gregtech.api.recipe.RecipeMaps.fluidSolidifierRecipes;
+import static gregtech.api.recipe.RecipeMaps.scannerFakeRecipes;
+import static gregtech.api.util.GTRecipeBuilder.TICKS;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Objects;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidContainerRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+import bartworks.system.material.Werkstoff;
+import bartworks.system.material.WerkstoffLoader;
+import bartworks.system.material.werkstoff_loaders.IWerkstoffRunnable;
+import bartworks.util.Pair;
+import gregtech.api.enums.Element;
+import gregtech.api.enums.GTValues;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.TextureSet;
+import gregtech.api.enums.TierEU;
+import gregtech.api.interfaces.ISubTagContainer;
+import gregtech.api.recipe.RecipeCategories;
+import gregtech.api.recipe.RecipeMaps;
+import gregtech.api.util.GTModHandler;
+import gregtech.api.util.GTOreDictUnificator;
+import gregtech.api.util.GTRecipe;
+import gregtech.api.util.GTUtility;
+import gregtech.common.items.behaviors.BehaviourDataOrb;
+
+public class CellLoader implements IWerkstoffRunnable {
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void run(Werkstoff werkstoff) {
+        if (!werkstoff.hasItemType(cell)) return;
+
+        if ((werkstoff.getStats()
+            .isElektrolysis()
+            || werkstoff.getStats()
+                .isCentrifuge())
+            && !werkstoff.hasItemType(dust)) {
+            List<FluidStack> flOutputs = new ArrayList<>();
+            List<ItemStack> stOutputs = new ArrayList<>();
+            HashMap<ISubTagContainer, Pair<Integer, Integer>> tracker = new HashMap<>();
+            int cells = 0;
+            for (Pair<ISubTagContainer, Integer> container : werkstoff.getContents()
+                .getValue()
+                .toArray(new Pair[0])) {
+                if (container.getKey() instanceof Materials) {
+                    if ((((Materials) container.getKey()).hasCorrespondingGas()
+                        || ((Materials) container.getKey()).hasCorrespondingFluid()
+                        || ((Materials) container.getKey()).mIconSet == TextureSet.SET_FLUID)
+                        && ((Materials) container.getKey()).getDust(0) == null) {
+                        FluidStack tmpFl = ((Materials) container.getKey()).getGas(1000L * container.getValue());
+                        if (tmpFl == null || tmpFl.getFluid() == null) {
+                            tmpFl = ((Materials) container.getKey()).getFluid(1000L * container.getValue());
+                        }
+                        flOutputs.add(tmpFl);
+                        if (flOutputs.size() > 1) {
+                            if (!tracker.containsKey(container.getKey())) {
+                                stOutputs.add(((Materials) container.getKey()).getCells(container.getValue()));
+                                tracker.put(container.getKey(), new Pair<>(container.getValue(), stOutputs.size() - 1));
+                            } else {
+                                stOutputs.add(
+                                    ((Materials) container.getKey()).getCells(
+                                        tracker.get(container.getKey())
+                                            .getKey() + container.getValue()));
+                                stOutputs.remove(
+                                    tracker.get(container.getKey())
+                                        .getValue() + 1);
+                            }
+                            cells += container.getValue();
+                        }
+                    } else {
+                        if (((Materials) container.getKey()).getDust(container.getValue()) == null) continue;
+                        if (!tracker.containsKey(container.getKey())) {
+                            stOutputs.add(((Materials) container.getKey()).getDust(container.getValue()));
+                            tracker.put(container.getKey(), new Pair<>(container.getValue(), stOutputs.size() - 1));
+                        } else {
+                            stOutputs.add(
+                                ((Materials) container.getKey()).getDust(
+                                    tracker.get(container.getKey())
+                                        .getKey() + container.getValue()));
+                            stOutputs.remove(
+                                tracker.get(container.getKey())
+                                    .getValue() + 1);
+                        }
+                    }
+                } else if (container.getKey() instanceof Werkstoff) {
+                    if (((Werkstoff) container.getKey()).getStats()
+                        .isGas() || ((Werkstoff) container.getKey()).hasItemType(cell)) {
+                        FluidStack tmpFl = ((Werkstoff) container.getKey()).getFluidOrGas(1000 * container.getValue());
+                        if (tmpFl == null || tmpFl.getFluid() == null) {
+                            tmpFl = ((Werkstoff) container.getKey()).getFluidOrGas(1000 * container.getValue());
+                        }
+                        flOutputs.add(tmpFl);
+                        if (flOutputs.size() > 1) {
+                            if (!tracker.containsKey(container.getKey())) {
+                                stOutputs.add(((Werkstoff) container.getKey()).get(cell, container.getValue()));
+                                tracker.put(container.getKey(), new Pair<>(container.getValue(), stOutputs.size() - 1));
+                            } else {
+                                stOutputs.add(
+                                    ((Werkstoff) container.getKey()).get(
+                                        cell,
+                                        tracker.get(container.getKey())
+                                            .getKey() + container.getValue()));
+                                stOutputs.remove(
+                                    tracker.get(container.getKey())
+                                        .getValue() + 1);
+                            }
+                            cells += container.getValue();
+                        }
+                    } else {
+                        if (!((Werkstoff) container.getKey()).hasItemType(dust)) continue;
+                        if (!tracker.containsKey(container.getKey())) {
+                            stOutputs.add(((Werkstoff) container.getKey()).get(dust, container.getValue()));
+                            tracker.put(container.getKey(), new Pair<>(container.getValue(), stOutputs.size() - 1));
+                        } else {
+                            stOutputs.add(
+                                ((Werkstoff) container.getKey()).get(
+                                    dust,
+                                    tracker.get(container.getKey())
+                                        .getKey() + container.getValue()));
+                            stOutputs.remove(
+                                tracker.get(container.getKey())
+                                    .getValue() + 1);
+                        }
+                    }
+                }
+            }
+            ItemStack input = werkstoff.get(cell);
+            input.stackSize = 1;
+
+            int cellEmpty = cells - 1;
+
+            stOutputs.add(Materials.Empty.getCells(-cellEmpty));
+            if (werkstoff.getStats()
+                .isElektrolysis())
+                RecipeMaps.electrolyzerRecipes.add(
+                    new GTRecipe(
+                        true,
+                        new ItemStack[] { input, cellEmpty > 0 ? Materials.Empty.getCells(cellEmpty) : null },
+                        stOutputs.toArray(new ItemStack[0]),
+                        null,
+                        null,
+                        new FluidStack[] { null },
+                        new FluidStack[] { flOutputs.size() > 0 ? flOutputs.get(0) : null },
+                        (int) Math.max(
+                            1L,
+                            Math.abs(
+                                werkstoff.getStats()
+                                    .getProtons()
+                                    * werkstoff.getContents()
+                                        .getValue()
+                                        .size())),
+                        Math.min(
+                            4,
+                            werkstoff.getContents()
+                                .getValue()
+                                .size())
+                            * 30,
+                        0));
+            if (werkstoff.getStats()
+                .isCentrifuge())
+                RecipeMaps.centrifugeRecipes.add(
+                    new GTRecipe(
+                        true,
+                        new ItemStack[] { input, cellEmpty > 0 ? Materials.Empty.getCells(cellEmpty) : null },
+                        stOutputs.toArray(new ItemStack[0]),
+                        null,
+                        null,
+                        new FluidStack[] { null },
+                        new FluidStack[] { flOutputs.size() > 0 ? flOutputs.get(0) : null },
+                        (int) Math.max(
+                            1L,
+                            Math.abs(
+                                werkstoff.getStats()
+                                    .getMass()
+                                    * werkstoff.getContents()
+                                        .getValue()
+                                        .size())),
+                        Math.min(
+                            4,
+                            werkstoff.getContents()
+                                .getValue()
+                                .size())
+                            * 5,
+                        0));
+        }
+
+        // Tank "Recipe"
+        GTUtility.addFluidContainerData(
+            new FluidContainerRegistry.FluidContainerData(
+                new FluidStack(Objects.requireNonNull(WerkstoffLoader.fluids.get(werkstoff)), 1000),
+                werkstoff.get(cell),
+                Materials.Empty.getCells(1)));
+        FluidContainerRegistry.registerFluidContainer(
+            werkstoff.getFluidOrGas(1)
+                .getFluid(),
+            werkstoff.get(cell),
+            Materials.Empty.getCells(1));
+
+        GTValues.RA.stdBuilder()
+            .itemInputs(Materials.Empty.getCells(1))
+            .itemOutputs(werkstoff.get(cell))
+            .fluidInputs(new FluidStack(Objects.requireNonNull(WerkstoffLoader.fluids.get(werkstoff)), 1000))
+            .duration(16 * TICKS)
+            .eut(2)
+            .addTo(fluidCannerRecipes);
+
+        GTValues.RA.stdBuilder()
+            .itemInputs(werkstoff.get(cell))
+            .itemOutputs(Materials.Empty.getCells(1))
+            .fluidOutputs(new FluidStack(Objects.requireNonNull(WerkstoffLoader.fluids.get(werkstoff)), 1000))
+            .duration(16 * TICKS)
+            .eut(2)
+            .addTo(fluidCannerRecipes);
+
+        if (Forestry.isModLoaded()) {
+            FluidContainerRegistry.FluidContainerData emptyData = new FluidContainerRegistry.FluidContainerData(
+                new FluidStack(Objects.requireNonNull(WerkstoffLoader.fluids.get(werkstoff)), 1000),
+                werkstoff.get(capsule),
+                GTModHandler.getModItem(Forestry.ID, "waxCapsule", 1),
+                true);
+            GTUtility.addFluidContainerData(emptyData);
+            FluidContainerRegistry.registerFluidContainer(emptyData);
+
+            GTValues.RA.stdBuilder()
+                .itemInputs(werkstoff.get(capsule))
+                .fluidOutputs(new FluidStack(Objects.requireNonNull(WerkstoffLoader.fluids.get(werkstoff)), 1000))
+                .duration(16 * TICKS)
+                .eut(2)
+                .addTo(fluidCannerRecipes);
+        }
+
+        if (werkstoff.hasItemType(dust)) {
+
+            GTValues.RA.stdBuilder()
+                .itemInputs(werkstoff.get(dust))
+                .fluidOutputs(werkstoff.getFluidOrGas(1000))
+                .duration(
+                    werkstoff.getStats()
+                        .getMass())
+                .eut(
+                    werkstoff.getStats()
+                        .getMass() > 128 ? 64 : 30)
+                .recipeCategory(RecipeCategories.fluidExtractorRecycling)
+                .addTo(fluidExtractionRecipes);
+
+            GTValues.RA.stdBuilder()
+                .itemInputs(GTUtility.getIntegratedCircuit(1))
+                .itemOutputs(werkstoff.get(dust))
+                .fluidInputs(werkstoff.getFluidOrGas(1000))
+                .duration(
+                    (int) werkstoff.getStats()
+                        .getMass())
+                .eut(
+                    werkstoff.getStats()
+                        .getMass() > 128 ? 64 : 30)
+                .addTo(fluidSolidifierRecipes);
+
+        }
+
+        if (Werkstoff.Types.ELEMENT.equals(werkstoff.getType())) {
+            Materials werkstoffBridgeMaterial = null;
+            boolean ElementSet = false;
+            for (Element e : Element.values()) {
+                if (e.toString()
+                    .equals(werkstoff.getToolTip())) {
+                    werkstoffBridgeMaterial = werkstoff.getBridgeMaterial() != null ? werkstoff.getBridgeMaterial()
+                        : new Materials(
+                            -1,
+                            werkstoff.getTexSet(),
+                            0,
+                            0,
+                            0,
+                            false,
+                            werkstoff.getDefaultName(),
+                            werkstoff.getDefaultName());
+                    werkstoffBridgeMaterial.mElement = e;
+                    e.mLinkedMaterials.add(werkstoffBridgeMaterial);
+                    ElementSet = true;
+                    werkstoff.setBridgeMaterial(werkstoffBridgeMaterial);
+                    break;
+                }
+            }
+            if (!ElementSet) return;
+
+            GTOreDictUnificator.addAssociation(cell, werkstoffBridgeMaterial, werkstoff.get(cell), false);
+
+            ItemStack scannerOutput = ItemList.Tool_DataOrb.get(1L);
+            BehaviourDataOrb.setDataTitle(scannerOutput, "Elemental-Scan");
+            BehaviourDataOrb.setDataName(scannerOutput, werkstoff.getToolTip());
+            GTValues.RA.stdBuilder()
+                .itemInputs(werkstoff.get(cell))
+                .itemOutputs(scannerOutput)
+                .special(ItemList.Tool_DataOrb.get(1L))
+                .duration(werkstoffBridgeMaterial.getMass() * 8192)
+                .eut(TierEU.RECIPE_LV)
+                .noOptimize()
+                .ignoreCollision()
+                .fake()
+                .addTo(scannerFakeRecipes);
+        }
+    }
+}
diff --git a/src/main/java/bartworks/system/material/werkstoff_loaders/recipe/CraftingMaterialLoader.java b/src/main/java/bartworks/system/material/werkstoff_loaders/recipe/CraftingMaterialLoader.java
new file mode 100644
index 0000000000..022cf4c3e6
--- /dev/null
+++ b/src/main/java/bartworks/system/material/werkstoff_loaders/recipe/CraftingMaterialLoader.java
@@ -0,0 +1,295 @@
+/*
+ * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+ * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial
+ * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package bartworks.system.material.werkstoff_l