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, 145 insertions, 0 deletions

diff --git a/src/main/java/gregtech/api/recipe/maps/MicrowaveBackend.java b/src/main/java/gregtech/api/recipe/maps/MicrowaveBackend.java
new file mode 100644
index 0000000000..53623cb0c7
--- /dev/null
+++ b/src/main/java/gregtech/api/recipe/maps/MicrowaveBackend.java
@@ -0,0 +1,145 @@
+package gregtech.api.recipe.maps;
+
+import static gregtech.api.enums.GT_Values.W;
+import static gregtech.api.util.GT_RecipeConstants.EXPLODE;
+import static gregtech.api.util.GT_RecipeConstants.ON_FIRE;
+
+import javax.annotation.Nullable;
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntityFurnace;
+import net.minecraftforge.fluids.FluidStack;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.SubTag;
+import gregtech.api.objects.ItemData;
+import gregtech.api.objects.MaterialStack;
+import gregtech.api.recipe.RecipeMapBackendPropertiesBuilder;
+import gregtech.api.util.GT_Log;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_RecipeBuilder;
+import gregtech.api.util.GT_Utility;
+import gregtech.api.util.MethodsReturnNonnullByDefault;
+
+/**
+ * Special Class for Microwave Recipe handling.
+ */
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+public class MicrowaveBackend extends NonGTBackend {
+
+    public MicrowaveBackend(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);
+
+        if (GT_Utility.areStacksEqual(items[0], new ItemStack(Items.book, 1, W))) {
+            return GT_Values.RA.stdBuilder()
+                .itemInputs(GT_Utility.copyAmount(1, items[0]))
+                .itemOutputs(GT_Utility.getWrittenBook("Manual_Microwave", ItemList.Book_Written_03.get(1)))
+                .duration(32)
+                .eut(4)
+                .noOptimize()
+                .build()
+                .orElse(null);
+        }
+
+        // Check Container Item of Input since it is around the Input, then the Input itself, then Container Item of
+        // Output and last check the Output itself
+        for (ItemStack item : new ItemStack[] { GT_Utility.getContainerItem(items[0], true), items[0],
+            GT_Utility.getContainerItem(output, true), output }) {
+            if (item == null) continue;
+            if (GT_Utility.areStacksEqual(item, new ItemStack(Blocks.netherrack, 1, W), true)
+                || GT_Utility.areStacksEqual(item, new ItemStack(Blocks.tnt, 1, W), true)
+                || GT_Utility.areStacksEqual(item, new ItemStack(Items.egg, 1, W), true)
+                || GT_Utility.areStacksEqual(item, new ItemStack(Items.firework_charge, 1, W), true)
+                || GT_Utility.areStacksEqual(item, new ItemStack(Items.fireworks, 1, W), true)
+                || GT_Utility.areStacksEqual(item, new ItemStack(Items.fire_charge, 1, W), true)) {
+                GT_Log.exp
+                    .println("Microwave Explosion due to TNT || EGG || FIREWORKCHARGE || FIREWORK || FIRE CHARGE");
+                return GT_RecipeBuilder.empty()
+                    .metadata(EXPLODE, true)
+                    .build()
+                    .orElse(null);
+            }
+
+            ItemData itemData = GT_OreDictUnificator.getItemData(item);
+            if (itemData != null) {
+                if (itemData.mMaterial != null && itemData.mMaterial.mMaterial != null) {
+                    if (itemData.mMaterial.mMaterial.contains(SubTag.METAL)
+                        || itemData.mMaterial.mMaterial.contains(SubTag.EXPLOSIVE)) {
+                        GT_Log.exp.println("Microwave Explosion due to METAL insertion");
+                        return GT_RecipeBuilder.empty()
+                            .metadata(EXPLODE, true)
+                            .build()
+                            .orElse(null);
+                    }
+                    if (itemData.mMaterial.mMaterial.contains(SubTag.FLAMMABLE)) {
+                        GT_Log.exp.println("Microwave INFLAMMATION due to FLAMMABLE insertion");
+                        return GT_RecipeBuilder.empty()
+                            .metadata(ON_FIRE, true)
+                            .build()
+                            .orElse(null);
+                    }
+                }
+                for (MaterialStack materialStack : itemData.mByProducts) {
+                    if (materialStack == null) continue;
+                    if (materialStack.mMaterial.contains(SubTag.METAL)
+                        || materialStack.mMaterial.contains(SubTag.EXPLOSIVE)) {
+                        GT_Log.exp.println("Microwave Explosion due to METAL insertion");
+                        return GT_RecipeBuilder.empty()
+                            .metadata(EXPLODE, true)
+                            .build()
+                            .orElse(null);
+                    }
+                    if (materialStack.mMaterial.contains(SubTag.FLAMMABLE)) {
+                        GT_Log.exp.println("Microwave INFLAMMATION due to FLAMMABLE insertion");
+                        return GT_RecipeBuilder.empty()
+                            .metadata(ON_FIRE, true)
+                            .build()
+                            .orElse(null);
+                    }
+                }
+            }
+            if (TileEntityFurnace.getItemBurnTime(item) > 0) {
+                GT_Log.exp.println("Microwave INFLAMMATION due to BURNABLE insertion");
+                return GT_RecipeBuilder.empty()
+                    .metadata(ON_FIRE, true)
+                    .build()
+                    .orElse(null);
+            }
+        }
+
+        return output == null ? null
+            : GT_Values.RA.stdBuilder()
+                .itemInputs(GT_Utility.copyAmount(1, items[0]))
+                .itemOutputs(output)
+                .duration(32)
+                .eut(4)
+                .noOptimize()
+                .build()
+                .orElse(null);
+    }
+
+    @Override
+    public boolean containsInput(ItemStack item) {
+        return GT_ModHandler.getSmeltingOutput(item, false, null) != null;
+    }
+}