Refactor RecipeMap (#2345)

* Remove deprecated and unused things

* Move recipemap subclasses

* Move GT_Recipe_Map to outside and rename to RecipeMap

* Move recipemap instances to separated class & remove prepending s

* Remove useless GT_Recipe constructors

* Always use ModularUI

* Rename IGT_RecipeMap -> IRecipeMap

* Add RecipeMapBuilder

* Remove more deprecated and unused things

* Fix RecipeMap type parameters

* Use multimap for recipe index

* Fix bending recipe error in dev env

* Remove mUniqueIdentifier

* Update AE2FC

* Less edgy texture for NEI recipe background

* Add replicator fluid output slot for NEI and machine GUI

* Fix fluid fuels not having fuel value in large boilers

* Remove GT_RectHandler and NEI_TransferRectHost

* Remove RecipeMapHandler

* Move NEI energy description from RecipeMapFrontend to Power

* Refactor the way to filter fusion recipes

* Check restriction for some properties

* Remove showVoltageAmperage

* Make Power accept GT_Recipe

* Fix NPE

* Move NEI duration description to Power from Frontend

* Directly implement IRecipeProcessingAwareHatch for GT_MetaTileEntity_Hatch_InputBus_ME

* Make Power integrated with GT_OverclockCalculator

* Rename Power -> OverclockDescriber

* Don't modify recipe find logic until postload finishes

* Reformat reserved MTE ids

* Fix check for too few inputs on recipe addition

* Move replicator logic to backend

* Stop un-hiding assline recipes

* Allow setting custom recipe comparator & implement for fusion

* Update AE2FC

* Rename getRecipeList and getRecipes -> getRecipeMap

* Automatically register recipe catalysts

* Cleanup the way to detect recipe collision

* Make use of BasicUIProperties for basic machines

* Make use of BasicUIProperties for UIHelper

* Rename specialHandler -> recipeTransformer

* Add way to automatically register handler info

* Add recipe category

* Add some APIs for addons

* Rename blastRecipes ->
blastFurnaceRecipes

* Remove GT_MetaTileEntity_BasicMachine_GT_Recipe#mSharedTank and #mRequiresFluidForFiltering

* Don't require setting duration and EU/t for fuel recipes

* Don't require setting EU/t for primitive blast furnace recipes

* Revert change to addMultiblockChemicalRecipe

* Fix large boiler general desc recipe not being added

* Hide duration and EU/t from large boiler

* Cleanup recipe stacktrace draw

* Extend metadata usage of recipe builder to recipe itself

* Implement metadata handling & NEI comparator for PCB factory

* Some rename around NEIRecipeInfo

* Some toString implementations

* Add more APIs for addons & some rename

* Infer handler icon from recipe catalyst if one is not set

* Also shrink recipe title when OC is not used

* Remove rare earth centrifuge recipe

* Use metadata for replicator backend

* Adjust geothermal generator output slot

* Allow having multiple transferrects

* Store recipemap reference in backend

* Rename vacuumRecipes -> vacuumFreezerRecipes

* Add config to tweak visibility of recipe categories

* Remove mHideRecyclingRecipes in favor of recipe category config

* Fix typo fluidSolidfierRecipes -> fluidSolidifierRecipes

* Refactor findRecipe and ProcessingLogic to use Stream

* Fix BBF handler icon & remove bronze blast furnace

* Add fluent API for findRecipe

* Add way to stop adding progressbar

* Change arg order for special texture

* Avoid overwriting interesting failure with NO_RECIPE

* Some changes for FuelBackend

* Set space project icon

* Remove localization from TT

* Remove CNC recipe adder

* Move recipe extractor from AE2FC

* Minor internal change for ProcessingLogic#applyRecipe

* More javadoc on #getAvailableRecipeMaps

* Better implementation of #ofSupplier

* Move replicator exponent config to GT_Proxy

* Remove RC & IC2 macerator handling

* Rename StreamUtil -> GT_StreamUtil

* Refactor code around RecipeMetadataStorage

* Revise #compileRecipe javadoc

* Switch extreme diesel recipe loader to downstream recipe map

* Optimize #reMap

* Rename reload -> reloadNEICache

* Minor tweak for drawEnergyInfo

* a bit more doc

* Adjust recipe catalysts

* Add toString implementation for GT_Fluid for debug

* Minor revision for OilCrackerBackend

* Index replicator recipes by material

---------

Co-authored-by: Glease <4586901+Glease@users.noreply.github.com>

20 files changed, 1467 insertions, 0 deletions

diff --git a/src/main/java/gregtech/api/recipe/maps/AssemblerBackend.java b/src/main/java/gregtech/api/recipe/maps/AssemblerBackend.java
new file mode 100644
index 0000000000..cfa25e9fe2
--- /dev/null
+++ b/src/main/java/gregtech/api/recipe/maps/AssemblerBackend.java
@@ -0,0 +1,35 @@
+package gregtech.api.recipe.maps;
+
+import javax.annotation.Nullable;
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+import gregtech.api.enums.ItemList;
+import gregtech.api.recipe.RecipeMapBackend;
+import gregtech.api.recipe.RecipeMapBackendPropertiesBuilder;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.MethodsReturnNonnullByDefault;
+
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+public class AssemblerBackend extends RecipeMapBackend {
+
+    public AssemblerBackend(RecipeMapBackendPropertiesBuilder propertiesBuilder) {
+        super(propertiesBuilder);
+    }
+
+    @Override
+    protected GT_Recipe modifyFoundRecipe(GT_Recipe recipe, ItemStack[] items, FluidStack[] fluids,
+        @Nullable ItemStack specialSlot) {
+        for (ItemStack item : items) {
+            if (ItemList.Paper_Printed_Pages.isStackEqual(item, false, true)) {
+                recipe = recipe.copy();
+                recipe.mCanBeBuffered = false;
+                recipe.mOutputs[0].setTagCompound(item.getTagCompound());
+            }
+        }
+        return recipe;
+    }
+}
diff --git a/src/main/java/gregtech/api/recipe/maps/AssemblyLineFrontend.java b/src/main/java/gregtech/api/recipe/maps/AssemblyLineFrontend.java
new file mode 100644
index 0000000000..3d56c96b82
--- /dev/null
+++ b/src/main/java/gregtech/api/recipe/maps/AssemblyLineFrontend.java
@@ -0,0 +1,76 @@
+package gregtech.api.recipe.maps;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Supplier;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import com.gtnewhorizons.modularui.api.math.Pos2d;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.common.widget.ProgressBar;
+
+import gregtech.api.gui.modularui.GT_UITextures;
+import gregtech.api.recipe.BasicUIPropertiesBuilder;
+import gregtech.api.recipe.NEIRecipePropertiesBuilder;
+import gregtech.api.recipe.RecipeMapFrontend;
+import gregtech.api.util.MethodsReturnNonnullByDefault;
+import gregtech.common.gui.modularui.UIHelper;
+
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+public class AssemblyLineFrontend extends RecipeMapFrontend {
+
+    public AssemblyLineFrontend(BasicUIPropertiesBuilder uiPropertiesBuilder,
+        NEIRecipePropertiesBuilder neiPropertiesBuilder) {
+        super(uiPropertiesBuilder, neiPropertiesBuilder);
+    }
+
+    @Override
+    public List<Pos2d> getItemInputPositions(int itemInputCount) {
+        return UIHelper.getGridPositions(itemInputCount, 16, 8, 4);
+    }
+
+    @Override
+    public List<Pos2d> getItemOutputPositions(int itemOutputCount) {
+        return Collections.singletonList(new Pos2d(142, 8));
+    }
+
+    @Override
+    public Pos2d getSpecialItemPosition() {
+        return new Pos2d(142, 44);
+    }
+
+    @Override
+    public List<Pos2d> getFluidInputPositions(int fluidInputCount) {
+        return UIHelper.getGridPositions(fluidInputCount, 106, 8, 1);
+    }
+
+    @Override
+    public void addProgressBar(ModularWindow.Builder builder, Supplier<Float> progressSupplier, Pos2d windowOffset) {
+        int bar1Width = 17;
+        int bar2Width = 18;
+        List<Supplier<Float>> splitProgress = splitProgress(progressSupplier, bar1Width, bar2Width);
+        builder.widget(
+            new ProgressBar().setTexture(GT_UITextures.PROGRESSBAR_ASSEMBLY_LINE_1, bar1Width)
+                .setDirection(ProgressBar.Direction.RIGHT)
+                .setProgress(splitProgress.get(0))
+                .setSynced(false, false)
+                .setPos(new Pos2d(88, 8).add(windowOffset))
+                .setSize(bar1Width, 72));
+        builder.widget(
+            new ProgressBar().setTexture(GT_UITextures.PROGRESSBAR_ASSEMBLY_LINE_2, bar2Width)
+                .setDirection(ProgressBar.Direction.RIGHT)
+                .setProgress(splitProgress.get(1))
+                .setSynced(false, false)
+                .setPos(new Pos2d(124, 8).add(windowOffset))
+                .setSize(bar2Width, 72));
+        builder.widget(
+            new ProgressBar().setTexture(GT_UITextures.PROGRESSBAR_ASSEMBLY_LINE_3, 18)
+                .setDirection(ProgressBar.Direction.UP)
+                .setProgress(progressSupplier)
+                .setSynced(false, false)
+                .setPos(new Pos2d(146, 26).add(windowOffset))
+                .setSize(10, 18));
+    }
+}
diff --git a/src/main/java/gregtech/api/recipe/maps/DistillationTowerFrontend.java b/src/main/java/gregtech/api/recipe/maps/DistillationTowerFrontend.java
new file mode 100644
index 0000000000..b061d10d55
--- /dev/null
+++ b/src/main/java/gregtech/api/recipe/maps/DistillationTowerFrontend.java
@@ -0,0 +1,38 @@
+package gregtech.api.recipe.maps;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import com.gtnewhorizons.modularui.api.math.Pos2d;
+
+import gregtech.api.recipe.BasicUIPropertiesBuilder;
+import gregtech.api.recipe.NEIRecipePropertiesBuilder;
+import gregtech.api.recipe.RecipeMapFrontend;
+import gregtech.api.util.MethodsReturnNonnullByDefault;
+
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+public class DistillationTowerFrontend extends RecipeMapFrontend {
+
+    public DistillationTowerFrontend(BasicUIPropertiesBuilder uiPropertiesBuilder,
+        NEIRecipePropertiesBuilder neiPropertiesBuilder) {
+        super(uiPropertiesBuilder, neiPropertiesBuilder);
+    }
+
+    @Override
+    public List<Pos2d> getItemOutputPositions(int itemOutputCount) {
+        return Collections.singletonList(new Pos2d(106, 62));
+    }
+
+    @Override
+    public List<Pos2d> getFluidOutputPositions(int fluidOutputCount) {
+        List<Pos2d> results = new ArrayList<>();
+        for (int i = 1; i < fluidOutputCount + 1; i++) {
+            results.add(new Pos2d(106 + (i % 3) * 18, 62 - (i / 3) * 18));
+        }
+        return results;
+    }
+}
diff --git a/src/main/java/gregtech/api/recipe/maps/FluidCannerBackend.java b/src/main/java/gregtech/api/recipe/maps/FluidCannerBackend.java
new file mode 100644
index 0000000000..e5681f59aa
--- /dev/null
+++ b/src/main/java/gregtech/api/recipe/maps/FluidCannerBackend.java
@@ -0,0 +1,73 @@
+package gregtech.api.recipe.maps;
+
+import javax.annotation.Nullable;
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.IFluidContainerItem;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.recipe.RecipeMapBackend;
+import gregtech.api.recipe.RecipeMapBackendPropertiesBuilder;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import gregtech.api.util.MethodsReturnNonnullByDefault;
+
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+public class FluidCannerBackend extends RecipeMapBackend {
+
+    public FluidCannerBackend(RecipeMapBackendPropertiesBuilder propertiesBuilder) {
+        super(propertiesBuilder);
+    }
+
+    @Override
+    protected GT_Recipe findFallback(ItemStack[] items, FluidStack[] fluids, @Nullable ItemStack specialSlot) {
+        if (items.length == 0 || items[0] == null) {
+            return null;
+        }
+
+        if (fluids.length > 0 && fluids[0] != null) {
+            ItemStack filledItem = GT_Utility.fillFluidContainer(fluids[0], items[0], false, true);
+            FluidStack fluidToTake = GT_Utility.getFluidForFilledItem(filledItem, true);
+            if (fluidToTake != null) {
+                return GT_Values.RA.stdBuilder()
+                    .itemInputs(GT_Utility.copyAmount(1, items[0]))
+                    .itemOutputs(filledItem)
+                    .fluidInputs(fluidToTake)
+                    .duration(Math.max(fluidToTake.amount / 64, 16))
+                    .eut(1)
+                    .noOptimize()
+                    .noBuffer()
+                    .build()
+                    .orElse(null);
+            }
+        }
+        FluidStack drainedFluid = GT_Utility.getFluidForFilledItem(items[0], true);
+        if (drainedFluid != null) {
+            return GT_Values.RA.stdBuilder()
+                .itemInputs(GT_Utility.copyAmount(1, items[0]))
+                .itemOutputs(GT_Utility.getContainerItem(items[0], true))
+                .fluidOutputs(drainedFluid)
+                .duration(Math.max(drainedFluid.amount / 64, 16))
+                .eut(1)
+                .noBuffer()
+                .build()
+                .orElse(null);
+        }
+        return null;
+    }
+
+    @Override
+    public boolean containsInput(ItemStack item) {
+        return super.containsInput(item) || (item.getItem() instanceof IFluidContainerItem
+            && ((IFluidContainerItem) item.getItem()).getCapacity(item) > 0);
+    }
+
+    @Override
+    public boolean containsInput(Fluid fluid) {
+        return true;
+    }
+}
diff --git a/src/main/java/gregtech/api/recipe/maps/FluidOnlyFrontend.java b/src/main/java/gregtech/api/recipe/maps/FluidOnlyFrontend.java
new file mode 100644
index 0000000000..8b37f6388c
--- /dev/null
+++ b/src/main/java/gregtech/api/recipe/maps/FluidOnlyFrontend.java
@@ -0,0 +1,33 @@
+package gregtech.api.recipe.maps;
+
+import java.util.List;
+
+import com.gtnewhorizons.modularui.api.math.Pos2d;
+
+import gregtech.api.recipe.BasicUIPropertiesBuilder;
+import gregtech.api.recipe.NEIRecipePropertiesBuilder;
+import gregtech.api.recipe.RecipeMapFrontend;
+import gregtech.api.util.MethodsReturnNonnullByDefault;
+import gregtech.common.gui.modularui.UIHelper;
+
+/**
+ * Display fluids where normally items are placed on NEI.
+ */
+@MethodsReturnNonnullByDefault
+public class FluidOnlyFrontend extends RecipeMapFrontend {
+
+    public FluidOnlyFrontend(BasicUIPropertiesBuilder uiPropertiesBuilder,
+        NEIRecipePropertiesBuilder neiPropertiesBuilder) {
+        super(uiPropertiesBuilder, neiPropertiesBuilder);
+    }
+
+    @Override
+    public List<Pos2d> getFluidInputPositions(int fluidInputCount) {
+        return UIHelper.getItemInputPositions(fluidInputCount);
+    }
+
+    @Override
+    public List<Pos2d> getFluidOutputPositions(int fluidOutputCount) {
+        return UIHelper.getItemOutputPositions(fluidOutputCount);
+    }
+}
diff --git a/src/main/java/gregtech/api/recipe/maps/FormingPressBackend.java b/src/main/java/gregtech/api/recipe/maps/FormingPressBackend.java
new file mode 100644
index 0000000000..ce3ea3e89c
--- /dev/null
+++ b/src/main/java/gregtech/api/recipe/maps/FormingPressBackend.java
@@ -0,0 +1,92 @@
+package gregtech.api.recipe.maps;
+
+import javax.annotation.Nullable;
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.fluids.FluidStack;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.recipe.RecipeMapBackend;
+import gregtech.api.recipe.RecipeMapBackendPropertiesBuilder;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import gregtech.api.util.MethodsReturnNonnullByDefault;
+
+/**
+ * Special Class for Forming Press handling.
+ */
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+public class FormingPressBackend extends RecipeMapBackend {
+
+    public FormingPressBackend(RecipeMapBackendPropertiesBuilder propertiesBuilder) {
+        super(propertiesBuilder);
+    }
+
+    @Override
+    protected GT_Recipe modifyFoundRecipe(GT_Recipe recipe, ItemStack[] items, FluidStack[] fluids,
+        @Nullable ItemStack specialSlot) {
+        for (ItemStack mold : items) {
+            if (ItemList.Shape_Mold_Credit.isStackEqual(mold, false, true)) {
+                NBTTagCompound nbt = mold.getTagCompound();
+                if (nbt == null) nbt = new NBTTagCompound();
+                if (!nbt.hasKey("credit_security_id")) nbt.setLong("credit_security_id", System.nanoTime());
+                mold.setTagCompound(nbt);
+
+                recipe = recipe.copy();
+                recipe.mCanBeBuffered = false;
+                recipe.mOutputs[0].setTagCompound(nbt);
+                return recipe;
+            }
+        }
+        return recipe;
+    }
+
+    @Override
+    protected GT_Recipe findFallback(ItemStack[] items, FluidStack[] fluids, @Nullable ItemStack specialSlot) {
+        if (items.length < 2) {
+            return null;
+        }
+        return findRenamingRecipe(items);
+    }
+
+    @Nullable
+    private GT_Recipe findRenamingRecipe(ItemStack[] inputs) {
+        ItemStack mold = findNameMoldIndex(inputs);
+        if (mold == null) return null;
+        ItemStack input = findStackToRename(inputs, mold);
+        if (input == null) return null;
+        ItemStack output = GT_Utility.copyAmount(1, input);
+        if (output == null) return null;
+        output.setStackDisplayName(mold.getDisplayName());
+        return GT_Values.RA.stdBuilder()
+            .itemInputs(GT_Utility.copyAmount(0, mold), GT_Utility.copyAmount(1, input))
+            .itemOutputs(output)
+            .duration(128)
+            .eut(8)
+            .noBuffer()
+            .nbtSensitive()
+            .build()
+            .orElse(null);
+    }
+
+    @Nullable
+    private ItemStack findNameMoldIndex(ItemStack[] inputs) {
+        for (ItemStack stack : inputs) {
+            if (ItemList.Shape_Mold_Name.isStackEqual(stack, false, true)) return stack;
+        }
+        return null;
+    }
+
+    @Nullable
+    private ItemStack findStackToRename(ItemStack[] inputs, ItemStack mold) {
+        for (ItemStack stack : inputs) {
+            if (stack == mold || stack == null) continue;
+            return stack;
+        }
+        return null;
+    }
+}
diff --git a/src/main/java/gregtech/api/recipe/maps/FuelBackend.java b/src/main/java/gregtech/api/recipe/maps/FuelBackend.java
new file mode 100644
index 0000000000..49c989e174
--- /dev/null
+++ b/src/main/java/gregtech/api/recipe/maps/FuelBackend.java
@@ -0,0 +1,75 @@
+package gregtech.api.recipe.maps;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.annotation.Nullable;
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+
+import gregtech.api.recipe.RecipeMapBackend;
+import gregtech.api.recipe.RecipeMapBackendPropertiesBuilder;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_RecipeBuilder;
+import gregtech.api.util.GT_Utility;
+import gregtech.api.util.MethodsReturnNonnullByDefault;
+
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+public class FuelBackend extends RecipeMapBackend {
+
+    private final Map<String, GT_Recipe> recipesByFluidInput = new HashMap<>();
+
+    public FuelBackend(RecipeMapBackendPropertiesBuilder propertiesBuilder) {
+        super(propertiesBuilder.disableOptimize());
+    }
+
+    @Override
+    protected Collection<GT_Recipe> doAdd(GT_RecipeBuilder builder) {
+        if (builder.getDuration() == -1) {
+            builder.duration(0);
+        }
+        if (builder.getEUt() == -1) {
+            builder.eut(0);
+        }
+        return super.doAdd(builder);
+    }
+
+    @Override
+    public GT_Recipe compileRecipe(GT_Recipe recipe) {
+        super.compileRecipe(recipe);
+        if (recipe.mInputs != null && GT_Utility.getNonnullElementCount(recipe.mInputs) == 1
+            && (recipe.mFluidInputs == null || GT_Utility.getNonnullElementCount(recipe.mFluidInputs) == 0)) {
+            FluidStack fluidStack = GT_Utility.getFluidForFilledItem(recipe.mInputs[0], true);
+            if (fluidStack != null) {
+                fluidStack.amount = 0;
+                recipesByFluidInput.put(
+                    fluidStack.getFluid()
+                        .getName(),
+                    recipe);
+            }
+        } else if ((recipe.mInputs == null || GT_Utility.getNonnullElementCount(recipe.mInputs) == 0)
+            && recipe.mFluidInputs != null
+            && GT_Utility.getNonnullElementCount(recipe.mFluidInputs) >= 1
+            && recipe.mFluidInputs[0] != null) {
+                recipesByFluidInput.put(
+                    recipe.mFluidInputs[0].getFluid()
+                        .getName(),
+                    recipe);
+            }
+        return recipe;
+    }
+
+    @Nullable
+    public GT_Recipe findFuel(FluidStack fluidStack) {
+        return findFuel(fluidStack.getFluid());
+    }
+
+    @Nullable
+    public GT_Recipe findFuel(Fluid fluid) {
+        return recipesByFluidInput.get(fluid.getName());
+    }
+}
diff --git a/src/main/java/gregtech/api/recipe/maps/FurnaceBackend.java b/src/main/java/gregtech/api/recipe/maps/FurnaceBackend.java
new file mode 100644
index 0000000000..c4095eeb4e
--- /dev/null
+++ b/src/main/java/gregtech/api/recipe/maps/FurnaceBackend.java
@@ -0,0 +1,52 @@
+package gregtech.api.recipe.maps;
+
+import javax.annotation.Nullable;
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.recipe.RecipeMapBackendPropertiesBuilder;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import gregtech.api.util.MethodsReturnNonnullByDefault;
+
+/**
+ * Special Class for Furnace Recipe handling.
+ */
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+public class FurnaceBackend extends NonGTBackend {
+
+    public FurnaceBackend(RecipeMapBackendPropertiesBuilder propertiesBuilder) {
+        super(propertiesBuilder);
+    }
+
+    @Override
+    protected GT_Recipe overwriteFindRecipe(ItemStack[] items, FluidStack[] fluids, @Nullable ItemStack specialSlot,
+        @Nullable GT_Recipe cachedRecipe) {
+        if (items.length == 0 || items[0] == null) {
+            return null;
+        }
+        if (cachedRecipe != null && cachedRecipe.isRecipeInputEqual(false, true, fluids, items)) {
+            return cachedRecipe;
+        }
+        ItemStack output = GT_ModHandler.getSmeltingOutput(items[0], false, null);
+        return output == null ? null
+            : GT_Values.RA.stdBuilder()
+                .itemInputs(GT_Utility.copyAmount(1, items[0]))
+                .itemOutputs(output)
+                .duration(128)
+                .eut(4)
+                .noOptimize()
+                .build()
+                .orElse(null);
+    }
+
+    @Override
+    public boolean containsInput(ItemStack item) {
+        return GT_ModHandler.getSmeltingOutput(item, false, null) != null;
+    }
+}
diff --git a/src/main/java/gregtech/api/recipe/maps/LargeBoilerFuelBackend.java b/src/main/java/gregtech/api/recipe/maps/LargeBoilerFuelBackend.java
new file mode 100644
index 0000000000..53152312f4
--- /dev/null
+++ b/src/main/java/gregtech/api/recipe/maps/LargeBoilerFuelBackend.java
@@ -0,0 +1,132 @@
+package gregtech.api.recipe.maps;
+
+import java.util.Arrays;
+import java.util.List;
+
+import javax.annotation.Nullable;
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.ConfigCategories;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.recipe.RecipeMapBackend;
+import gregtech.api.recipe.RecipeMapBackendPropertiesBuilder;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.MethodsReturnNonnullByDefault;
+
+@SuppressWarnings({ "unused", "UnusedReturnValue" })
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+public class LargeBoilerFuelBackend extends RecipeMapBackend {
+
+    private static boolean addedGeneralDesc = false;
+
+    private static final List<String> ALLOWED_SOLID_FUELS = Arrays.asList(
+        GregTech_API.sMachineFile.mConfig.getStringList(
+            "LargeBoiler.allowedFuels",
+            ConfigCategories.machineconfig.toString(),
+            new String[] { "gregtech:gt.blockreinforced:6", "gregtech:gt.blockreinforced:7" },
+            "Allowed fuels for the Large Titanium Boiler and Large Tungstensteel Boiler"));
+
+    public LargeBoilerFuelBackend(RecipeMapBackendPropertiesBuilder propertiesBuilder) {
+        super(propertiesBuilder);
+    }
+
+    public static boolean isAllowedSolidFuel(ItemStack stack) {
+        return isAllowedSolidFuel(Item.itemRegistry.getNameForObject(stack.getItem()), stack.getItemDamage());
+    }
+
+    public static boolean isAllowedSolidFuel(String itemRegistryName, int meta) {
+        return ALLOWED_SOLID_FUELS.contains(itemRegistryName + ":" + meta);
+    }
+
+    public static boolean addAllowedSolidFuel(ItemStack stack) {
+        return addAllowedSolidFuel(Item.itemRegistry.getNameForObject(stack.getItem()), stack.getItemDamage());
+    }
+
+    public static boolean addAllowedSolidFuel(String itemregistryName, int meta) {
+        return ALLOWED_SOLID_FUELS.add(itemregistryName + ":" + meta);
+    }
+
+    public GT_Recipe addDenseLiquidRecipe(GT_Recipe recipe) {
+        return addRecipe(recipe, ((double) recipe.mSpecialValue) / 10, false);
+    }
+
+    public GT_Recipe addDieselRecipe(GT_Recipe recipe) {
+        return addRecipe(recipe, ((double) recipe.mSpecialValue) / 40, false);
+    }
+
+    public void addSolidRecipes(ItemStack... itemStacks) {
+        for (ItemStack itemStack : itemStacks) {
+            addSolidRecipe(itemStack);
+        }
+    }
+
+    @Nullable
+    public GT_Recipe addSolidRecipe(@Nullable ItemStack fuelItemStack) {
+        if (fuelItemStack == null) {
+            return null;
+        }
+        if (!addedGeneralDesc) {
+            GT_Values.RA.stdBuilder()
+                .duration(1)
+                .eut(1)
+                .specialValue(1)
+                .setNEIDesc(
+                    "Not all solid fuels are listed.",
+                    "Any item that burns in a",
+                    "vanilla furnace will burn in",
+                    "a Large Bronze or Steel Boiler.")
+                .build()
+                .map(this::compileRecipe);
+            addedGeneralDesc = true;
+        }
+
+        String registryName = Item.itemRegistry.getNameForObject(fuelItemStack.getItem());
+        boolean isHighTierAllowed = ALLOWED_SOLID_FUELS.contains(registryName + ":" + fuelItemStack.getItemDamage());
+        return GT_Values.RA.stdBuilder()
+            .itemInputs(fuelItemStack)
+            .duration(1)
+            .eut(0)
+            .specialValue(GT_ModHandler.getFuelValue(fuelItemStack) / 1600)
+            .build()
+            .map(r -> addRecipe(r, ((double) GT_ModHandler.getFuelValue(fuelItemStack)) / 1600, isHighTierAllowed))
+            .orElse(null);
+    }
+
+    private GT_Recipe addRecipe(GT_Recipe recipe, double baseBurnTime, boolean isHighTierAllowed) {
+        // Some recipes will have a burn time like 15.9999999 and % always rounds down
+        double floatErrorCorrection = 0.0001;
+
+        double bronzeBurnTime = baseBurnTime * 2 + floatErrorCorrection;
+        bronzeBurnTime -= bronzeBurnTime % 0.05;
+        double steelBurnTime = baseBurnTime + floatErrorCorrection;
+        steelBurnTime -= steelBurnTime % 0.05;
+        double titaniumBurnTime = baseBurnTime * 0.3 + floatErrorCorrection;
+        titaniumBurnTime -= titaniumBurnTime % 0.05;
+        double tungstensteelBurnTime = baseBurnTime * 0.15 + floatErrorCorrection;
+        tungstensteelBurnTime -= tungstensteelBurnTime % 0.05;
+
+        if (isHighTierAllowed) {
+            recipe.setNeiDesc(
+                "Burn time in seconds:",
+                String.format("Bronze Boiler: %.4f", bronzeBurnTime),
+                String.format("Steel Boiler: %.4f", steelBurnTime),
+                String.format("Titanium Boiler: %.4f", titaniumBurnTime),
+                String.format("Tungstensteel Boiler: %.4f", tungstensteelBurnTime));
+        } else {
+            recipe.setNeiDesc(
+                "Burn time in seconds:",
+                String.format("Bronze Boiler: %.4f", bronzeBurnTime),
+                String.format("Steel Boiler: %.4f", steelBurnTime),
+                "Titanium Boiler: Not allowed",
+                "Tungstenst. Boiler: Not allowed");
+        }
+
+        return compileRecipe(recipe);
+    }
+}
diff --git a/src/main/java/gregtech/api/recipe/maps/LargeBoilerFuelFrontend.java b/src/main/java/gregtech/api/recipe/maps/LargeBoilerFuelFrontend.java
new file mode 100644
index 0000000000..dbe7f6fe2f
--- /dev/null
+++ b/src/main/java/gregtech/api/recipe/maps/LargeBoilerFuelFrontend.java
@@ -0,0 +1,25 @@
+package gregtech.api.recipe.maps;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import gregtech.api.recipe.BasicUIPropertiesBuilder;
+import gregtech.api.recipe.NEIRecipePropertiesBuilder;
+import gregtech.api.recipe.RecipeMapFrontend;
+import gregtech.api.util.MethodsReturnNonnullByDefault;
+import gregtech.nei.RecipeDisplayInfo;
+
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+public class LargeBoilerFuelFrontend extends RecipeMapFrontend {
+
+    public LargeBoilerFuelFrontend(BasicUIPropertiesBuilder uiPropertiesBuilder,
+        NEIRecipePropertiesBuilder neiPropertiesBuilder) {
+        super(uiPropertiesBuilder, neiPropertiesBuilder);
+    }
+
+    @Override
+    protected void drawEnergyInfo(RecipeDisplayInfo recipeInfo) {}
+
+    @Override
+    protected void drawDurationInfo(RecipeDisplayInfo recipeInfo) {}
+}
diff --git a/src/main/java/gregtech/api/recipe/maps/LargeNEIFrontend.java b/src/main/java/gregtech/api/recipe/maps/LargeNEIFrontend.java
new file mode 100644
index 0000000000..70184a83de
--- /dev/null
+++ b/src/main/java/gregtech/api/recipe/maps/LargeNEIFrontend.java
@@ -0,0 +1,65 @@
+package gregtech.api.recipe.maps;
+
+import java.util.List;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import com.gtnewhorizons.modularui.api.math.Pos2d;
+import com.gtnewhorizons.modularui.api.math.Size;
+