From 1489795e9404fa59b68a84e5da90c242a69aeced Mon Sep 17 00:00:00 2001 From: GlodBlock <1356392126@qq.com> Date: Sat, 22 Jan 2022 11:44:22 +0800 Subject: gui and structure stuff of XHE --- .../blocks/tileEntity/ExtremeHeatExchanger.java | 249 ++++++++++++++++++++- .../crossmod/nei/ExtremeHeatExchangerHandler.java | 45 ++++ .../goodgenerator/crossmod/nei/NEI_Config.java | 1 + src/main/java/goodgenerator/loader/Loaders.java | 4 +- src/main/java/goodgenerator/util/ItemRefer.java | 2 + .../java/goodgenerator/util/MyRecipeAdder.java | 52 +++++ .../resources/assets/goodgenerator/lang/en_US.lang | 12 + .../textures/gui/extreme_heat_exchanger.png | Bin 0 -> 2279 bytes 8 files changed, 362 insertions(+), 3 deletions(-) create mode 100644 src/main/java/goodgenerator/crossmod/nei/ExtremeHeatExchangerHandler.java create mode 100644 src/main/resources/assets/goodgenerator/textures/gui/extreme_heat_exchanger.png (limited to 'src') diff --git a/src/main/java/goodgenerator/blocks/tileEntity/ExtremeHeatExchanger.java b/src/main/java/goodgenerator/blocks/tileEntity/ExtremeHeatExchanger.java index 95fd4b3396..02d0cfa17a 100644 --- a/src/main/java/goodgenerator/blocks/tileEntity/ExtremeHeatExchanger.java +++ b/src/main/java/goodgenerator/blocks/tileEntity/ExtremeHeatExchanger.java @@ -3,14 +3,43 @@ package goodgenerator.blocks.tileEntity; import com.github.technus.tectech.thing.metaTileEntity.multi.base.GT_MetaTileEntity_MultiblockBase_EM; import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable; import com.gtnewhorizon.structurelib.structure.IStructureDefinition; +import com.gtnewhorizon.structurelib.structure.StructureDefinition; +import goodgenerator.loader.Loaders; +import goodgenerator.util.DescTextLocalization; +import gregtech.api.GregTech_API; +import gregtech.api.interfaces.ITexture; import gregtech.api.interfaces.metatileentity.IMetaTileEntity; import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import gregtech.api.util.GT_Utility; +import ic2.core.Ic2Items; +import net.minecraft.block.Block; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.StatCollector; +import org.lwjgl.input.Keyboard; + +import static com.gtnewhorizon.structurelib.structure.StructureUtility.*; +import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO; +import static gregtech.api.enums.Textures.BlockIcons.*; +import static gregtech.api.util.GT_StructureUtility.ofHatchAdder; public class ExtremeHeatExchanger extends GT_MetaTileEntity_MultiblockBase_EM implements IConstructable { protected IStructureDefinition multiDefinition = null; + public static float penalty_per_config = 0.015f; + protected int casingAmount = 0; + protected GT_MetaTileEntity_Hatch_Input mHotFluidHatch; + protected GT_MetaTileEntity_Hatch_Output mCooledFluidHatch; + private boolean transformed = false; + private int transformed_threshold = 0; + public ExtremeHeatExchanger(String name) { super(name); } @@ -20,17 +49,233 @@ public class ExtremeHeatExchanger extends GT_MetaTileEntity_MultiblockBase_EM im } @Override - public void construct(ItemStack stackSize, boolean hintsOnly) { + public IStructureDefinition getStructure_EM() { + if(multiDefinition == null) { + multiDefinition = StructureDefinition + .builder() + .addShape(mName, + transpose(new String[][]{ + {" CCC ", "TTTTT", "TTTTT", "TTTTT", "TTTTT", "TTTTT", "TTTTT", "TTTTT", "TTTTT", "TTTTT", " CCC "}, + {" CCC ", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", " CCC "}, + {" CFC ", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", " CEC "}, + {" CCC ", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", " CCC "}, + {" CCC ", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", "GWWWG", "GPPPG", " CCC "}, + {" C~C ", "BBBBB", "BBBBB", "BBBBB", "BBBBB", "BBBBB", "BBBBB", "BBBBB", "BBBBB", "BBBBB", " CCC "}, + }) + ).addElement( + 'B', + ofChain( + ofHatchAdder( + ExtremeHeatExchanger::addClassicInputToMachineList, 48, + 1 + ), + ofHatchAdder( + ExtremeHeatExchanger::addMaintenanceToMachineList, 48, + 1 + ), + onElementPass( + x -> x.casingAmount++, + ofBlock( + GregTech_API.sBlockCasings4, 0 + ) + ) + ) + ) + .addElement( + 'T', + ofChain( + ofHatchAdder( + ExtremeHeatExchanger::addClassicOutputToMachineList, 48, + 2 + ), + ofHatchAdder( + ExtremeHeatExchanger::addMaintenanceToMachineList, 48, + 2 + ), + onElementPass( + x -> x.casingAmount++, + ofBlock( + GregTech_API.sBlockCasings4, 0 + ) + ) + ) + ) + .addElement( + 'F', + ofHatchAdder( + ExtremeHeatExchanger::addHotFluidInputToMachineList, 48, + 3 + ) + ) + .addElement( + 'E', + ofHatchAdder( + ExtremeHeatExchanger::addColdFluidOutputToMachineList, 48, + 4 + ) + ) + .addElement( + 'C', + ofChain( + ofHatchAdder( + ExtremeHeatExchanger::addMaintenanceToMachineList, 48, + GregTech_API.sBlockCasings4, 0 + ), + onElementPass( + x -> x.casingAmount++, + ofBlock( + GregTech_API.sBlockCasings4, 0 + ) + ) + ) + + ) + .addElement( + 'G', + ofBlock( + Block.getBlockFromItem(Ic2Items.reinforcedGlass.getItem()), 0 + ) + ) + .addElement( + 'P', + ofBlock( + GregTech_API.sBlockCasings2,15 + ) + ) + .addElement( + 'W', + ofBlock( + Loaders.pressureResistantWalls, 0 + ) + ) + .build(); + } + return multiDefinition; + } + + public boolean addHotFluidInputToMachineList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) { + if (aTileEntity == null) return false; + IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity(); + if (aMetaTileEntity == null) return false; + if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Input) { + ((GT_MetaTileEntity_Hatch) aMetaTileEntity).updateTexture(aBaseCasingIndex); + mHotFluidHatch = (GT_MetaTileEntity_Hatch_Input) aMetaTileEntity; + return true; + } + return false; + } + + public boolean addColdFluidOutputToMachineList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) { + if (aTileEntity == null) return false; + IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity(); + if (aMetaTileEntity == null) return false; + if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Output) { + ((GT_MetaTileEntity_Hatch) aMetaTileEntity).updateTexture(aBaseCasingIndex); + mCooledFluidHatch = (GT_MetaTileEntity_Hatch_Output) aMetaTileEntity; + return true; + } + return false; + } + @Override + public void loadNBTData(NBTTagCompound aNBT) { + transformed = aNBT.getBoolean("transformed"); + super.loadNBTData(aNBT); + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + aNBT.setBoolean("transformed", transformed); + super.saveNBTData(aNBT); + } + + @Override + public boolean checkMachine_EM(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) { + this.casingAmount = 0; + mCooledFluidHatch = null; + mHotFluidHatch = null; + return structureCheck_EM(mName, 2, 5, 0) && mMaintenanceHatches.size() == 1 && casingAmount >= 25; + } + + @Override + public String[] getDescription() { + final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + tt.addMachineType("Heat Exchanger/Plasma Heat Exchanger") + .addInfo("Controller block for the Extreme Heat Exchanger.") + .addInfo("Accept Hot fluid like lava, hot coolant or plasma.") + .addInfo("Output SC Steam/SH Steam/Steam ot other working fluid.") + .addInfo("Works like the normal Heat Exchanger with lava and hot coolant,") + .addInfo("but max input/output speed and threshold value is x10.") + .addInfo("Check NEI for more info.") + .addInfo(BLUE_PRINT_INFO) + .addSeparator() + .addController("Front bottom") + .addOtherStructurePart("Input Hatch: distilled water or other working fluid", "Hint block with dot 1") + .addOtherStructurePart("Output Hatch: SC Steam/SH Steam/Steam or other heated working fluid", "Hint block with dot 2") + .addOtherStructurePart("Input Hatch: Hot fluid or plasma", "Hint block with dot 3") + .addOtherStructurePart("Output Hatch: Cold fluid", "Hint block with dot 4") + .addMaintenanceHatch("Any Casing") + .addCasingInfo("obust Tungstensteel Machine Casings", 25) + .toolTipFinisher("Good Generator"); + if (!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) { + return tt.getInformation(); + } else { + return tt.getStructureInformation(); + } + } + + @Override + public boolean checkRecipe_EM(ItemStack aStack) { + this.mEfficiencyIncrease = 80; + return true; + } + + @Override + public void construct(ItemStack stackSize, boolean hintsOnly) { + structureBuild_EM(mName, 2, 5, 0, hintsOnly, stackSize); } @Override public String[] getStructureDescription(ItemStack stackSize) { - return new String[0]; + return DescTextLocalization.addText("ExtremeHeatExchanger.hint", 6); } @Override public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { return new ExtremeHeatExchanger(mName); } + + @Override + public int getMaxEfficiency(ItemStack aStack) { + return 10000; + } + + @Override + public String[] getInfoData() { + return new String[]{ + StatCollector.translateToLocal("GT5U.multiblock.Progress") + ": " + + EnumChatFormatting.GREEN + GT_Utility.formatNumbers(mProgresstime / 20) + EnumChatFormatting.RESET + " s / " + + EnumChatFormatting.YELLOW + GT_Utility.formatNumbers(mMaxProgresstime / 20) + EnumChatFormatting.RESET + " s", + StatCollector.translateToLocal("GT5U.multiblock.problems") + ": " + + EnumChatFormatting.RED + (getIdealStatus() - getRepairStatus()) + EnumChatFormatting.RESET + " " + + StatCollector.translateToLocal("GT5U.multiblock.efficiency") + ": " + + EnumChatFormatting.YELLOW + mEfficiency / 100.0F + EnumChatFormatting.RESET + " %" + }; + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) { + if (aSide == aFacing) { + if (aActive) + return new ITexture[]{ + casingTexturePages[0][48], + TextureFactory.builder().addIcon(OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE).extFacing().build(), + TextureFactory.builder().addIcon(OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE_GLOW).extFacing().glow().build()}; + return new ITexture[]{ + casingTexturePages[0][48], + TextureFactory.builder().addIcon(OVERLAY_FRONT_HEAT_EXCHANGER).extFacing().build(), + TextureFactory.builder().addIcon(OVERLAY_FRONT_HEAT_EXCHANGER_GLOW).extFacing().glow().build()}; + } + return new ITexture[]{casingTexturePages[0][48]}; + } } diff --git a/src/main/java/goodgenerator/crossmod/nei/ExtremeHeatExchangerHandler.java b/src/main/java/goodgenerator/crossmod/nei/ExtremeHeatExchangerHandler.java new file mode 100644 index 0000000000..0bf7726544 --- /dev/null +++ b/src/main/java/goodgenerator/crossmod/nei/ExtremeHeatExchangerHandler.java @@ -0,0 +1,45 @@ +package goodgenerator.crossmod.nei; + +import codechicken.nei.recipe.GuiCraftingRecipe; +import codechicken.nei.recipe.GuiUsageRecipe; +import codechicken.nei.recipe.TemplateRecipeHandler; +import cpw.mods.fml.common.event.FMLInterModComms; +import gregtech.api.enums.GT_Values; +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; +import gregtech.nei.GT_NEI_DefaultHandler; +import net.minecraft.util.StatCollector; +import net.minecraftforge.fluids.FluidStack; + +import java.awt.*; + +public class ExtremeHeatExchangerHandler extends GT_NEI_DefaultHandler { + + public ExtremeHeatExchangerHandler(GT_Recipe.GT_Recipe_Map aRecipeMap) { + super(aRecipeMap); + this.transferRects.add(new TemplateRecipeHandler.RecipeTransferRect(new Rectangle(65, 13, 36, 18), this.getOverlayIdentifier())); + if (!NEI_Config.isAdded) { + FMLInterModComms.sendRuntimeMessage(GT_Values.GT, "NEIPlugins", "register-crafting-handler", "gregtech@" + this.getRecipeName() + "@" + this.getOverlayIdentifier()); + GuiCraftingRecipe.craftinghandlers.add(this); + GuiUsageRecipe.usagehandlers.add(this); + } + } + + @Override + public TemplateRecipeHandler newInstance() { + return new ExtremeHeatExchangerHandler(this.mRecipeMap); + } + + @Override + public void drawExtras(int aRecipeIndex) { + FluidStack[] Inputs = ((CachedDefaultRecipe) this.arecipes.get(aRecipeIndex)).mRecipe.mFluidInputs; + FluidStack[] Outputs = ((CachedDefaultRecipe) this.arecipes.get(aRecipeIndex)).mRecipe.mFluidOutputs; + int Threshold = ((CachedDefaultRecipe) this.arecipes.get(aRecipeIndex)).mRecipe.mSpecialValue; + drawText(10, 73, StatCollector.translateToLocal("value.extreme_heat_exchanger.0") + " " + GT_Utility.formatNumbers(Inputs[0].amount) + " L/s", -16777216); + drawText(10, 83, StatCollector.translateToLocal("value.extreme_heat_exchanger.1") + " " + GT_Utility.formatNumbers(Inputs[1].amount) + " L/s", -16777216); + drawText(10, 93, StatCollector.translateToLocal("value.extreme_heat_exchanger.2") + " " + GT_Utility.formatNumbers(Outputs[0].amount) + " L/s", -16777216); + drawText(10, 103, StatCollector.translateToLocal("value.extreme_heat_exchanger.3") + " " + GT_Utility.formatNumbers(Outputs[1].amount) + " L/s", -16777216); + drawText(10, 113, StatCollector.translateToLocal("value.extreme_heat_exchanger.4") + " " + Threshold + " L/s", -16777216); + } + +} diff --git a/src/main/java/goodgenerator/crossmod/nei/NEI_Config.java b/src/main/java/goodgenerator/crossmod/nei/NEI_Config.java index d5c71bc197..a344fc89fe 100644 --- a/src/main/java/goodgenerator/crossmod/nei/NEI_Config.java +++ b/src/main/java/goodgenerator/crossmod/nei/NEI_Config.java @@ -15,6 +15,7 @@ public class NEI_Config implements IConfigureNEI { public void loadConfig() { NEI_Config.isAdded = false; new NeutronActivatorHandler(MyRecipeAdder.instance.NA); + new ExtremeHeatExchangerHandler(MyRecipeAdder.instance.XHE); NEI_Config.isAdded = true; } diff --git a/src/main/java/goodgenerator/loader/Loaders.java b/src/main/java/goodgenerator/loader/Loaders.java index 6b0b3477bc..86e706d891 100644 --- a/src/main/java/goodgenerator/loader/Loaders.java +++ b/src/main/java/goodgenerator/loader/Loaders.java @@ -94,6 +94,7 @@ public class Loaders { public static ItemStack YFT; public static ItemStack YFH; public static ItemStack SCTurbine; + public static ItemStack XHE; public static ItemStack[] NeutronAccelerators = new ItemStack[9]; public static ItemStack[] Generator_Diesel = new ItemStack[2]; @@ -112,6 +113,7 @@ public class Loaders { Loaders.YFT = new YottaFluidTank(IDOffset + 13, "YottaFluidTank", "YOTTank").getStackForm(1L); Loaders.YFH = new YOTTAHatch(IDOffset + 14, "YottaFluidTankHatch", "YOTHatch", 5).getStackForm(1L); Loaders.SCTurbine = new SupercriticalFluidTurbine(IDOffset + 15, "SupercriticalFluidTurbine", "SC Fluid Turbine").getStackForm(1L); + Loaders.XHE = new ExtremeHeatExchanger(IDOffset + 16, "ExtremeHeatExchanger", "Extreme Heat Exchanger").getStackForm(1L); Loaders.Generator_Diesel[0] = new DieselGenerator(1113, "basicgenerator.diesel.tier.04", "Turbo Supercharging Combustion Generator", 4).getStackForm(1L); Loaders.Generator_Diesel[1] = new DieselGenerator(1114, "basicgenerator.diesel.tier.05", "Ultimate Chemical Energy Releaser", 5).getStackForm(1L); } @@ -174,6 +176,7 @@ public class Loaders { GameRegistry.registerBlock(magicCasing, MyItemBlocks.class, "magicCasing"); GameRegistry.registerBlock(essentiaCell, MyItemBlocks.class, "essentiaCell"); GameRegistry.registerBlock(essentiaHatch, MyItemBlocks.class, "essentiaHatch"); + Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][0] = TextureFactory.of(magicCasing); } } @@ -184,7 +187,6 @@ public class Loaders { public static void addTexturePage() { if (Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage] == null){ Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage] = new ITexture[128]; - Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][0] = TextureFactory.of(magicCasing); Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][1] = TextureFactory.of(yottaFluidTankCasing); Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][2] = TextureFactory.of(supercriticalFluidTurbineCasing); } diff --git a/src/main/java/goodgenerator/util/ItemRefer.java b/src/main/java/goodgenerator/util/ItemRefer.java index f666fea41d..8db9de3479 100644 --- a/src/main/java/goodgenerator/util/ItemRefer.java +++ b/src/main/java/goodgenerator/util/ItemRefer.java @@ -1,5 +1,6 @@ package goodgenerator.util; +import goodgenerator.blocks.tileEntity.ExtremeHeatExchanger; import gregtech.api.util.GT_Utility; import net.minecraft.block.Block; import net.minecraft.item.Item; @@ -105,6 +106,7 @@ public final class ItemRefer { public static ItemRefer Combustion_Generator_EV = getItemStack(Generator_Diesel[0]); public static ItemRefer Combustion_Generator_IV = getItemStack(Generator_Diesel[1]); public static ItemRefer SC_Fluid_Turbine = getItemStack(SCTurbine); + public static ItemRefer Extreme_Heat_Exchanger = getItemStack(XHE); private Item mItem = null; private Block mBlock = null; diff --git a/src/main/java/goodgenerator/util/MyRecipeAdder.java b/src/main/java/goodgenerator/util/MyRecipeAdder.java index 056d220275..59bce6220c 100644 --- a/src/main/java/goodgenerator/util/MyRecipeAdder.java +++ b/src/main/java/goodgenerator/util/MyRecipeAdder.java @@ -1,10 +1,13 @@ package goodgenerator.util; +import codechicken.nei.PositionedStack; import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; import net.minecraft.item.ItemStack; import net.minecraft.util.StatCollector; import net.minecraftforge.fluids.FluidStack; +import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; @@ -52,6 +55,18 @@ public class MyRecipeAdder { false ); + public final ExtremeHeatExchangerMapper XHE = new ExtremeHeatExchangerMapper( + new HashSet<>(50), + "gg.recipe.extreme_heat_exchanger", + StatCollector.translateToLocal("tile.extreme_heat_exchanger"), + null, + "goodgenerator:textures/gui/extreme_heat_exchanger", + 0, 0, 0, 0, 0, + null, 0, null, + false, + false + ); + public static class liquidMentalFuelMapper extends GT_Recipe.GT_Recipe_Map_Fuel{ public liquidMentalFuelMapper(Collection aRecipeList, String aUnlocalizedName, String aLocalName, String aNEIName, String aNEIGUIPath, int aUsualInputCount, int aUsualOutputCount, int aMinimalInputItems, int aMinimalInputFluids, int aAmperage, String aNEISpecialValuePre, int aNEISpecialValueMultiplier, String aNEISpecialValuePost, boolean aShowVoltageAmperageInNEI, boolean aNEIAllowed){ super(aRecipeList, aUnlocalizedName, aLocalName, aNEIName, aNEIGUIPath, aUsualInputCount, aUsualOutputCount, aMinimalInputItems, aMinimalInputFluids, aAmperage, aNEISpecialValuePre, aNEISpecialValueMultiplier, aNEISpecialValuePost, aShowVoltageAmperageInNEI, aNEIAllowed); @@ -97,4 +112,41 @@ public class MyRecipeAdder { if (minNKE >= maxNKE) minNKE = maxNKE - 1; NA.addNARecipe(input1, input2, output1, output2, ticks, maxNKE * 10000 + minNKE); } + + public static class ExtremeHeatExchangerMapper extends GT_Recipe.GT_Recipe_Map { + public ExtremeHeatExchangerMapper(Collection aRecipeList, String aUnlocalizedName, String aLocalName, String aNEIName, String aNEIGUIPath, int aUsualInputCount, int aUsualOutputCount, int aMinimalInputItems, int aMinimalInputFluids, int aAmperage, String aNEISpecialValuePre, int aNEISpecialValueMultiplier, String aNEISpecialValuePost, boolean aShowVoltageAmperageInNEI, boolean aNEIAllowed){ + super(aRecipeList, aUnlocalizedName, aLocalName, aNEIName, aNEIGUIPath, aUsualInputCount, aUsualOutputCount, aMinimalInputItems, aMinimalInputFluids, aAmperage, aNEISpecialValuePre, aNEISpecialValueMultiplier, aNEISpecialValuePost, aShowVoltageAmperageInNEI, aNEIAllowed); + } + + @Override + public GT_Recipe addRecipe(boolean aOptimize, ItemStack[] aInputs, ItemStack[] aOutputs, Object aSpecial, int[] aOutputChances, FluidStack[] aFluidInputs, FluidStack[] aFluidOutputs, int aDuration, int aEUt, int aSpecialValue) { + return addRecipe(new ExtremeHeatExchangerRecipe(aFluidInputs, aFluidOutputs, aSpecialValue)); + } + } + + public static class ExtremeHeatExchangerRecipe extends GT_Recipe { + + public ExtremeHeatExchangerRecipe(FluidStack[] input, FluidStack[] output, int special) { + super(false, null, null, null, null, input, output, 0, 0, special); + } + + @Override + public ArrayList getInputPositionedStacks() { + ArrayList inputStacks = new ArrayList<>(); + if (this.mFluidInputs != null && this.mFluidInputs.length == 2) { + inputStacks.add(new PositionedStack(GT_Utility.getFluidDisplayStack(this.mFluidInputs[0], true), 22, 3)); + inputStacks.add(new PositionedStack(GT_Utility.getFluidDisplayStack(this.mFluidInputs[1], true), 22, 27)); + } + if (this.mFluidOutputs != null && this.mFluidOutputs.length == 3) { + inputStacks.add(new PositionedStack(GT_Utility.getFluidDisplayStack(this.mFluidOutputs[0], true), 124, 3)); + inputStacks.add(new PositionedStack(GT_Utility.getFluidDisplayStack(this.mFluidOutputs[1], true), 124, 21)); + inputStacks.add(new PositionedStack(GT_Utility.getFluidDisplayStack(this.mFluidOutputs[2], true), 124, 44)); + } + return inputStacks; + } + } + + public void addExtremeHeatExchangerRecipe(FluidStack HotFluid, FluidStack ColdFluid, FluidStack WorkFluid, FluidStack HeatedWorkFluid, FluidStack OverHeatedWorkFluid, int Threshold) { + XHE.addRecipe(false, null, null, null, null, new FluidStack[]{HotFluid, WorkFluid}, new FluidStack[]{HeatedWorkFluid, OverHeatedWorkFluid, ColdFluid}, 0, 0, Threshold); + } } diff --git a/src/main/resources/assets/goodgenerator/lang/en_US.lang b/src/main/resources/assets/goodgenerator/lang/en_US.lang index 3854d37ac0..226e1643f3 100644 --- a/src/main/resources/assets/goodgenerator/lang/en_US.lang +++ b/src/main/resources/assets/goodgenerator/lang/en_US.lang @@ -208,12 +208,18 @@ gui.YOTTank.2=Stored: tile.recipe.naquadah_reactor=Large Naquadah Reactor tile.naquadah_fuel_refine_factory=Naquadah Fuel Refine Factory tile.neutron_activator=Neutron Activator +tile.extreme_heat_exchanger=Extreme Heat Exchanger value.naquadah_reactor=Basic Output Voltage: value.naquadah_fuel_refine_factory.0=Need Tier value.naquadah_fuel_refine_factory.1= Coil value.neutron_activator.0=Minimum Neutron Kinetic Energy: value.neutron_activator.1=Maximum Neutron Kinetic Energy: value.neutron_activator.2= MeV +value.extreme_heat_exchanger.0=Max Hot Fluid Input: +value.extreme_heat_exchanger.1=Max Working Fluid Input: +value.extreme_heat_exchanger.2=Max Heated Working Fluid Output: +value.extreme_heat_exchanger.3=Max Overheated Working Fluid Output: +value.extreme_heat_exchanger.4=Threshold: #TecTech Structure Info FuelRefineFactory.hint.0=8x Field Restriction Glasses @@ -263,6 +269,12 @@ YOTTank.hint.3=9x Fluid Cell Block for every layer YOTTank.hint.4=1 - Input Hatch/YOTTank Casing YOTTank.hint.5=2 - Maintenance Hatch/YOTTank Casing YOTTank.hint.6=3 - Output Hatch/YOTHatch +ExtremeHeatExchanger.hint.0=At least 25x Robust Tungstensteel Machine Casings +ExtremeHeatExchanger.hint.1=1 - Input hatch for distilled water or other working fluid +ExtremeHeatExchanger.hint.2=2 - Output hatch for SC Steam/SH Steam/Steam or other heated working fluid +ExtremeHeatExchanger.hint.3=3 - Input hatch for hot fluid +ExtremeHeatExchanger.hint.4=4 - Output hatch for cold fluid +ExtremeHeatExchanger.hint.5=Any Casing - Maintenance Hatch #Chat largeessentiagenerator.chat= Installed! diff --git a/src/main/resources/assets/goodgenerator/textures/gui/extreme_heat_exchanger.png b/src/main/resources/assets/goodgenerator/textures/gui/extreme_heat_exchanger.png new file mode 100644 index 0000000000..dcbc004bb6 Binary files /dev/null and b/src/main/resources/assets/goodgenerator/textures/gui/extreme_heat_exchanger.png differ -- cgit