From f74c7cc297d1d19d38a19683cd277ad9ce605d3a Mon Sep 17 00:00:00 2001 From: miozune Date: Mon, 4 Dec 2023 05:34:27 +0900 Subject: 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> --- .../postload/GT_ExtremeDieselFuelLoader.java | 22 - .../gregtech/loaders/postload/GT_PostLoad.java | 221 ++-- .../postload/GT_ProcessingArrayRecipeLoader.java | 92 +- .../loaders/postload/GT_UUMRecipeLoader.java | 7 - .../postload/chains/GT_BauxiteRefineChain.java | 50 +- .../loaders/postload/chains/GT_NaniteChain.java | 4 +- .../postload/chains/GT_PCBFactoryRecipes.java | 487 ++++---- .../postload/recipes/AlloySmelterRecipes.java | 12 +- .../postload/recipes/ArcFurnaceRecipes.java | 47 + .../loaders/postload/recipes/AssemblerRecipes.java | 1260 ++++++++++---------- .../loaders/postload/recipes/AutoclaveRecipes.java | 48 +- .../loaders/postload/recipes/BenderRecipes.java | 88 +- .../postload/recipes/BlastFurnaceRecipes.java | 130 +- .../loaders/postload/recipes/BreweryRecipes.java | 118 +- .../loaders/postload/recipes/CannerRecipes.java | 14 +- .../postload/recipes/CentrifugeRecipes.java | 182 ++- .../postload/recipes/ChemicalBathRecipes.java | 82 +- .../loaders/postload/recipes/ChemicalRecipes.java | 410 +++---- .../postload/recipes/CircuitAssemblerRecipes.java | 42 +- .../postload/recipes/CompressorRecipes.java | 36 +- .../postload/recipes/CropProcessingRecipes.java | 8 +- .../loaders/postload/recipes/CuttingRecipes.java | 14 +- .../postload/recipes/DistilleryRecipes.java | 140 +-- .../postload/recipes/ElectrolyzerRecipes.java | 62 +- .../recipes/ElectromagneticSeparatorRecipes.java | 6 +- .../loaders/postload/recipes/ExtractorRecipes.java | 4 +- .../loaders/postload/recipes/ExtruderRecipes.java | 6 +- .../loaders/postload/recipes/FermenterRecipes.java | 80 +- .../postload/recipes/FluidCannerRecipes.java | 22 +- .../postload/recipes/FluidExtractorRecipes.java | 171 +-- .../postload/recipes/FluidHeaterRecipes.java | 20 +- .../postload/recipes/FluidSolidifierRecipes.java | 130 +- .../postload/recipes/ForgeHammerRecipes.java | 38 +- .../postload/recipes/FormingPressRecipes.java | 40 +- .../loaders/postload/recipes/FuelRecipes.java | 34 - .../postload/recipes/FusionReactorRecipes.java | 72 +- .../recipes/ImplosionCompressorRecipes.java | 14 +- .../postload/recipes/LaserEngraverRecipes.java | 12 +- .../loaders/postload/recipes/LatheRecipes.java | 6 +- .../postload/recipes/MatterAmplifierRecipes.java | 6 +- .../loaders/postload/recipes/MixerRecipes.java | 302 ++--- .../loaders/postload/recipes/PackagerRecipes.java | 10 +- .../postload/recipes/PlasmaForgeRecipes.java | 6 +- .../loaders/postload/recipes/PrinterRecipes.java | 12 +- .../loaders/postload/recipes/Pulverizer.java | 128 +- .../loaders/postload/recipes/PyrolyseRecipes.java | 26 +- .../loaders/postload/recipes/SifterRecipes.java | 6 +- .../loaders/postload/recipes/SlicerRecipes.java | 10 +- .../postload/recipes/ThermalCentrifugeRecipes.java | 4 +- .../recipes/TranscendentPlasmaMixerRecipes.java | 14 +- .../postload/recipes/VacuumFreezerRecipes.java | 100 +- .../loaders/postload/recipes/WiremillRecipes.java | 18 +- 52 files changed, 2467 insertions(+), 2406 deletions(-) delete mode 100644 src/main/java/gregtech/loaders/postload/GT_ExtremeDieselFuelLoader.java delete mode 100644 src/main/java/gregtech/loaders/postload/GT_UUMRecipeLoader.java (limited to 'src/main/java/gregtech/loaders/postload') diff --git a/src/main/java/gregtech/loaders/postload/GT_ExtremeDieselFuelLoader.java b/src/main/java/gregtech/loaders/postload/GT_ExtremeDieselFuelLoader.java deleted file mode 100644 index 8ff392e817..0000000000 --- a/src/main/java/gregtech/loaders/postload/GT_ExtremeDieselFuelLoader.java +++ /dev/null @@ -1,22 +0,0 @@ -package gregtech.loaders.postload; - -import gregtech.api.util.GT_Log; -import gregtech.api.util.GT_Recipe; - -public class GT_ExtremeDieselFuelLoader implements Runnable { - - @Override - public void run() { - GT_Log.out.println("GT_Mod: Adding extreme diesel fuel."); - int added = 0; - for (GT_Recipe aRecipe : GT_Recipe.GT_Recipe_Map.sDieselFuels.mRecipeList) { - if (aRecipe.mSpecialValue < 1500) { - continue; - } - - added += 1; - GT_Recipe.GT_Recipe_Map.sExtremeDieselFuels.add(aRecipe); - } - GT_Log.out.println("GT_Mod: Added " + added + " kind(s) of extreme diesel fuel."); - } -} diff --git a/src/main/java/gregtech/loaders/postload/GT_PostLoad.java b/src/main/java/gregtech/loaders/postload/GT_PostLoad.java index 5bf025cf20..5ec4391d71 100644 --- a/src/main/java/gregtech/loaders/postload/GT_PostLoad.java +++ b/src/main/java/gregtech/loaders/postload/GT_PostLoad.java @@ -1,12 +1,11 @@ package gregtech.loaders.postload; -import static gregtech.api.enums.GT_Values.VP; import static gregtech.api.enums.Mods.Forestry; import static gregtech.api.enums.Mods.GalacticraftCore; import static gregtech.api.enums.Mods.GalacticraftMars; import static gregtech.api.enums.Mods.GalaxySpace; import static gregtech.api.enums.Mods.Thaumcraft; -import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sFluidCannerRecipes; +import static gregtech.api.recipe.RecipeMaps.fluidCannerRecipes; import static gregtech.api.util.GT_RecipeBuilder.TICKS; import java.lang.reflect.InvocationTargetException; @@ -38,13 +37,15 @@ import gregtech.api.enums.ItemList; import gregtech.api.enums.Materials; import gregtech.api.enums.OrePrefixes; import gregtech.api.enums.SubTag; +import gregtech.api.enums.TierEU; +import gregtech.api.recipe.RecipeMaps; import gregtech.api.util.GT_CLS_Compat; import gregtech.api.util.GT_Forestry_Compat; 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_RecipeConstants; import gregtech.api.util.GT_RecipeRegistrator; import gregtech.api.util.GT_Utility; import gregtech.common.items.GT_MetaGenerated_Tool_01; @@ -95,20 +96,12 @@ public class GT_PostLoad { .findAny() .ifPresent(e -> aCompressorRecipeList.remove(e.getKey())); // Add default IC2 recipe to GT + GT_ModHandler.addIC2RecipesToGT(aMaceratorRecipeList, RecipeMaps.maceratorRecipes, true, true, true); + GT_ModHandler.addIC2RecipesToGT(aCompressorRecipeList, RecipeMaps.compressorRecipes, true, true, true); + GT_ModHandler.addIC2RecipesToGT(aExtractorRecipeList, RecipeMaps.extractorRecipes, true, true, true); + GT_ModHandler.addIC2RecipesToGT(aOreWashingRecipeList, RecipeMaps.oreWasherRecipes, false, true, true); GT_ModHandler - .addIC2RecipesToGT(aMaceratorRecipeList, GT_Recipe.GT_Recipe_Map.sMaceratorRecipes, true, true, true); - GT_ModHandler - .addIC2RecipesToGT(aCompressorRecipeList, GT_Recipe.GT_Recipe_Map.sCompressorRecipes, true, true, true); - GT_ModHandler - .addIC2RecipesToGT(aExtractorRecipeList, GT_Recipe.GT_Recipe_Map.sExtractorRecipes, true, true, true); - GT_ModHandler - .addIC2RecipesToGT(aOreWashingRecipeList, GT_Recipe.GT_Recipe_Map.sOreWasherRecipes, false, true, true); - GT_ModHandler.addIC2RecipesToGT( - aThermalCentrifugeRecipeList, - GT_Recipe.GT_Recipe_Map.sThermalCentrifugeRecipes, - true, - true, - true); + .addIC2RecipesToGT(aThermalCentrifugeRecipeList, RecipeMaps.thermalCentrifugeRecipes, true, true, true); // noinspection UnstableApiUsage// Stable enough for this project GT_Mod.GT_FML_LOGGER.info("IC2 Removal (" + stopwatch.stop() + "). Have a Cake."); } @@ -125,7 +118,7 @@ public class GT_PostLoad { .fluidInputs(tData.fluid) .duration((tData.fluid.amount / 62) * TICKS) .eut(1) - .addTo(sFluidCannerRecipes); + .addTo(fluidCannerRecipes); GT_RecipeBuilder builder = GT_Values.RA.stdBuilder() .itemInputs(tData.filledContainer); if (tData.emptyContainer.stackSize > 0) { @@ -134,7 +127,7 @@ public class GT_PostLoad { builder.fluidOutputs(tData.fluid) .duration((tData.fluid.amount / 62) * TICKS) .eut(1) - .addTo(sFluidCannerRecipes); + .addTo(fluidCannerRecipes); } } @@ -146,7 +139,7 @@ public class GT_PostLoad { } if (ItemList.IC2_Crop_Seeds.get(1L) != null) { - GT_Recipe.GT_Recipe_Map.sScannerFakeRecipes.addFakeRecipe( + RecipeMaps.scannerFakeRecipes.addFakeRecipe( false, new ItemStack[] { ItemList.IC2_Crop_Seeds.getWildcard(1L) }, new ItemStack[] { ItemList.IC2_Crop_Seeds.getWithName(1L, "Scanned Seeds") }, @@ -157,7 +150,7 @@ public class GT_PostLoad { 8, 0); } - GT_Recipe.GT_Recipe_Map.sScannerFakeRecipes.addFakeRecipe( + RecipeMaps.scannerFakeRecipes.addFakeRecipe( false, new ItemStack[] { new ItemStack(Items.written_book, 1, 32767) }, new ItemStack[] { ItemList.Tool_DataStick.getWithName(1L, "Scanned Book Data") }, @@ -167,7 +160,7 @@ public class GT_PostLoad { 128, 30, 0); - GT_Recipe.GT_Recipe_Map.sScannerFakeRecipes.addFakeRecipe( + RecipeMaps.scannerFakeRecipes.addFakeRecipe( false, new ItemStack[] { new ItemStack(Items.filled_map, 1, 32767) }, new ItemStack[] { ItemList.Tool_DataStick.getWithName(1L, "Scanned Map Data") }, @@ -177,7 +170,7 @@ public class GT_PostLoad { 128, 30, 0); - GT_Recipe.GT_Recipe_Map.sScannerFakeRecipes.addFakeRecipe( + RecipeMaps.scannerFakeRecipes.addFakeRecipe( false, new ItemStack[] { ItemList.Tool_DataOrb.getWithName(1L, "Orb to overwrite") }, new ItemStack[] { ItemList.Tool_DataOrb.getWithName(1L, "Copy of the Orb") }, @@ -187,7 +180,7 @@ public class GT_PostLoad { 512, 30, 0); - GT_Recipe.GT_Recipe_Map.sScannerFakeRecipes.addFakeRecipe( + RecipeMaps.scannerFakeRecipes.addFakeRecipe( false, new ItemStack[] { ItemList.Tool_DataStick.getWithName(1L, "Stick to overwrite") }, new ItemStack[] { ItemList.Tool_DataStick.getWithName(1L, "Copy of the Stick") }, @@ -197,7 +190,7 @@ public class GT_PostLoad { 128, 30, 0); - GT_Recipe.GT_Recipe_Map.sScannerFakeRecipes.addFakeRecipe( + RecipeMaps.scannerFakeRecipes.addFakeRecipe( false, new ItemStack[] { ItemList.Tool_DataStick.getWithName(1L, "Raw Prospection Data") }, new ItemStack[] { ItemList.Tool_DataStick.getWithName(1L, "Analyzed Prospection Data") }, @@ -208,7 +201,7 @@ public class GT_PostLoad { 30, 0); if (GalacticraftCore.isModLoaded()) { - GT_Recipe.GT_Recipe_Map.sScannerFakeRecipes.addFakeRecipe( + RecipeMaps.scannerFakeRecipes.addFakeRecipe( false, new ItemStack[] { Objects .requireNonNull(GT_ModHandler.getModItem(GalacticraftCore.ID, "item.schematic", 1, Short.MAX_VALUE)) @@ -220,7 +213,7 @@ public class GT_PostLoad { 36000, 480, 0); - if (GalacticraftMars.isModLoaded()) GT_Recipe.GT_Recipe_Map.sScannerFakeRecipes.addFakeRecipe( + if (GalacticraftMars.isModLoaded()) RecipeMaps.scannerFakeRecipes.addFakeRecipe( false, new ItemStack[] { Objects .requireNonNull(GT_ModHandler.getModItem(GalacticraftMars.ID, "item.schematic", 1, Short.MAX_VALUE)) @@ -234,7 +227,7 @@ public class GT_PostLoad { 0); if (GalaxySpace.isModLoaded()) { for (int i = 4; i < 9; i++) { - GT_Recipe.GT_Recipe_Map.sScannerFakeRecipes.addFakeRecipe( + RecipeMaps.scannerFakeRecipes.addFakeRecipe( false, new ItemStack[] { GT_ModHandler.getModItem(GalaxySpace.ID, "item.SchematicTier" + i, 1) .setStackDisplayName("Any Schematic") }, @@ -254,73 +247,66 @@ public class GT_PostLoad { if ((tMaterial.mElement != null) && (!tMaterial.mElement.mIsIsotope) && (tMaterial != Materials.Magic) && (tMaterial.getMass() > 0L)) { - ItemStack tOutput = ItemList.Tool_DataOrb.get(1L); - Behaviour_DataOrb.setDataTitle(tOutput, "Elemental-Scan"); - Behaviour_DataOrb.setDataName(tOutput, tMaterial.mElement.name()); - ItemStack tInput = GT_OreDictUnificator.get(OrePrefixes.dust, tMaterial, 1L); - ItemStack[] iSMat0 = new ItemStack[] { tInput }; - ItemStack[] iSMat1 = new ItemStack[] { tOutput }; - if (tInput != null) { - GT_Recipe.GT_Recipe_Map.sScannerFakeRecipes.addFakeRecipe( - false, - iSMat0, - iSMat1, - ItemList.Tool_DataOrb.get(1L), - null, - null, - (int) (tMaterial.getMass() * 8192L), - 30, - 0); - GT_Recipe.GT_Recipe_Map.sReplicatorFakeRecipes.addFakeRecipe( - false, - null, - iSMat0, - iSMat1, - new FluidStack[] { Materials.UUMatter.getFluid(tMaterial.getMass()) }, - null, - (int) (tMaterial.getMass() * 512L), - (int) VP[1], - 0); + ItemStack dataOrb = ItemList.Tool_DataOrb.get(1L); + Behaviour_DataOrb.setDataTitle(dataOrb, "Elemental-Scan"); + Behaviour_DataOrb.setDataName(dataOrb, tMaterial.mElement.name()); + ItemStack dustItem = GT_OreDictUnificator.get(OrePrefixes.dust, tMaterial, 1L); + if (dustItem != null) { + GT_Values.RA.stdBuilder() + .itemInputs(dustItem) + .itemOutputs(dataOrb) + .special(ItemList.Tool_DataOrb.get(1L)) + .duration((int) (tMaterial.getMass() * 8192L)) + .eut(TierEU.RECIPE_LV) + .fake() + .ignoreCollision() + .addTo(RecipeMaps.scannerFakeRecipes); + GT_Values.RA.stdBuilder() + .itemOutputs(dustItem) + .special(dataOrb) + .metadata(GT_RecipeConstants.MATERIAL, tMaterial) + .addTo(RecipeMaps.replicatorRecipes); return; } - tInput = GT_OreDictUnificator.get(OrePrefixes.cell, tMaterial, 1L); - iSMat0 = new ItemStack[] { tInput }; - if (tInput != null) { - GT_Recipe.GT_Recipe_Map.sScannerFakeRecipes.addFakeRecipe( - false, - iSMat0, - iSMat1, - ItemList.Tool_DataOrb.get(1L), - null, - null, - (int) (tMaterial.getMass() * 8192L), - 30, - 0); - GT_Recipe.GT_Recipe_Map.sReplicatorFakeRecipes.addFakeRecipe( - false, - null, - iSMat0, - iSMat1, - new FluidStack[] { Materials.UUMatter.getFluid(tMaterial.getMass()) }, - null, - (int) (tMaterial.getMass() * 512L), - (int) VP[1], - 0); + ItemStack cellItem = GT_OreDictUnificator.get(OrePrefixes.cell, tMaterial, 1L); + if (cellItem != null) { + GT_Values.RA.stdBuilder() + .itemInputs(cellItem) + .itemOutputs(dataOrb) + .special(ItemList.Tool_DataOrb.get(1L)) + .duration((int) (tMaterial.getMass() * 8192L)) + .eut(TierEU.RECIPE_LV) + .fake() + .ignoreCollision() + .addTo(RecipeMaps.scannerFakeRecipes); + FluidStack fluidStack = GT_Utility.getFluidForFilledItem(cellItem, false); + GT_RecipeBuilder builder = GT_Values.RA.stdBuilder(); + if (fluidStack != null) { + builder.fluidOutputs(fluidStack); + } else { + builder.itemInputs(Materials.Empty.getCells(1)) + .itemOutputs(cellItem); + } + builder.special(dataOrb) + .metadata(GT_RecipeConstants.MATERIAL, tMaterial) + .addTo(RecipeMaps.replicatorRecipes); } } }); - if (!GT_MetaTileEntity_Massfabricator.sRequiresUUA) GT_Recipe.GT_Recipe_Map.sMassFabFakeRecipes.addFakeRecipe( - false, - null, - null, - null, - null, - new FluidStack[] { Materials.UUMatter.getFluid(1L) }, - GT_MetaTileEntity_Massfabricator.sDurationMultiplier, - 256, - 0); - GT_Recipe.GT_Recipe_Map.sMassFabFakeRecipes.addFakeRecipe( + if (!GT_MetaTileEntity_Massfabricator.sRequiresUUA) { + GT_MetaTileEntity_Massfabricator.nonUUARecipe = RecipeMaps.massFabFakeRecipes.addFakeRecipe( + false, + null, + null, + null, + null, + new FluidStack[] { Materials.UUMatter.getFluid(1L) }, + GT_MetaTileEntity_Massfabricator.sDurationMultiplier, + GT_MetaTileEntity_Massfabricator.BASE_EUT, + 0); + } + GT_MetaTileEntity_Massfabricator.uuaRecipe = RecipeMaps.massFabFakeRecipes.addFakeRecipe( false, new ItemStack[] { GT_Utility.getIntegratedCircuit(1) }, null, @@ -328,9 +314,9 @@ public class GT_PostLoad { new FluidStack[] { Materials.UUAmplifier.getFluid(GT_MetaTileEntity_Massfabricator.sUUAperUUM) }, new FluidStack[] { Materials.UUMatter.getFluid(1L) }, GT_MetaTileEntity_Massfabricator.sDurationMultiplier / GT_MetaTileEntity_Massfabricator.sUUASpeedBonus, - 256, + GT_MetaTileEntity_Massfabricator.BASE_EUT, 0); - GT_Recipe.GT_Recipe_Map.sRockBreakerFakeRecipes.addFakeRecipe( + RecipeMaps.rockBreakerFakeRecipes.addFakeRecipe( false, new ItemStack[] { ItemList.Display_ITS_FREE.getWithName(1L, "IT'S FREE! Place Lava on Side") }, new ItemStack[] { new ItemStack(Blocks.cobblestone, 1) }, @@ -340,7 +326,7 @@ public class GT_PostLoad { 16, 30, 0); - GT_Recipe.GT_Recipe_Map.sRockBreakerFakeRecipes.addFakeRecipe( + RecipeMaps.rockBreakerFakeRecipes.addFakeRecipe( false, new ItemStack[] { ItemList.Display_ITS_FREE.getWithName(1L, "IT'S FREE! Place Lava on Top") }, new ItemStack[] { new ItemStack(Blocks.stone, 1) }, @@ -350,7 +336,7 @@ public class GT_PostLoad { 16, 30, 0); - GT_Recipe.GT_Recipe_Map.sRockBreakerFakeRecipes.addFakeRecipe( + RecipeMaps.rockBreakerFakeRecipes.addFakeRecipe( false, new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Redstone, 1L), GT_Utility.getIntegratedCircuit(1) }, @@ -491,32 +477,33 @@ public class GT_PostLoad { } public static void addSolidFakeLargeBoilerFuels() { - GT_Recipe.GT_Recipe_Map.sLargeBoilerFakeFuels.addSolidRecipes( - GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Charcoal, 1), - GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Charcoal, 1), - GT_OreDictUnificator.get(OrePrefixes.block, Materials.Charcoal, 1), - GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Coal, 1), - GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Coal, 1), - GT_OreDictUnificator.get(OrePrefixes.block, Materials.Coal, 1), - GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Coal, 1), - GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Lignite, 1), - GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Lignite, 1), - GT_OreDictUnificator.get(OrePrefixes.block, Materials.Lignite, 1), - GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Lignite, 1), - GT_OreDictUnificator.get(OrePrefixes.log, Materials.Wood, 1), - GT_OreDictUnificator.get(OrePrefixes.plank, Materials.Wood, 1), - GT_OreDictUnificator.get(OrePrefixes.stick, Materials.Wood, 1), - GT_OreDictUnificator.get(OrePrefixes.slab, Materials.Wood, 1), - GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 1), - GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sodium, 1), - GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Lithium, 1), - GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Caesium, 1), - GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sulfur, 1), - GT_OreDictUnificator.get(ItemList.Block_SSFUEL.get(1)), - GT_OreDictUnificator.get(ItemList.Block_MSSFUEL.get(1)), - GT_OreDictUnificator.get(OrePrefixes.rod, Materials.Blaze, 1)); + RecipeMaps.largeBoilerFakeFuels.getBackend() + .addSolidRecipes( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Charcoal, 1), + GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Charcoal, 1), + GT_OreDictUnificator.get(OrePrefixes.block, Materials.Charcoal, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Coal, 1), + GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Coal, 1), + GT_OreDictUnificator.get(OrePrefixes.block, Materials.Coal, 1), + GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Coal, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Lignite, 1), + GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Lignite, 1), + GT_OreDictUnificator.get(OrePrefixes.block, Materials.Lignite, 1), + GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Lignite, 1), + GT_OreDictUnificator.get(OrePrefixes.log, Materials.Wood, 1), + GT_OreDictUnificator.get(OrePrefixes.plank, Materials.Wood, 1), + GT_OreDictUnificator.get(OrePrefixes.stick, Materials.Wood, 1), + GT_OreDictUnificator.get(OrePrefixes.slab, Materials.Wood, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sodium, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Lithium, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Caesium, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sulfur, 1), + GT_OreDictUnificator.get(ItemList.Block_SSFUEL.get(1)), + GT_OreDictUnificator.get(ItemList.Block_MSSFUEL.get(1)), + GT_OreDictUnificator.get(OrePrefixes.rod, Materials.Blaze, 1)); if (Thaumcraft.isModLoaded()) { - GT_Recipe.GT_Recipe_Map.sLargeBoilerFakeFuels + RecipeMaps.largeBoilerFakeFuels.getBackend() .addSolidRecipe(GT_ModHandler.getModItem(Thaumcraft.ID, "ItemResource", 1)); } } diff --git a/src/main/java/gregtech/loaders/postload/GT_ProcessingArrayRecipeLoader.java b/src/main/java/gregtech/loaders/postload/GT_ProcessingArrayRecipeLoader.java index 32023df99a..0ff53d0424 100644 --- a/src/main/java/gregtech/loaders/postload/GT_ProcessingArrayRecipeLoader.java +++ b/src/main/java/gregtech/loaders/postload/GT_ProcessingArrayRecipeLoader.java @@ -1,171 +1,167 @@ package gregtech.loaders.postload; import gregtech.api.enums.SoundResource; +import gregtech.api.recipe.RecipeMaps; import gregtech.api.util.GT_ProcessingArray_Manager; -import gregtech.api.util.GT_Recipe.GT_Recipe_Map; public class GT_ProcessingArrayRecipeLoader { public static void registerDefaultGregtechMaps() { // Alloy Smelter - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.alloysmelter", GT_Recipe_Map.sAlloySmelterRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.alloysmelter", RecipeMaps.alloySmelterRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.alloysmelter", SoundResource.IC2_MACHINES_INDUCTION_LOOP); // Arc Furnace - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.arcfurnace", GT_Recipe_Map.sArcFurnaceRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.arcfurnace", RecipeMaps.arcFurnaceRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.arcfurnace", SoundResource.IC2_MACHINES_INDUCTION_LOOP); // Assembler - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.assembler", GT_Recipe_Map.sAssemblerRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.assembler", RecipeMaps.assemblerRecipes); GT_ProcessingArray_Manager.addSoundResourceToPA("basicmachine.assembler", SoundResource.NONE); // Autoclave - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.autoclave", GT_Recipe_Map.sAutoclaveRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.autoclave", RecipeMaps.autoclaveRecipes); GT_ProcessingArray_Manager.addSoundResourceToPA("basicmachine.autoclave", SoundResource.NONE); // Bender - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.bender", GT_Recipe_Map.sBenderRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.bender", RecipeMaps.benderRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.bender", SoundResource.IC2_MACHINES_COMPRESSOR_OP); // Boxinator - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.boxinator", GT_Recipe_Map.sBoxinatorRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.boxinator", RecipeMaps.packagerRecipes); GT_ProcessingArray_Manager.addSoundResourceToPA("basicmachine.boxinator", SoundResource.NONE); // Brewery - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.brewery", GT_Recipe_Map.sBrewingRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.brewery", RecipeMaps.brewingRecipes); GT_ProcessingArray_Manager.addSoundResourceToPA("basicmachine.brewery", SoundResource.NONE); // Canner - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.canner", GT_Recipe_Map.sCannerRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.canner", RecipeMaps.cannerRecipes); GT_ProcessingArray_Manager.addSoundResourceToPA("basicmachine.canner", SoundResource.IC2_MACHINES_EXTRACTOR_OP); // Centrifuge - GT_ProcessingArray_Manager - .addRecipeMapToPA("basicmachine.centrifuge", GT_Recipe_Map.sMultiblockCentrifugeRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.centrifuge", RecipeMaps.centrifugeNonCellRecipes); GT_ProcessingArray_Manager.addSoundResourceToPA("basicmachine.centrifuge", SoundResource.NONE); // Chemical Bath - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.chemicalbath", GT_Recipe_Map.sChemicalBathRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.chemicalbath", RecipeMaps.chemicalBathRecipes); GT_ProcessingArray_Manager.addSoundResourceToPA("basicmachine.chemicalbath", SoundResource.NONE); // Chemical Reactor GT_ProcessingArray_Manager - .addRecipeMapToPA("basicmachine.chemicalreactor", GT_Recipe_Map.sMultiblockChemicalRecipes); + .addRecipeMapToPA("basicmachine.chemicalreactor", RecipeMaps.multiblockChemicalReactorRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.chemicalreactor", SoundResource.IC2_MACHINES_EXTRACTOR_OP); // Circuit Assembler GT_ProcessingArray_Manager - .addRecipeMapToPA("basicmachine.circuitassembler", GT_Recipe_Map.sCircuitAssemblerRecipes); + .addRecipeMapToPA("basicmachine.circuitassembler", RecipeMaps.circuitAssemblerRecipes); GT_ProcessingArray_Manager.addSoundResourceToPA("basicmachine.circuitassembler", SoundResource.NONE); // Compressor - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.compressor", GT_Recipe_Map.sCompressorRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.compressor", RecipeMaps.compressorRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.compressor", SoundResource.IC2_MACHINES_COMPRESSOR_OP); // Cutting Machine - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.cutter", GT_Recipe_Map.sCutterRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.cutter", RecipeMaps.cutterRecipes); GT_ProcessingArray_Manager.addSoundResourceToPA("basicmachine.cutter", SoundResource.NONE); // Distillery - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.distillery", GT_Recipe_Map.sDistilleryRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.distillery", RecipeMaps.distilleryRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.distillery", SoundResource.GT_MACHINES_DISTILLERY_LOOP); // Electrolyzer - GT_ProcessingArray_Manager - .addRecipeMapToPA("basicmachine.electrolyzer", GT_Recipe_Map.sMultiblockElectrolyzerRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.electrolyzer", RecipeMaps.electrolyzerNonCellRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.electrolyzer", SoundResource.IC2_MACHINES_MAGNETIZER_LOOP); // Extractor - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.extractor", GT_Recipe_Map.sExtractorRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.extractor", RecipeMaps.extractorRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.extractor", SoundResource.IC2_MACHINES_EXTRACTOR_OP); // Extruder - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.extruder", GT_Recipe_Map.sExtruderRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.extruder", RecipeMaps.extruderRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.extruder", SoundResource.IC2_MACHINES_INDUCTION_LOOP); // Fermenter - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.fermenter", GT_Recipe_Map.sFermentingRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.fermenter", RecipeMaps.fermentingRecipes); GT_ProcessingArray_Manager.addSoundResourceToPA("basicmachine.fermenter", SoundResource.NONE); // Fluid Canner - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.fluidcanner", GT_Recipe_Map.sFluidCannerRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.fluidcanner", RecipeMaps.fluidCannerRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.fluidcanner", SoundResource.IC2_MACHINES_EXTRACTOR_OP); // Fluid Extractor - GT_ProcessingArray_Manager - .addRecipeMapToPA("basicmachine.fluidextractor", GT_Recipe_Map.sFluidExtractionRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.fluidextractor", RecipeMaps.fluidExtractionRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.fluidextractor", SoundResource.IC2_MACHINES_EXTRACTOR_OP); // Fluid Heater - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.fluidheater", GT_Recipe_Map.sFluidHeaterRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.fluidheater", RecipeMaps.fluidHeaterRecipes); GT_ProcessingArray_Manager.addSoundResourceToPA("basicmachine.fluidheater", SoundResource.NONE); // Fluid Solidifier - GT_ProcessingArray_Manager - .addRecipeMapToPA("basicmachine.fluidsolidifier", GT_Recipe_Map.sFluidSolidficationRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.fluidsolidifier", RecipeMaps.fluidSolidifierRecipes); GT_ProcessingArray_Manager.addSoundResourceToPA("basicmachine.fluidsolidifier", SoundResource.NONE); // Forge Hammer - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.hammer", GT_Recipe_Map.sHammerRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.hammer", RecipeMaps.hammerRecipes); GT_ProcessingArray_Manager.addSoundResourceToPA("basicmachine.hammer", SoundResource.RANDOM_ANVIL_USE); // Forming Press - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.press", GT_Recipe_Map.sPressRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.press", RecipeMaps.formingPressRecipes); GT_ProcessingArray_Manager.addSoundResourceToPA("basicmachine.press", SoundResource.IC2_MACHINES_COMPRESSOR_OP); // Laser Engraver - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.laserengraver", GT_Recipe_Map.sLaserEngraverRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.laserengraver", RecipeMaps.laserEngraverRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.laserengraver", SoundResource.IC2_MACHINES_MAGNETIZER_LOOP); // Lathe - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.lathe", GT_Recipe_Map.sLatheRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.lathe", RecipeMaps.latheRecipes); GT_ProcessingArray_Manager.addSoundResourceToPA("basicmachine.lathe", SoundResource.NONE); // Macerator - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.macerator", GT_Recipe_Map.sMaceratorRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.macerator", RecipeMaps.maceratorRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.macerator", SoundResource.IC2_MACHINES_MACERATOR_OP); // Magnetic Separator GT_ProcessingArray_Manager - .addRecipeMapToPA("basicmachine.electromagneticseparator", GT_Recipe_Map.sElectroMagneticSeparatorRecipes); + .addRecipeMapToPA("basicmachine.electromagneticseparator", RecipeMaps.electroMagneticSeparatorRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.electromagneticseparator", SoundResource.IC2_MACHINES_MAGNETIZER_LOOP); // Matter Amplifier - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.amplifab", GT_Recipe_Map.sAmplifiers); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.amplifab", RecipeMaps.amplifierRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.amplifab", SoundResource.IC2_MACHINES_EXTRACTOR_OP); // Microwave - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.microwave", GT_Recipe_Map.sMicrowaveRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.microwave", RecipeMaps.microwaveRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.microwave", SoundResource.IC2_MACHINES_ELECTROFURNACE_LOOP); // Mixer - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.mixer", GT_Recipe_Map.sMultiblockMixerRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.mixer", RecipeMaps.mixerNonCellRecipes); GT_ProcessingArray_Manager.addSoundResourceToPA("basicmachine.mixer", SoundResource.NONE); // Ore Washer - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.orewasher", GT_Recipe_Map.sOreWasherRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.orewasher", RecipeMaps.oreWasherRecipes); GT_ProcessingArray_Manager.addSoundResourceToPA("basicmachine.orewasher", SoundResource.NONE); // Plasma Arc Furnace GT_ProcessingArray_Manager - .addRecipeMapToPA("basicmachine.plasmaarcfurnace", GT_Recipe_Map.sPlasmaArcFurnaceRecipes); + .addRecipeMapToPA("basicmachine.plasmaarcfurnace", RecipeMaps.plasmaArcFurnaceRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.plasmaarcfurnace", SoundResource.IC2_MACHINES_INDUCTION_LOOP); // Polarizer - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.polarizer", GT_Recipe_Map.sPolarizerRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.polarizer", RecipeMaps.polarizerRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.polarizer", SoundResource.IC2_MACHINES_MAGNETIZER_LOOP); // Printer - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.printer", GT_Recipe_Map.sPrinterRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.printer", RecipeMaps.printerRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.printer", SoundResource.IC2_MACHINES_COMPRESSOR_OP); // Recycler - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.recycler", GT_Recipe_Map.sRecyclerRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.recycler", RecipeMaps.recyclerRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.recycler", SoundResource.IC2_MACHINES_RECYCLER_OP); // Scanner - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.scanner", GT_Recipe_Map.sScannerFakeRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.scanner", RecipeMaps.scannerFakeRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.scanner", SoundResource.IC2_MACHINES_MAGNETIZER_LOOP); // Sifter - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.sifter", GT_Recipe_Map.sSifterRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.sifter", RecipeMaps.sifterRecipes); GT_ProcessingArray_Manager.addSoundResourceToPA("basicmachine.sifter", SoundResource.NONE); // Slicer - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.slicer", GT_Recipe_Map.sSlicerRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.slicer", RecipeMaps.slicerRecipes); GT_ProcessingArray_Manager.addSoundResourceToPA("basicmachine.slicer", SoundResource.NONE); // Thermal Centrifuge GT_ProcessingArray_Manager - .addRecipeMapToPA("basicmachine.thermalcentrifuge", GT_Recipe_Map.sThermalCentrifugeRecipes); + .addRecipeMapToPA("basicmachine.thermalcentrifuge", RecipeMaps.thermalCentrifugeRecipes); GT_ProcessingArray_Manager.addSoundResourceToPA("basicmachine.thermalcentrifuge", SoundResource.NONE); // Unboxinator - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.unboxinator", GT_Recipe_Map.sUnboxinatorRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.unboxinator", RecipeMaps.unpackagerRecipes); GT_ProcessingArray_Manager.addSoundResourceToPA("basicmachine.unboxinator", SoundResource.NONE); // Wiremill - GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.wiremill", GT_Recipe_Map.sWiremillRecipes); + GT_ProcessingArray_Manager.addRecipeMapToPA("basicmachine.wiremill", RecipeMaps.wiremillRecipes); GT_ProcessingArray_Manager .addSoundResourceToPA("basicmachine.wiremill", SoundResource.IC2_MACHINES_RECYCLER_OP); } diff --git a/src/main/java/gregtech/loaders/postload/GT_UUMRecipeLoader.java b/src/main/java/gregtech/loaders/postload/GT_UUMRecipeLoader.java deleted file mode 100644 index bf2c2c4ebb..0000000000 --- a/src/main/java/gregtech/loaders/postload/GT_UUMRecipeLoader.java +++ /dev/null @@ -1,7 +0,0 @@ -package gregtech.loaders.postload; - -public class GT_UUMRecipeLoader implements Runnable { - - @Override - public void run() {} -} diff --git a/src/main/java/gregtech/loaders/postload/chains/GT_BauxiteRefineChain.java b/src/main/java/gregtech/loaders/postload/chains/GT_BauxiteRefineChain.java index d5d1537a49..aaf25812e4 100644 --- a/src/main/java/gregtech/loaders/postload/chains/GT_BauxiteRefineChain.java +++ b/src/main/java/gregtech/loaders/postload/chains/GT_BauxiteRefineChain.java @@ -1,10 +1,10 @@ package gregtech.loaders.postload.chains; -import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes; -import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sChemicalBathRecipes; -import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sCrackingRecipes; -import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sMixerRecipes; -import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sMultiblockChemicalRecipes; +import static gregtech.api.recipe.RecipeMaps.centrifugeRecipes; +import static gregtech.api.recipe.RecipeMaps.chemicalBathRecipes; +import static gregtech.api.recipe.RecipeMaps.crackingRecipes; +import static gregtech.api.recipe.RecipeMaps.mixerRecipes; +import static gregtech.api.recipe.RecipeMaps.multiblockChemicalReactorRecipes; import static gregtech.api.util.GT_RecipeBuilder.SECONDS; import static gregtech.api.util.GT_RecipeBuilder.TICKS; @@ -34,7 +34,7 @@ public class GT_BauxiteRefineChain { .fluidOutputs(MaterialsOreAlum.BauxiteSlurry.getFluid(8000)) .duration(10 * SECONDS) .eut(TierEU.RECIPE_MV) - .addTo(sMixerRecipes); + .addTo(mixerRecipes); GT_Values.RA.stdBuilder() .itemInputs( @@ -46,7 +46,7 @@ public class GT_BauxiteRefineChain { .fluidOutputs(MaterialsOreAlum.BauxiteSlurry.getFluid(8000)) .duration(10 * SECONDS) .eut(TierEU.RECIPE_MV) - .addTo(sMixerRecipes); + .addTo(mixerRecipes); GT_Values.RA.stdBuilder() .itemInputs(GT_Utility.getIntegratedCircuit(1)) @@ -54,7 +54,7 @@ public class GT_BauxiteRefineChain { .fluidOutputs(MaterialsOreAlum.HeatedBauxiteSlurry.getFluid(32000)) .duration(8 * SECONDS) .eut(400) - .addTo(sCrackingRecipes); + .addTo(crackingRecipes); GT_Values.RA.stdBuilder() .itemInputs(Materials.Aluminiumhydroxide.getDust(1)) @@ -68,7 +68,7 @@ public class GT_BauxiteRefineChain { .fluidOutputs(MaterialsOreAlum.SluiceJuice.getFluid(5000)) .duration(15 * SECONDS) .eut(TierEU.RECIPE_HV) - .addTo(sMultiblockChemicalRecipes); + .addTo(multiblockChemicalReactorRecipes); GT_Values.RA.stdBuilder() .itemInputs(MaterialsOreAlum.BauxiteSlag.getDust(1)) @@ -81,7 +81,7 @@ public class GT_BauxiteRefineChain { .outputChances(10000, 3000, 2000, 9000, 8000) .duration(2 * SECONDS) .eut(TierEU.RECIPE_MV) - .addTo(sCentrifugeRecipes); + .addTo(centrifugeRecipes); GT_Values.RA.stdBuilder() .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushedPurified, Materials.Ilmenite, 1)) @@ -91,7 +91,7 @@ public class GT_BauxiteRefineChain { .fluidOutputs(new FluidStack(ItemList.sGreenVitriol, 2000)) .duration(21 * SECONDS) .eut(1000) - .addTo(sChemicalBathRecipes); + .addTo(chemicalBathRecipes); GT_Values.RA.stdBuilder() .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Ilmenite, 1)) @@ -101,7 +101,7 @@ public class GT_BauxiteRefineChain { .fluidOutputs(new FluidStack(ItemList.sGreenVitriol, 2000)) .duration(21 * SECONDS) .eut(1000) - .addTo(sChemicalBathRecipes); + .addTo(chemicalBathRecipes); GT_Values.RA.stdBuilder() .itemInputs(MaterialsOreAlum.IlmeniteSlag.getDust(1)) @@ -114,7 +114,7 @@ public class GT_BauxiteRefineChain { .outputChances(8000, 500, 2000, 5000, 6000) .duration(2 * SECONDS) .eut(TierEU.RECIPE_MV) - .addTo(sCentrifugeRecipes); + .addTo(centrifugeRecipes); OrePrefixes[] washable = new OrePrefixes[] { OrePrefixes.crushed, OrePrefixes.crushedPurified, OrePrefixes.dustImpure, OrePrefixes.dustPure }; @@ -129,7 +129,7 @@ public class GT_BauxiteRefineChain { .fluidOutputs(MaterialsOreAlum.SapphireJuice.getFluid(1000)) .duration(2 * SECONDS) .eut(100) - .addTo(sMixerRecipes); + .addTo(mixerRecipes); GT_Values.RA.stdBuilder() .itemInputs( @@ -140,7 +140,7 @@ public class GT_BauxiteRefineChain { .fluidOutputs(MaterialsOreAlum.GreenSapphireJuice.getFluid(1000)) .duration(2 * SECONDS) .eut(100) - .addTo(sMixerRecipes); + .addTo(mixerRecipes); GT_Values.RA.stdBuilder() .itemInputs( @@ -151,7 +151,7 @@ public class GT_BauxiteRefineChain { .fluidOutputs(MaterialsOreAlum.RubyJuice.getFluid(1000)) .duration(2 * SECONDS) .eut(100) - .addTo(sMixerRecipes); + .addTo(mixerRecipes); } GT_Values.RA.stdBuilder() @@ -166,7 +166,7 @@ public class GT_BauxiteRefineChain { .fluidOutputs(Materials.HydrochloricAcid.getFluid(1000)) .duration(2 * SECONDS + 5 * TICKS) .eut(100) - .addTo(sCentrifugeRecipes); + .addTo(centrifugeRecipes); GT_Values.RA.stdBuilder() .itemInputs(GT_Utility.getIntegratedCircuit(1)) @@ -181,7 +181,7 @@ public class GT_BauxiteRefineChain { .fluidOutputs(Materials.HydrochloricAcid.getFluid(1000)) .duration(2 * SECONDS + 5 * TICKS) .eut(100) - .addTo(sCentrifugeRecipes); + .addTo(centrifugeRecipes); GT_Values.RA.stdBuilder() .itemInputs(GT_Utility.getIntegratedCircuit(1)) @@ -196,7 +196,7 @@ public class GT_BauxiteRefineChain { .fluidOutputs(Materials.HydrochloricAcid.getFluid(1000)) .duration(2 * SECONDS + 5 * TICKS) .eut(100) - .addTo(sCentrifugeRecipes); + .addTo(centrifugeRecipes); GT_Values.RA.stdBuilder() .itemInputs(Materials.Pyrope.getDust(1)) @@ -212,7 +212,7 @@ public class GT_BauxiteRefineChain { .fluidOutputs(MaterialsOreAlum.SluiceJuice.getFluid(10)) .duration(2 * SECONDS + 5 * TICKS) .eut(TierEU.RECIPE_MV) - .addTo(sCentrifugeRecipes); + .addTo(centrifugeRecipes); GT_Values.RA.stdBuilder() .itemInputs(Materials.Almandine.getDust(1)) @@ -228,7 +228,7 @@ public class GT_BauxiteRefineChain { .fluidOutputs(MaterialsOreAlum.SluiceJuice.getFluid(10)) .duration(2 * SECONDS + 5 * TICKS) .eut(TierEU.RECIPE_MV) - .addTo(sCentrifugeRecipes); + .addTo(centrifugeRecipes); GT_Values.RA.stdBuilder() .itemInputs(Materials.Spessartine.getDust(1)) @@ -244,7 +244,7 @@ public class GT_BauxiteRefineChain { .fluidOutputs(MaterialsOreAlum.SluiceJuice.getFluid(10)) .duration(2 * SECONDS + 5 * TICKS) .eut(TierEU.RECIPE_MV) - .addTo(sCentrifugeRecipes); + .addTo(centrifugeRecipes); GT_Values.RA.stdBuilder() .itemInputs(Materials.Andradite.getDust(1)) @@ -260,7 +260,7 @@ public class GT_BauxiteRefineChain { .fluidOutputs(MaterialsOreAlum.SluiceJuice.getFluid(10)) .duration(2 * SECONDS + 5 * TICKS) .eut(TierEU.RECIPE_MV) - .addTo(sCentrifugeRecipes); + .addTo(centrifugeRecipes); GT_Values.RA.stdBuilder() .itemInputs(Materials.Uvarovite.getDust(1)) @@ -276,7 +276,7 @@ public class GT_BauxiteRefineChain { .fluidOutputs(MaterialsOreAlum.SluiceJuice.getFluid(10)) .duration(2 * SECONDS + 5 * TICKS) .eut(TierEU.RECIPE_MV) - .addTo(sCentrifugeRecipes); + .addTo(centrifugeRecipes); GT_Values.RA.stdBuilder() .itemInputs(Materials.Grossular.getDust(1)) @@ -292,6 +292,6 @@ public class GT_BauxiteRefineChain { .fluidOutputs(MaterialsOreAlum.SluiceJuice.getFluid(10)) .duration(2 * SECONDS + 5 * TICKS) .eut(TierEU.RECIPE_MV) - .addTo(sCentrifugeRecipes); + .addTo(centrifugeRecipes); } } diff --git a/src/main/java/gregtech/loaders/postload/chains/GT_NaniteChain.java b/src/main/java/gregtech/loaders/postload/chains/GT_NaniteChain.java index a72fe0acc9..dabcd93a8d 100644 --- a/src/main/java/gregtech/loaders/postload/chains/GT_NaniteChain.java +++ b/src/main/java/gregtech/loaders/postload/chains/GT_NaniteChain.java @@ -23,8 +23,8 @@ import gregtech.api.enums.Materials; import gregtech.api.enums.MaterialsUEVplus; import gregtech.api.enums.OrePrefixes; import gregtech.api.enums.TierEU; +import gregtech.api.recipe.RecipeMaps; import gregtech.api.util.GT_OreDictUnificator; -import gregtech.api.util.GT_Recipe; import gregtech.api.util.GT_RecipeBuilder; public class GT_NaniteChain { @@ -234,7 +234,7 @@ public class GT_NaniteChain { .duration(750 * GT_RecipeBuilder.SECONDS) .eut(TierEU.RECIPE_MAX) .specialValue(3) - .addTo(GT_Recipe.GT_Recipe_Map.sNanoForge); + .addTo(RecipeMaps.nanoForgeRecipes); } } diff --git a/src/main/java/gregtech/loaders/postload/chains/GT_PCBFactoryRecipes.java b/src/main/java/gregtech/loaders/postload/chains/GT_PCBFactoryRecipes.java index 7e7e4ec496..392e6fa154 100644 --- a/src/main/java/gregtech/loaders/postload/chains/GT_PCBFactoryRecipes.java +++ b/src/main/java/gregtech/loaders/postload/chains/GT_PCBFactoryRecipes.java @@ -2,7 +2,8 @@ package gregtech.loaders.postload.chains; import static gregtech.api.enums.Mods.BartWorks; import static gregtech.api.enums.Mods.GTPlusPlus; -import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sAssemblerRecipes; +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.recipe.metadata.PCBFactoryUpgrade.BIO; import static gregtech.api.util.GT_RecipeBuilder.MINUTES; import static gregtech.api.util.GT_RecipeBuilder.SECONDS; import static gregtech.api.util.GT_RecipeConstants.AssemblyLine; @@ -23,6 +24,9 @@ import gregtech.api.enums.Materials; import gregtech.api.enums.MaterialsUEVplus; import gregtech.api.enums.OrePrefixes; import gregtech.api.enums.TierEU; +import gregtech.api.recipe.RecipeMaps; +import gregtech.api.recipe.metadata.PCBFactoryTierKey; +import gregtech.api.recipe.metadata.PCBFactoryUpgradeKey; import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_OreDictUnificator; import gregtech.api.util.GT_PCBFactoryManager; @@ -31,12 +35,10 @@ import gregtech.api.util.GT_Utility; @SuppressWarnings("SpellCheckingInspection") public class GT_PCBFactoryRecipes { - public static void load() { - final int mBioUpgradeBitMap = 0b1000; - final int mTier3BitMap = 0b100; - final int mTier2BitMap = 0b10; - final int mTier1BitMap = 0b1; + private static final PCBFactoryTierKey TIER = PCBFactoryTierKey.INSTANCE; + private static final PCBFactoryUpgradeKey UPGRADE = PCBFactoryUpgradeKey.INSTANCE; + public static void load() { final Fluid solderLuV = FluidRegistry.getFluid("molten.indalloy140") != null ? FluidRegistry.getFluid("molten.indalloy140") : FluidRegistry.getFluid("molten.solderingalloy"); @@ -65,7 +67,7 @@ public class GT_PCBFactoryRecipes { .itemOutputs(ItemList.BasicPhotolithographicFrameworkCasing.get(1)) .duration(30 * SECONDS) .eut(TierEU.RECIPE_ZPM) - .addTo(sAssemblerRecipes); + .addTo(assemblerRecipes); GT_Values.RA.stdBuilder() .itemInputs( GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 1), @@ -73,7 +75,7 @@ public class GT_PCBFactoryRecipes { .itemOutputs(ItemList.ReinforcedPhotolithographicFrameworkCasing.get(1)) .duration(30 * SECONDS) .eut(TierEU.RECIPE_UHV) - .addTo(sAssemblerRecipes); + .addTo(assemblerRecipes); GT_Values.RA.stdBuilder() .itemInputs( GT_ModHandler.getModItem(GTPlusPlus.ID, "blockFrameGtCelestialTungsten", 1), @@ -82,7 +84,7 @@ public class GT_PCBFactoryRecipes { .itemOutputs(ItemList.RadiationProofPhotolithographicFrameworkCasing.get(1)) .duration(30 * SECONDS) .eut(TierEU.RECIPE_UIV) - .addTo(sAssemblerRecipes); + .addTo(assemblerRecipes); GT_Values.RA.stdBuilder() .itemInputs( GT_ModHandler.getModItem(GTPlusPlus.ID, "blockFrameGtHypogen", 1), @@ -92,7 +94,7 @@ public class GT_PCBFactoryRecipes { .fluidInputs(MaterialsUEVplus.SpaceTime.getMolten(8 * 144)) .duration(10 * SECONDS) .eut(TierEU.RECIPE_UMV) - .addTo(sAssemblerRecipes); + .addTo(assemblerRecipes); } // Load CircuitBoard Recipes @@ -106,19 +108,22 @@ public class GT_PCBFactoryRecipes { amountOfBoards -= 64; } aBoards.add(ItemList.Circuit_Board_Plastic_Advanced.get(amountOfBoards)); - GT_Values.RA.addPCBFactoryRecipe( - new ItemStack[] { GT_Utility.getIntegratedCircuit(1), + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(1), GT_PCBFactoryManager.getPlasticMaterialFromTier(tier) .getPlates(1), GT_OreDictUnificator .get(OrePrefixes.foil, Materials.AnnealedCopper, (long) (16 * (Math.sqrt(tier)))), - GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Copper, (long) (16 * (Math.sqrt(tier)))) }, - new FluidStack[] { Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier)))), - Materials.IronIIIChloride.getFluid((long) (250 * (Math.sqrt(tier)))) }, - aBoards.toArray(new ItemStack[0]), - (int) Math.ceil(600 / Math.sqrt(Math.pow(1.5, tier - 1.5))), - (int) GT_Values.VP[tier] * 3 / 4, - mTier1BitMap | mTier2BitMap | mTier3BitMap); + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Copper, (long) (16 * (Math.sqrt(tier))))) + .fluidInputs( + Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier)))), + Materials.IronIIIChloride.getFluid((long) (250 * (Math.sqrt(tier))))) + .itemOutputs(aBoards.toArray(new ItemStack[0])) + .duration((int) Math.ceil(600 / Math.sqrt(Math.pow(1.5, tier - 1.5)))) + .eut((int) GT_Values.VP[tier] * 3 / 4) + .metadata(TIER, 1) + .addTo(RecipeMaps.pcbFactoryRecipes); } for (int tier = 1; tier <= GT_PCBFactoryManager.mTiersOfPlastics; tier++) { int amountOfBoards = (int) Math.ceil(8 * (Math.sqrt(Math.pow(2, tier - 0.5)))); @@ -128,19 +133,23 @@ public class GT_PCBFactoryRecipes { amountOfBoards -= 64; } aBoards.add(ItemList.Circuit_Board_Plastic_Advanced.get(amountOfBoards)); - GT_Values.RA.addPCBFactoryRecipe( - new ItemStack[] { GT_Utility.getIntegratedCircuit(2), GT_Utility.getNaniteAsCatalyst(Materials.Silver), + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(2), + GT_Utility.getNaniteAsCatalyst(Materials.Silver), GT_PCBFactoryManager.getPlasticMaterialFromTier(tier) .getPlates(1), GT_OreDictUnificator .get(OrePrefixes.foil, Materials.AnnealedCopper, (long) (16 * (Math.sqrt(tier)))), - GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Copper, (long) (16 * (Math.sqrt(tier)))) }, - new FluidStack[] { Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier)))), - Materials.IronIIIChloride.getFluid((long) (250 * (Math.sqrt(tier)))) }, - aBoards.toArray(new ItemStack[0]), - (int) Math.ceil(500 / Math.sqrt(Math.pow(1.5, tier - 1.5))), - (int) GT_Values.VP[tier + 1] * 3 / 4, - mTier2BitMap | mTier3BitMap); + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Copper, (long) (16 * (Math.sqrt(tier))))) + .fluidInputs( + Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier)))), + Materials.IronIIIChloride.getFluid((long) (250 * (Math.sqrt(tier))))) + .itemOutputs(aBoards.toArray(new ItemStack[0])) + .duration((int) Math.ceil(500 / Math.sqrt(Math.pow(1.5, tier - 1.5)))) + .eut((int) GT_Values.VP[tier + 1] * 3 / 4) + .metadata(TIER, 2) + .addTo(RecipeMaps.pcbFactoryRecipes); } for (int tier = 1; tier <= GT_PCBFactoryManager.mTiersOfPlastics; tier++) { int amountOfBoards = (int) Math.ceil(8 * (Math.sqrt(Math.pow(2, tier)))); @@ -150,19 +159,23 @@ public class GT_PCBFactoryRecipes { amountOfBoards -= 64; } aBoards.add(ItemList.Circuit_Board_Plastic_Advanced.get(amountOfBoards)); - GT_Values.RA.addPCBFactoryRecipe( - new