gui and structure stuff of XHE

8 files changed, 362 insertions, 3 deletions

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<ExtremeHeatExchanger> 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<ExtremeHeatExchanger> getStructure_EM() {
+        if(multiDefinition == null) {
+            multiDefinition = StructureDefinition
+                    .<ExtremeHeatExchanger>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<GT_Recipe> 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<GT_Recipe> 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<PositionedStack> getInputPositionedStacks() {
+            ArrayList<PositionedStack> 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
--- /dev/null
+++ b/src/main/resources/assets/goodgenerator/textures/gui/extreme_heat_exchanger.png