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>

1 files changed, 132 insertions, 0 deletions

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);
+    }
+}