diff options
12 files changed, 372 insertions, 4 deletions
diff --git a/src/main/java/gregtech/api/util/GTPP_Recipe.java b/src/main/java/gregtech/api/util/GTPP_Recipe.java index c169170bb7..653c0f0930 100644 --- a/src/main/java/gregtech/api/util/GTPP_Recipe.java +++ b/src/main/java/gregtech/api/util/GTPP_Recipe.java @@ -317,6 +317,23 @@ public class GTPP_Recipe extends GT_Recipe implements IComparableRecipe { "Total: " + MathUtils.formatNumbers(tDuration * tEUt * 4) + " EU"); }); + public static final GT_Recipe_Map sNuclearSaltProcessingPlantRecipes = new GT_Recipe_Map_LargeNEI( + new HashSet<>(50), + "gtpp.recipe.nuclearsaltprocessingplant", + "Nuclear Salt Processing Plant", + null, + RES_PATH_GUI + "basicmachines/FissionFuel", + 0, + 6, + 0, + 0, + 1, + "", + 0, + "", + true, + true).setUsualFluidInputCount(2).setUsualFluidOutputCount(3); + // Ore Milling Map public static final GT_Recipe_Map sOreMillRecipes = new GT_Recipe_Map( new HashSet<>(10000), diff --git a/src/main/java/gtPlusPlus/GTplusplus.java b/src/main/java/gtPlusPlus/GTplusplus.java index f552ee2850..9dfe9356e9 100644 --- a/src/main/java/gtPlusPlus/GTplusplus.java +++ b/src/main/java/gtPlusPlus/GTplusplus.java @@ -288,7 +288,7 @@ public class GTplusplus implements ActionListener { protected void generateGregtechRecipeMaps() { int[] mValidCount = new int[] { 0, 0, 0 }; - int[] mInvalidCount = new int[] { 0, 0, 0, 0, 0 }; + int[] mInvalidCount = new int[] { 0, 0, 0, 0, 0, 0, 0 }; int[] mOriginalCount = new int[] { 0, 0, 0 }; RecipeGen_BlastSmelterGT_GTNH.generateGTNHBlastSmelterRecipesFromEBFList(); @@ -312,6 +312,12 @@ public class GTplusplus implements ActionListener { mInvalidCount[4] = RecipeGen_MultisUsingFluidInsteadOfCells.generateRecipesNotUsingCells( GTPP_Recipe.GTPP_Recipe_Map.sChemicalDehydratorRecipes, GTPP_Recipe.GTPP_Recipe_Map.sMultiblockChemicalDehydratorRecipes); + mInvalidCount[5] = RecipeGen_MultisUsingFluidInsteadOfCells.generateRecipesNotUsingCells( + GTPP_Recipe.GTPP_Recipe_Map.sColdTrapRecipes, + GTPP_Recipe.GTPP_Recipe_Map.sNuclearSaltProcessingPlantRecipes); + mInvalidCount[6] = RecipeGen_MultisUsingFluidInsteadOfCells.generateRecipesNotUsingCells( + GTPP_Recipe.GTPP_Recipe_Map.sReactorProcessingUnitRecipes, + GTPP_Recipe.GTPP_Recipe_Map.sNuclearSaltProcessingPlantRecipes); /* * //Large Centrifuge generation mOriginalCount[0] = * GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes.mRecipeList.size(); for (GT_Recipe x : diff --git a/src/main/java/gtPlusPlus/core/config/ConfigHandler.java b/src/main/java/gtPlusPlus/core/config/ConfigHandler.java index b6d5c977b7..296fc0518d 100644 --- a/src/main/java/gtPlusPlus/core/config/ConfigHandler.java +++ b/src/main/java/gtPlusPlus/core/config/ConfigHandler.java @@ -58,6 +58,7 @@ import static gtPlusPlus.core.lib.CORE.ConfigSwitches.enableMultiblock_LiquidFlu import static gtPlusPlus.core.lib.CORE.ConfigSwitches.enableMultiblock_MatterFabricator; import static gtPlusPlus.core.lib.CORE.ConfigSwitches.enableMultiblock_MultiTank; import static gtPlusPlus.core.lib.CORE.ConfigSwitches.enableMultiblock_NuclearFuelRefinery; +import static gtPlusPlus.core.lib.CORE.ConfigSwitches.enableMultiblock_NuclearSaltProcessingPlant; import static gtPlusPlus.core.lib.CORE.ConfigSwitches.enableMultiblock_PowerSubstation; import static gtPlusPlus.core.lib.CORE.ConfigSwitches.enableMultiblock_ThermalBoiler; import static gtPlusPlus.core.lib.CORE.ConfigSwitches.enableOldGTcircuits; @@ -346,6 +347,11 @@ public class ConfigHandler { GregTech.ID, true, "Refines molten chemicals into nuclear fuels."); + enableMultiblock_NuclearSaltProcessingPlant = config.getBoolean( + "enableMultiblockNuclearSaltProcessingPlant", + GregTech.ID, + true, + "Reprocesses depleted nuclear salts into useful chemicals."); enableMultiblock_IndustrialSifter = config .getBoolean("enableMultiblock_IndustrialSifter", GregTech.ID, true, "Large scale sifting."); enableMultiblock_LargeAutoCrafter = config.getBoolean( diff --git a/src/main/java/gtPlusPlus/core/handler/COMPAT_HANDLER.java b/src/main/java/gtPlusPlus/core/handler/COMPAT_HANDLER.java index 694cd86c69..f893486d4f 100644 --- a/src/main/java/gtPlusPlus/core/handler/COMPAT_HANDLER.java +++ b/src/main/java/gtPlusPlus/core/handler/COMPAT_HANDLER.java @@ -89,6 +89,7 @@ import gtPlusPlus.xmod.gregtech.registration.gregtech.GregtechIsaMill; import gtPlusPlus.xmod.gregtech.registration.gregtech.GregtechLFTR; import gtPlusPlus.xmod.gregtech.registration.gregtech.GregtechLargeTurbinesAndHeatExchanger; import gtPlusPlus.xmod.gregtech.registration.gregtech.GregtechMolecularTransformer; +import gtPlusPlus.xmod.gregtech.registration.gregtech.GregtechNuclearSaltProcessingPlant; import gtPlusPlus.xmod.gregtech.registration.gregtech.GregtechPollutionDevices; import gtPlusPlus.xmod.gregtech.registration.gregtech.GregtechPowerBreakers; import gtPlusPlus.xmod.gregtech.registration.gregtech.GregtechPowerSubStation; @@ -149,6 +150,7 @@ public class COMPAT_HANDLER { GregtechGeneratorsULV.run(); GregtechEnergyBuffer.run(); GregtechLFTR.run(); + GregtechNuclearSaltProcessingPlant.run(); GregtechSteamCondenser.run(); GregtechSafeBlock.run(); GregtechIronBlastFurnace.run(); diff --git a/src/main/java/gtPlusPlus/core/lib/CORE.java b/src/main/java/gtPlusPlus/core/lib/CORE.java index 918c767a8c..71a812e95a 100644 --- a/src/main/java/gtPlusPlus/core/lib/CORE.java +++ b/src/main/java/gtPlusPlus/core/lib/CORE.java @@ -192,6 +192,7 @@ public class CORE { public static boolean enableMultiblock_MultiTank = true; public static boolean enableMultiblock_PowerSubstation = true; public static boolean enableMultiblock_LiquidFluorideThoriumReactor = true; + public static boolean enableMultiblock_NuclearSaltProcessingPlant = true; public static boolean enableMultiblock_NuclearFuelRefinery = true; public static boolean enableMultiblock_TreeFarmer = true; public static boolean enableMultiblock_IndustrialSifter = true; diff --git a/src/main/java/gtPlusPlus/core/recipe/RECIPES_Machines.java b/src/main/java/gtPlusPlus/core/recipe/RECIPES_Machines.java index 92efee13b4..5f6a807746 100644 --- a/src/main/java/gtPlusPlus/core/recipe/RECIPES_Machines.java +++ b/src/main/java/gtPlusPlus/core/recipe/RECIPES_Machines.java @@ -120,6 +120,9 @@ public class RECIPES_Machines { public static ItemStack RECIPE_LFTROuterCasing; public static ItemStack RECIPE_LFTRInnerCasing; + // Nuclear Salt Processing Plant + public static ItemStack RECIPE_SaltPlantController; + // Milling public static ItemStack RECIPE_ISAMill_Controller; public static ItemStack RECIPE_ISAMill_Gearbox; @@ -2451,6 +2454,21 @@ public class RECIPES_Machines { ALLOY.HS188A.getPlateDouble(1), CI.getFieldGenerator(5, 1), GregtechItemList.ReactorProcessingUnit_ZPM.get(1)); + + // Nuclear Salt Processing Plant Controller + RECIPE_SaltPlantController = GregtechItemList.Nuclear_Salt_Processing_Plant.get(1); + + RecipeUtils.addShapedGregtechRecipe( + "plateOsmiridium", + GregtechItemList.ReactorProcessingUnit_IV.get(1), + "plateOsmiridium", + "plateRuridit", + CI.getTieredCircuitOreDictName(7), + "plateRuridit", + "plateOsmiridium", + GregtechItemList.ColdTrap_IV.get(1), + "plateOsmiridium", + RECIPE_SaltPlantController); } // Shelves diff --git a/src/main/java/gtPlusPlus/nei/NEI_IMC_Sender.java b/src/main/java/gtPlusPlus/nei/NEI_IMC_Sender.java index 29f850a76c..3d54c9e7e1 100644 --- a/src/main/java/gtPlusPlus/nei/NEI_IMC_Sender.java +++ b/src/main/java/gtPlusPlus/nei/NEI_IMC_Sender.java @@ -56,6 +56,9 @@ public class NEI_IMC_Sender { sendCatalyst("gtpp.recipe.reactorprocessingunit", "gregtech:gt.blockmachines:31031"); sendCatalyst("gtpp.recipe.reactorprocessingunit", "gregtech:gt.blockmachines:31032"); + sendHandler("gtpp.recipe.nuclearsaltprocessingplant", "gregtech:gt.blockmachines:749"); + sendCatalyst("gtpp.recipe.nuclearsaltprocessingplant", "gregtech:gt.blockmachines:749"); + sendHandler("gtpp.recipe.treefarm", "gregtech:gt.blockmachines:836"); sendCatalyst("gtpp.recipe.treefarm", "gregtech:gt.blockmachines:836"); diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java b/src/main/java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java index 4d9646357f..e341ee5a8c 100644 --- a/src/main/java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java +++ b/src/main/java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java @@ -309,6 +309,9 @@ public enum GregtechItemList implements GregtechItemContainer { Casing_Reactor_I, Casing_Reactor_II, + // Nuclear Salt Processing Plant + Nuclear_Salt_Processing_Plant, + // Multitank /* Industrial_MultiTank, */ Industrial_MultiTankDense, diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_NuclearSaltProcessingPlant.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_NuclearSaltProcessingPlant.java new file mode 100644 index 0000000000..9f22887036 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_NuclearSaltProcessingPlant.java @@ -0,0 +1,261 @@ +package gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.processing; + +import static com.gtnewhorizon.structurelib.structure.StructureUtility.*; +import static gregtech.api.enums.GT_HatchElement.Energy; +import static gregtech.api.enums.GT_HatchElement.InputBus; +import static gregtech.api.enums.GT_HatchElement.InputHatch; +import static gregtech.api.enums.GT_HatchElement.Maintenance; +import static gregtech.api.enums.GT_HatchElement.Muffler; +import static gregtech.api.enums.GT_HatchElement.OutputBus; +import static gregtech.api.enums.GT_HatchElement.OutputHatch; +import static gregtech.api.util.GT_StructureUtility.buildHatchAdder; + +import java.util.ArrayList; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable; +import com.gtnewhorizon.structurelib.structure.IStructureDefinition; +import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment; +import com.gtnewhorizon.structurelib.structure.StructureDefinition; + +import gregtech.api.GregTech_API; +import gregtech.api.enums.TAE; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_InputBus; +import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; +import gtPlusPlus.core.block.ModBlocks; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase; + +public class GregtechMetaTileEntity_NuclearSaltProcessingPlant + extends GregtechMeta_MultiBlockBase<GregtechMetaTileEntity_NuclearSaltProcessingPlant> + implements ISurvivalConstructable { + + protected GT_Recipe lastRecipeToBuffer; + private int casing; + private static IStructureDefinition<GregtechMetaTileEntity_NuclearSaltProcessingPlant> STRUCTURE_DEFINITION = null; + + public GregtechMetaTileEntity_NuclearSaltProcessingPlant(int aID, String aName, String aNameRegional) { + super(aID, aName, aNameRegional); + } + + public GregtechMetaTileEntity_NuclearSaltProcessingPlant(String mName) { + super(mName); + } + + @Override + public String getMachineType() { + return "Reactor Processing Unit, Cold Trap"; + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity tileEntity) { + return new GregtechMetaTileEntity_NuclearSaltProcessingPlant(this.mName); + } + + @Override + public int getMaxEfficiency(ItemStack itemStack) { + return 10000; + } + + @Override + public int getPollutionPerSecond(ItemStack aStack) { + return CORE.ConfigSwitches.pollutionPerSecondMultiAutoCrafter; + } + + @Override + protected GT_Multiblock_Tooltip_Builder createTooltip() { + GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + tt.addMachineType(getMachineType()).addInfo("Controller Block for the Nuclear Salt Processing Plant") + .addInfo("Processes depleted nuclear salts that come from the LFTR") + .addInfo("Handles the recipes of the Reactor Processor Unit and Cold Trap") + .addInfo("Only Thermally Insulated Casings can be replaced with hatches") + .addInfo("Mufflers on top, Energy Hatches on bottom, exactly 2 of each are required") + .addInfo("Maintenance Hatch goes on the back, opposite of the controller block") + .addInfo("Inputs go on the left side of the multi, outputs on the right side") + .addInfo("150% faster than using single block machines of the same voltage") + .addInfo("Processes two items per voltage tier").addPollutionAmount(getPollutionPerSecond(null)) + .addSeparator().beginStructureBlock(3, 3, 3, true).addController("Front Center") + .addCasingInfoMin("IV Machine Casing", 58, false) + .addCasingInfoMin("Thermally Insulated Casing", 1, false).addInputBus("Left Half", 2) + .addInputHatch("Left Half", 2).addOutputBus("Right Half", 3).addOutputHatch("Right Half", 3) + .addMufflerHatch("Top Side, 2 Required", 4).addEnergyHatch("Bottom Side, 2 Required", 5) + .addMaintenanceHatch("Back Side, Opposite of Controller", 6) + .toolTipFinisher(CORE.GT_Tooltip_Builder.get()); + return tt; + } + + @Override + protected IIconContainer getActiveOverlay() { + return Textures.BlockIcons.OVERLAY_FRONT_DISASSEMBLER_ACTIVE; + } + + @Override + protected IIconContainer getInactiveOverlay() { + return Textures.BlockIcons.OVERLAY_FRONT_DISASSEMBLER; + } + + @Override + protected int getCasingTextureId() { + return TAE.getIndexFromPage(0, 10); + } + + @Override + public IStructureDefinition<GregtechMetaTileEntity_NuclearSaltProcessingPlant> getStructureDefinition() { + if (STRUCTURE_DEFINITION == null) { + STRUCTURE_DEFINITION = StructureDefinition.<GregtechMetaTileEntity_NuclearSaltProcessingPlant>builder() + .addShape( + mName, + transpose( + new String[][] { { "AAA AAA", "ADA ADA", "AAA AAA" }, + { "ABBA ACCA", "B AAA C", "ABBA ACCA" }, + { "ABBB~CCCA", "B C", "ABBBFCCCA" }, + { "ABBA ACCA", "B AAA C", "ABBA ACCA" }, + { "AAA AAA", "AEA AEA", "AAA AAA" } })) + .addElement('A', ofBlock(GregTech_API.sBlockCasings1, 5)) + .addElement( + 'B', + buildHatchAdder(GregtechMetaTileEntity_NuclearSaltProcessingPlant.class) + .atLeast(InputBus, InputHatch).casingIndex(TAE.getIndexFromPage(0, 10)).dot(2) + .buildAndChain( + onElementPass( + x -> ++x.casing, + ofBlock(ModBlocks.blockSpecialMultiCasings, 8)))) + .addElement( + 'C', + buildHatchAdder(GregtechMetaTileEntity_NuclearSaltProcessingPlant.class) + .atLeast(OutputBus, OutputHatch).casingIndex(TAE.getIndexFromPage(0, 10)).dot(3) + .buildAndChain( + onElementPass( + x -> ++x.casing, + ofBlock(ModBlocks.blockSpecialMultiCasings, 8)))) + .addElement( + 'D', + buildHatchAdder(GregtechMetaTileEntity_NuclearSaltProcessingPlant.class).atLeast(Muffler) + .casingIndex(TAE.getIndexFromPage(0, 10)).dot(4).buildAndChain( + onElementPass( + x -> ++x.casing, + ofBlock(ModBlocks.blockSpecialMultiCasings, 8)))) + .addElement( + 'E', + buildHatchAdder(GregtechMetaTileEntity_NuclearSaltProcessingPlant.class).atLeast(Energy) + .casingIndex(TAE.getIndexFromPage(0, 10)).dot(5).buildAndChain( + onElementPass( + x -> ++x.casing, + ofBlock(ModBlocks.blockSpecialMultiCasings, 8)))) + .addElement( + 'F', + buildHatchAdder(GregtechMetaTileEntity_NuclearSaltProcessingPlant.class) + .atLeast(Maintenance).casingIndex(TAE.getIndexFromPage(0, 10)).dot(6).buildAndChain( + onElementPass( + x -> ++x.casing, + ofBlock(ModBlocks.blockSpecialMultiCasings, 8)))) + .build(); + } + return STRUCTURE_DEFINITION; + } + + @Override + public void construct(ItemStack itemStack, boolean hintsOnly) { + buildPiece(mName, itemStack, hintsOnly, 4, 2, 0); + } + + @Override + public int survivalConstruct(ItemStack itemStack, int elementBudget, ISurvivalBuildEnvironment env) { + if (mMachine) return -1; + return survivialBuildPiece(mName, itemStack, 4, 2, 0, elementBudget, env, false, true); + } + + @Override + public boolean checkMachine(IGregTechTileEntity baseMetaTileEntity, ItemStack itemStack) { + casing = 0; + return checkPiece(mName, 4, 2, 0) && checkHatch(); + } + + @Override + public boolean checkHatch() { + return mEnergyHatches.size() == 2 && mMufflerHatches.size() == 2 && super.checkHatch(); + } + + @Override + public GT_Recipe.GT_Recipe_Map getRecipeMap() { + return gregtech.api.util.GTPP_Recipe.GTPP_Recipe_Map.sNuclearSaltProcessingPlantRecipes; + } + + @Override + public boolean checkRecipe(final ItemStack itemStack) { + if (inputSeparation) { + for (GT_MetaTileEntity_Hatch_InputBus tBus : mInputBusses) { + ArrayList<ItemStack> rList = new ArrayList<>(); + for (int i = tBus.getBaseMetaTileEntity().getSizeInventory() - 1; i >= 0; i--) { + if (tBus.getBaseMetaTileEntity().getStackInSlot(i) != null) + rList.add(tBus.getBaseMetaTileEntity().getStackInSlot(i)); + } + + if (checkRecipeGeneric( + rList.toArray(new ItemStack[0]), + getStoredFluids().toArray(new FluidStack[0]), + getMaxParallelRecipes(), + getEuDiscountForParallelism(), + 150, + 10000)) { + return true; + } + } + + return checkRecipeGeneric( + new ItemStack[0], + getStoredFluids().toArray(new FluidStack[0]), + getMaxParallelRecipes(), + getEuDiscountForParallelism(), + 150, + 10000); + } else { + return checkRecipeGeneric( + getStoredInputs().toArray(new ItemStack[0]), + getStoredFluids().toArray(new FluidStack[0]), + getMaxParallelRecipes(), + getEuDiscountForParallelism(), + 150, + 10000); + } + } + + @Override + public int getMaxParallelRecipes() { + return 2 * (Math.max(1, GT_Utility.getTier(getMaxInputVoltage()))); + } + + @Override + public int getEuDiscountForParallelism() { + return 100; + } + + @Override + public String[] getExtraInfoData() { + final String running = (this.mMaxProgresstime > 0 ? "Salt Plant running" : "Salt Plant stopped"); + final String maintenance = (this.getIdealStatus() == this.getRepairStatus() ? "No Maintenance issues" + : "Needs Maintenance"); + String tSpecialText; + + if (lastRecipeToBuffer != null && lastRecipeToBuffer.mOutputs[0].getDisplayName() != null) { + tSpecialText = "Currently processing: " + lastRecipeToBuffer.mOutputs[0].getDisplayName(); + } else { + tSpecialText = "Currently processing: Nothing"; + } + + return new String[] { "Nuclear Salt Processing Plant", running, maintenance, tSpecialText }; + } + + @Override + protected boolean isInputSeparationButtonEnabled() { + return true; + } +} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_NuclearFuelProcessing.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_NuclearFuelProcessing.java index e85f4989d7..e088b50880 100644 --- a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_NuclearFuelProcessing.java +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_NuclearFuelProcessing.java @@ -188,9 +188,8 @@ public class RecipeLoader_NuclearFuelProcessing { new ItemStack[] { ELEMENT.getInstance().FLUORINE.getCell(1), FLUORIDES.URANIUM_HEXAFLUORIDE.getCell(2), ELEMENT.getInstance().PHOSPHORUS.getDust(1), ELEMENT.getInstance().PHOSPHORUS.getDust(1), ELEMENT.getInstance().PHOSPHORUS.getDust(1), ELEMENT.getInstance().PHOSPHORUS.getDust(1), - ELEMENT.getInstance().PHOSPHORUS.getDust(1), ELEMENT.getInstance().PHOSPHORUS.getDust(1), - ELEMENT.getInstance().PHOSPHORUS.getDust(1) }, - new int[] { 10000, 10000, 5000, 5000, 5000, 5000, 5000, 5000, 5000 }, + ELEMENT.getInstance().PHOSPHORUS.getDust(1), ELEMENT.getInstance().PHOSPHORUS.getDust(1) }, + new int[] { 10000, 10000, 5000, 5000, 5000, 5000, 5000, 5000 }, FLUORIDES.SODIUM_FLUORIDE.getFluidStack(2000), 20 * 60 * 10, MaterialUtils.getVoltageForTier(4)); diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/recipes/GregtechRecipeAdder.java b/src/main/java/gtPlusPlus/xmod/gregtech/recipes/GregtechRecipeAdder.java index 034f9550f4..2cb2ed2c5f 100644 --- a/src/main/java/gtPlusPlus/xmod/gregtech/recipes/GregtechRecipeAdder.java +++ b/src/main/java/gtPlusPlus/xmod/gregtech/recipes/GregtechRecipeAdder.java @@ -1162,6 +1162,37 @@ public class GregtechRecipeAdder implements IGregtech_RecipeAdder { return true; } + public boolean addNuclearSaltProcessingPlantRecipe(ItemStack[] aInputs, FluidStack[] aFluidInputs, + FluidStack[] aFluidOutputs, ItemStack[] aOutputs, int[] aChances, int aDuration, int aEUtick, + int aSpecial) { + if (areItemsAndFluidsBothNull(aInputs, aFluidInputs) || areItemsAndFluidsBothNull(aOutputs, aFluidOutputs) + || aEUtick <= 0) { + return false; + } + if (!ItemUtils.checkForInvalidItems(aInputs, aOutputs)) { + Logger.INFO("[Recipe] Error generating Salt Plant recipe."); + Logger.INFO("Inputs: " + ItemUtils.getArrayStackNames(aInputs)); + Logger.INFO("Fluid Inputs: " + ItemUtils.getArrayStackNames(aFluidInputs)); + Logger.INFO("Outputs: " + ItemUtils.getArrayStackNames(aOutputs)); + Logger.INFO("Fluid Outputs: " + ItemUtils.getArrayStackNames(aFluidOutputs)); + return false; + } + + GTPP_Recipe aRecipe = new GTPP_Recipe( + false, + aInputs, + aOutputs, + null, + aChances, + aFluidInputs, + aFluidOutputs, + aDuration, + aEUtick, + aSpecial); + GTPP_Recipe.GTPP_Recipe_Map.sNuclearSaltProcessingPlantRecipes.addRecipe(aRecipe); + return true; + } + @Override public boolean addFluidHeaterRecipe(ItemStack aInput, FluidStack aFluidInput, FluidStack aOutput, int aDuration, int aEUt) { diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechNuclearSaltProcessingPlant.java b/src/main/java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechNuclearSaltProcessingPlant.java new file mode 100644 index 0000000000..4cd9b63567 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechNuclearSaltProcessingPlant.java @@ -0,0 +1,21 @@ +package gtPlusPlus.xmod.gregtech.registration.gregtech; + +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList; +import gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.processing.GregtechMetaTileEntity_NuclearSaltProcessingPlant; + +public class GregtechNuclearSaltProcessingPlant { + + public static void run() { + Logger.INFO("Gregtech5u Content | Registering Nuclear Salt Processing Plant Multiblock."); + if (CORE.ConfigSwitches.enableMultiblock_NuclearSaltProcessingPlant) { + // Nuclear Salt Processing Plant Multiblock + GregtechItemList.Nuclear_Salt_Processing_Plant.set( + new GregtechMetaTileEntity_NuclearSaltProcessingPlant( + 749, + "nuclearsaltprocessingplant.controller.tier.single", + "Nuclear Salt Processing Plant").getStackForm(1L)); + } + } +} |