Thermal Boiler rework (#815)

* Migrate recipes to RA. Fix oredict of outputs.

* New recipe UI for NEI.

* Reworked processing logic.

* Display EU/t in WAILA + misc fixes

* Small spelling updates.

* Full rework of recipes.

* Reverted Pyrotheum recipe.

* Restored old recipes + cleanup.

5 files changed, 300 insertions, 278 deletions

diff --git a/src/main/java/gtPlusPlus/api/recipe/GTPPRecipeMaps.java b/src/main/java/gtPlusPlus/api/recipe/GTPPRecipeMaps.java
index 9d02865c5b..3977d69fe7 100644
--- a/src/main/java/gtPlusPlus/api/recipe/GTPPRecipeMaps.java
+++ b/src/main/java/gtPlusPlus/api/recipe/GTPPRecipeMaps.java
@@ -115,7 +115,7 @@ public class GTPPRecipeMaps {
             .of("gtpp.recipe.RTGgenerators", FuelBackend::new).maxIO(1, 0, 0, 0)
             .neiSpecialInfoFormatter(new SimpleSpecialValueFormatter("gtpp.nei.rtg.days", 365)).build();
     public static final RecipeMap<RecipeMapBackend> thermalBoilerRecipes = RecipeMapBuilder
-            .of("gtpp.recipe.thermalgeneratorfuel").maxIO(9, 9, 3, 3).frontend(LargeNEIFrontend::new).build();
+            .of("gtpp.recipe.thermalgeneratorfuel").maxIO(0, 9, 2, 3).frontend(ThermalBoilerFrontend::new).build();
     public static final RecipeMap<RecipeMapBackend> solarTowerRecipes = RecipeMapBuilder.of("gtpp.recipe.solartower")
             .maxIO(0, 0, 1, 1)
             .neiSpecialInfoFormatter(
diff --git a/src/main/java/gtPlusPlus/api/recipe/ThermalBoilerFrontend.java b/src/main/java/gtPlusPlus/api/recipe/ThermalBoilerFrontend.java
new file mode 100644
index 0000000000..9c78519765
--- /dev/null
+++ b/src/main/java/gtPlusPlus/api/recipe/ThermalBoilerFrontend.java
@@ -0,0 +1,60 @@
+package gtPlusPlus.api.recipe;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import com.gtnewhorizons.modularui.api.math.Pos2d;
+
+import gregtech.api.recipe.BasicUIPropertiesBuilder;
+import gregtech.api.recipe.NEIRecipePropertiesBuilder;
+import gregtech.api.recipe.maps.LargeNEIFrontend;
+import gregtech.api.util.MethodsReturnNonnullByDefault;
+import gregtech.common.gui.modularui.UIHelper;
+import gregtech.nei.RecipeDisplayInfo;
+import gregtech.nei.formatter.INEISpecialInfoFormatter;
+
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+public class ThermalBoilerFrontend extends LargeNEIFrontend {
+
+    private static final int tileSize = 18;
+    private static final int xOrigin = 16;
+    private static final int yOrigin = 8 + tileSize; // Aligned with second row of output items.
+    private static final int maxInputs = 3;
+
+    public ThermalBoilerFrontend(BasicUIPropertiesBuilder uiPropertiesBuilder,
+            NEIRecipePropertiesBuilder neiPropertiesBuilder) {
+        super(
+                uiPropertiesBuilder,
+                neiPropertiesBuilder.neiSpecialInfoFormatter(new ThermalBoilerSpecialValueFormatter()));
+    }
+
+    @Override
+    public List<Pos2d> getFluidInputPositions(int fluidInputCount) {
+        return UIHelper.getGridPositions(
+                fluidInputCount,
+                xOrigin + tileSize * (maxInputs - fluidInputCount),
+                yOrigin,
+                maxInputs);
+    }
+
+    private static class ThermalBoilerSpecialValueFormatter implements INEISpecialInfoFormatter {
+
+        @Override
+        public List<String> format(RecipeDisplayInfo recipeInfo) {
+            // TODO: Translation.
+            List<String> result = new ArrayList<>();
+            result.add("Steam output shown");
+            result.add("at maximum efficiency.");
+
+            if (recipeInfo.recipe.mSpecialValue == -1) {
+                result.add("Without a Lava Filter,");
+                result.add("only Obsidian is produced.");
+            }
+
+            return result;
+        }
+    }
+}
diff --git a/src/main/java/gtPlusPlus/core/item/general/ItemLavaFilter.java b/src/main/java/gtPlusPlus/core/item/general/ItemLavaFilter.java
index 0a3d5f7394..583124a44d 100644
--- a/src/main/java/gtPlusPlus/core/item/general/ItemLavaFilter.java
+++ b/src/main/java/gtPlusPlus/core/item/general/ItemLavaFilter.java
@@ -8,7 +8,6 @@ import net.minecraft.client.renderer.texture.IIconRegister;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.EnumRarity;
 import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.EnumChatFormatting;
 import net.minecraft.util.IIcon;
 import net.minecraft.util.StatCollector;
@@ -26,7 +25,7 @@ public class ItemLavaFilter extends CoreItem {
                 "itemLavaFilter",
                 AddToCreativeTab.tabMachines,
                 1,
-                100,
+                99,
                 new String[] { "Lava Filter" },
                 EnumRarity.common,
                 EnumChatFormatting.BLACK,
@@ -50,74 +49,36 @@ public class ItemLavaFilter extends CoreItem {
         return this.mIcon[0];
     }
 
-    private static boolean createNBT(ItemStack rStack) {
-        final NBTTagCompound tagMain = new NBTTagCompound();
-        final NBTTagCompound tagNBT = new NBTTagCompound();
-        tagNBT.setLong("Damage", 0);
-        tagMain.setTag("LavaFilter", tagNBT);
-        rStack.setTagCompound(tagMain);
-        return true;
-    }
-
-    public static final long getFilterDamage(final ItemStack aStack) {
-        NBTTagCompound aNBT = aStack.getTagCompound();
-        if (aNBT != null) {
-            aNBT = aNBT.getCompoundTag("LavaFilter");
-            if (aNBT != null) {
-                return aNBT.getLong("Damage");
-            }
-        } else {
-            createNBT(aStack);
-        }
-        return 0L;
-    }
-
-    public static final boolean setFilterDamage(final ItemStack aStack, final long aDamage) {
-        NBTTagCompound aNBT = aStack.getTagCompound();
-        if (aNBT != null) {
-            aNBT = aNBT.getCompoundTag("LavaFilter");
-            if (aNBT != null) {
-                aNBT.setLong("Damage", aDamage);
-                return true;
-            }
-        } else {
-            createNBT(aStack);
-        }
-        return false;
-    }
-
-    @Override
-    public double getDurabilityForDisplay(ItemStack stack) {
-        if (stack.getTagCompound() == null) {
-            createNBT(stack);
-        }
-        double currentDamage = getFilterDamage(stack);
-        double durabilitypercent = currentDamage / 100;
-        return durabilitypercent;
-    }
-
     @SuppressWarnings("unchecked")
     @Override
     public void addInformation(ItemStack stack, EntityPlayer player, List list, boolean bool) {
         list.add(EnumChatFormatting.GRAY + StatCollector.translateToLocal("item.itemLavaFilter.tooltip"));
-        EnumChatFormatting durability = EnumChatFormatting.GRAY;
-        if (100 - getFilterDamage(stack) > 80) {
-            durability = EnumChatFormatting.GRAY;
-        } else if (100 - getFilterDamage(stack) > 60) {
-            durability = EnumChatFormatting.GREEN;
-        } else if (100 - getFilterDamage(stack) > 40) {
-            durability = EnumChatFormatting.YELLOW;
-        } else if (100 - getFilterDamage(stack) > 20) {
-            durability = EnumChatFormatting.GOLD;
-        } else if (100 - getFilterDamage(stack) > 0) {
-            durability = EnumChatFormatting.RED;
+
+        int maxDurability = stack.getMaxDamage() + 1;
+        int durability = maxDurability - stack.getItemDamage();
+
+        EnumChatFormatting formatting = EnumChatFormatting.GRAY;
+        if (durability > maxDurability * 0.8) {
+            formatting = EnumChatFormatting.GRAY;
+        } else if (durability > maxDurability * 0.6) {
+            formatting = EnumChatFormatting.GREEN;
+        } else if (durability > maxDurability * 0.4) {
+            formatting = EnumChatFormatting.YELLOW;
+        } else if (durability > maxDurability * 0.2) {
+            formatting = EnumChatFormatting.GOLD;
+        } else if (durability > 0) {
+            formatting = EnumChatFormatting.RED;
         }
-        list.add(durability + "" + (100 - getFilterDamage(stack)) + EnumChatFormatting.GRAY + " / " + 100);
-        // super.addInformation(stack, player, list, bool);
+        list.add("Uses remaining: " + formatting + durability + EnumChatFormatting.GRAY + " / " + maxDurability);
     }
 
     @Override
     public boolean showDurabilityBar(ItemStack stack) {
         return true;
     }
+
+    @Override
+    public boolean isRepairable() {
+        return false;
+    }
 }
diff --git a/src/main/java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java b/src/main/java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java
index 239add81f9..ffe2d5be64 100644
--- a/src/main/java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java
+++ b/src/main/java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java
@@ -35,6 +35,7 @@ import static gregtech.api.util.GT_RecipeConstants.FUSION_THRESHOLD;
 import static gregtech.api.util.GT_RecipeConstants.RESEARCH_ITEM;
 import static gregtech.api.util.GT_RecipeConstants.RESEARCH_TIME;
 import static gregtech.api.util.GT_RecipeConstants.UniversalChemical;
+import static gtPlusPlus.api.recipe.GTPPRecipeMaps.thermalBoilerRecipes;
 
 import net.minecraft.init.Blocks;
 import net.minecraft.init.Items;
@@ -50,7 +51,6 @@ import gregtech.api.util.GT_ModHandler;
 import gregtech.api.util.GT_OreDictUnificator;
 import gregtech.api.util.GT_RecipeConstants;
 import gregtech.api.util.GT_Utility;
-import gregtech.api.util.HotFuel;
 import gtPlusPlus.api.objects.Logger;
 import gtPlusPlus.core.block.ModBlocks;
 import gtPlusPlus.core.item.ModItems;
@@ -106,6 +106,7 @@ public class RECIPES_GREGTECH {
         fluidHeaterRecipes();
         chemplantRecipes();
         alloySmelterRecipes();
+        thermalBoilerRecipes();
 
         /*
          * Special Recipe handlers
@@ -1101,39 +1102,65 @@ public class RECIPES_GREGTECH {
                 .eut(TierEU.RECIPE_MV / 2).addTo(distillationTowerRecipes);
     }
 
+    private static void thermalBoilerRecipes() {
+        Logger.INFO("Registering Thermal Boiler Recipes.");
+
+        // Recipes with special value -1 display additional tooltip in NEI about lava filters.
+
+        // Lava
+
+        GT_Values.RA.stdBuilder()
+                .fluidInputs(FluidUtils.getLava(1000), FluidUtils.getWater(16_000 / GT_Values.STEAM_PER_WATER))
+                .fluidOutputs(FluidUtils.getPahoehoeLava(1000), FluidUtils.getSteam(16_000))
+                .itemOutputs(
+                        GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Copper, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Tin, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Gold, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Silver, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Tantalum, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Tungstate, 1),
+                        new ItemStack(Blocks.obsidian, 1, 0))
+                .outputChances(444, 222, 56, 56, 56, 125, 1000).specialValue(-1).duration(1 * SECONDS).eut(0)
+                .addTo(thermalBoilerRecipes);
+
+        // Pahoehoe Lava
+
+        GT_Values.RA.stdBuilder()
+                .fluidInputs(FluidUtils.getPahoehoeLava(1000), FluidUtils.getWater(16_000 / GT_Values.STEAM_PER_WATER))
+                .fluidOutputs(FluidUtils.getSteam(16_000))
+                .itemOutputs(
+                        GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Bronze, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Electrum, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Tantalum, 1),
+                        GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Tungstate, 1),
+                        new ItemStack(Blocks.obsidian, 1, 0))
+                .outputChances(167, 56, 56, 125, 3700).specialValue(-1).duration(1 * SECONDS).eut(0)
+                .addTo(thermalBoilerRecipes);
+
+        // Hot Coolant
+
+        GT_Values.RA.stdBuilder()
+                .fluidInputs(
+                        FluidUtils.getFluidStack("ic2hotcoolant", 500),
+                        FluidUtils.getWater(100_000 / GT_Values.STEAM_PER_WATER))
+                .fluidOutputs(FluidUtils.getFluidStack("ic2coolant", 500), FluidUtils.getSuperHeatedSteam(100_000))
+                .duration(1 * SECONDS).eut(0).addTo(thermalBoilerRecipes);
+
+        // Solar Salt (Hot)
+
+        GT_Values.RA.stdBuilder()
+                .fluidInputs(
+                        MISC_MATERIALS.SOLAR_SALT_HOT.getFluidStack(100),
+                        FluidUtils.getWater(100_000 / GT_Values.STEAM_PER_WATER))
+                .fluidOutputs(
+                        MISC_MATERIALS.SOLAR_SALT_COLD.getFluidStack(100),
+                        FluidUtils.getSuperHeatedSteam(100_000))
+                .duration(1 * SECONDS).eut(0).addTo(thermalBoilerRecipes);
+    }
+
     private static void addFuels() {
         Logger.INFO("Registering New Fuels.");
 
-        HotFuel.addNewHotFuel(
-                FluidUtils.getLava(83),
-                FluidUtils.getPahoehoeLava(83),
-                new ItemStack[] { ItemUtils.getItemStackOfAmountFromOreDict("nuggetCopper", 1),
-                        ItemUtils.getItemStackOfAmountFromOreDict("nuggetTin", 1),
-                        ItemUtils.getItemStackOfAmountFromOreDict("nuggetGold", 1),
-                        ItemUtils.getItemStackOfAmountFromOreDict("nuggetSilver", 1),
-                        ItemUtils.getItemStackOfAmountFromOreDict("nuggetTantalum", 1),
-                        ItemUtils.getItemStackOfAmountFromOreDict("dustSmallTungstate", 1),
-                        ItemUtils.getSimpleStack(Blocks.obsidian) },
-                new int[] { 2000, 1000, 250, 250, 250, 250, 500 },
-                0);
-
-        HotFuel.addNewHotFuel(
-                FluidUtils.getPahoehoeLava(83),
-                GT_Values.NF,
-                new ItemStack[] { ItemUtils.getItemStackOfAmountFromOreDict("nuggetBronze", 1),
-                        ItemUtils.getItemStackOfAmountFromOreDict("nuggetElectrum", 1),
-                        ItemUtils.getItemStackOfAmountFromOreDict("nuggetTantalum", 1),
-                        ItemUtils.getItemStackOfAmountFromOreDict("dustSmallTungstate", 1),
-                        ItemUtils.getSimpleStack(Blocks.obsidian) },
-                new int[] { 750, 250, 250, 250, 1850 },
-                0);
-
-        HotFuel.addNewHotFuel(
-                MISC_MATERIALS.SOLAR_SALT_HOT.getFluidStack(100),
-                MISC_MATERIALS.SOLAR_SALT_COLD.getFluidStack(100),
-                FluidUtils.getSuperHeatedSteam(100000),
-                0);
-
         GT_Values.RA.stdBuilder().itemInputs(ItemUtils.getSimpleStack(Items.lava_bucket)).metadata(FUEL_VALUE, 32)
                 .metadata(FUEL_TYPE, 2).duration(0).eut(0).addTo(GT_RecipeConstants.Fuel);
         GT_Values.RA.stdBuilder().itemInputs(ItemUtils.getIC2Cell(2)).metadata(FUEL_VALUE, 32).metadata(FUEL_TYPE, 2)
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GT4Entity_ThermalBoiler.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GT4Entity_ThermalBoiler.java
index 8d851a0264..04844ab88b 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GT4Entity_ThermalBoiler.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GT4Entity_ThermalBoiler.java
@@ -12,6 +12,12 @@ 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.stream.Stream;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import net.minecraft.init.Blocks;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.fluids.Fluid;
@@ -25,25 +31,22 @@ import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
 import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
 import com.gtnewhorizon.structurelib.structure.StructureDefinition;
 
+import gregtech.api.enums.GT_Values;
 import gregtech.api.enums.ItemList;
-import gregtech.api.enums.Materials;
 import gregtech.api.enums.TAE;
 import gregtech.api.interfaces.IIconContainer;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.logic.ProcessingLogic;
 import gregtech.api.metatileentity.MetaTileEntity;
-import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_InputBus;
 import gregtech.api.recipe.RecipeMap;
 import gregtech.api.recipe.check.CheckRecipeResult;
-import gregtech.api.recipe.check.CheckRecipeResultRegistry;
-import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_Log;
 import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_ParallelHelper;
 import gregtech.api.util.GT_Recipe;
-import gregtech.api.util.GT_Utility;
 import gtPlusPlus.api.recipe.GTPPRecipeMaps;
 import gtPlusPlus.core.block.ModBlocks;
-import gtPlusPlus.core.item.general.ItemLavaFilter;
 import gtPlusPlus.core.lib.CORE;
-import gtPlusPlus.core.material.MISC_MATERIALS;
 import gtPlusPlus.core.util.minecraft.FluidUtils;
 import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase;
 import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
@@ -53,7 +56,17 @@ public class GT4Entity_ThermalBoiler extends GregtechMeta_MultiBlockBase<GT4Enti
 
     private int mCasing;
     private static IStructureDefinition<GT4Entity_ThermalBoiler> STRUCTURE_DEFINITION = null;
-    private int mSuperEfficencyIncrease = 0;
+
+    private static final int lavaFilterResilience = 30; // Damage lava filter with 1/n probability every operation.
+    private int dryHeatCounter = 0; // Counts up to dryHeatMaximum to check for explosion conditions.
+    private static final int dryHeatMaximum = 10; // 10 consecutive operations without water = BOOM
+
+    private static final Item itemLavaFilter = ItemList.Component_LavaFilter.getItem();
+    private static final Item itemObsidian = Item.getItemFromBlock(Blocks.obsidian);
+    private static final Fluid fluidWater = FluidRegistry.WATER;
+    private static final Fluid fluidDistilledWater = FluidUtils.getDistilledWater(1).getFluid();
+    private static final Fluid fluidSteam = FluidUtils.getSteam(1).getFluid();
+    private static final Fluid fluidSHSteam = FluidUtils.getSuperHeatedSteam(1).getFluid();
 
     public GT4Entity_ThermalBoiler(int aID, String aName, String aNameRegional) {
         super(aID, aName, aNameRegional);
@@ -69,19 +82,13 @@ public class GT4Entity_ThermalBoiler extends GregtechMeta_MultiBlockBase<GT4Enti
     }
 
     @Override
-    public boolean isCorrectMachinePart(ItemStack aStack) {
-        return true;
-    }
-
-    @Override
     public String getMachineType() {
         return "Boiler";
     }
 
     @Override
     public int getDamageToComponent(ItemStack aStack) {
-        // log("Trying to damage component.");
-        return (aStack != null && aStack.getItem() == mLavaFilter) ? 1 : 0;
+        return (aStack != null && aStack.getItem() == itemLavaFilter) ? 1 : 0;
     }
 
     @Override
@@ -94,155 +101,165 @@ public class GT4Entity_ThermalBoiler extends GregtechMeta_MultiBlockBase<GT4Enti
         return false;
     }
 
-    private static Item mLavaFilter;
-    private static Fluid mLava = null;
-    private static Fluid mPahoehoe = null;
-    private static Fluid mSolarSaltHot = null;
+    @Override
+    public boolean supportsVoidProtection() {
+        return true;
+    }
 
     @Override
-    public @NotNull CheckRecipeResult checkProcessing() {
-        ItemStack controllerStack = getControllerSlot();
-        this.mSuperEfficencyIncrease = 0;
+    public boolean supportsBatchMode() {
+        return false;
+    }
 
-        if (mLavaFilter == null) {
-            mLavaFilter = ItemList.Component_LavaFilter.getItem();
-        }
-        if (mLava == null) {
-            mLava = FluidRegistry.LAVA;
-        }
-        if (mPahoehoe == null) {
-            mPahoehoe = FluidUtils.getPahoehoeLava(1).getFluid();
-        }
-        if (mSolarSaltHot == null) {
-            mSolarSaltHot = MISC_MATERIALS.SOLAR_SALT_HOT.getFluid();
-        }
+    @Override
+    protected ProcessingLogic createProcessingLogic() {
+        return new ProcessingLogic() {
+
+            // Only test against the first fluid input in the recipe.
+            // We still want to run if we lack water (and subsequently explode).
+            @NotNull
+            @Override
+            protected Stream<GT_Recipe> findRecipeMatches(@Nullable RecipeMap<?> map) {
+                if (lastRecipe != null && depleteInput(lastRecipe.mFluidInputs[0], true)) {
+                    return Stream.of(lastRecipe);
+                }
+                if (map == null) {
+                    return Stream.empty();
+                }
+                return map.getAllRecipes().stream().filter(recipe -> depleteInput(recipe.mFluidInputs[0], true));
+            }
+
+            @NotNull
+            @Override
+            protected GT_ParallelHelper createParallelHelper(@Nonnull GT_Recipe recipe) {
+                GT_Recipe adjustedRecipe = recipe.copy();
+
+                // Hack the recipe logic to not consume water, so that we can explode.
+                for (FluidStack inputFluid : adjustedRecipe.mFluidInputs) {
+                    if (inputFluid != null
+                            && (inputFluid.getFluid() == fluidWater || inputFluid.getFluid() == fluidDistilledWater)) {
+                        inputFluid.amount = 0;
+                    }
+                }
 
-        // Try reload new Lava Filter
-        if (controllerStack == null) {
-            ItemStack uStack = this.findItemInInventory(mLavaFilter);
-            if (uStack != null) {
-                this.setGUIItemStack(uStack);
-                controllerStack = this.getControllerSlot();
+                // If we don't have a lava filter, remove non-obsidian outputs
+                // so that output space for them is not required if void protection is on.
+                if (!findLavaFilter()) {
+                    for (ItemStack outputItem : adjustedRecipe.mOutputs) {
+                        if (outputItem != null && outputItem.getItem() != itemObsidian) {
+                            outputItem.stackSize = 0;
+                        }
+                    }
+                }
+                return super.createParallelHelper(adjustedRecipe);
             }
-        }
+        };
+    }
 
-        for (GT_Recipe tRecipe : GTPPRecipeMaps.thermalBoilerRecipes.getAllRecipes()) {
-            FluidStack tFluid = tRecipe.mFluidInputs[0];
-            if (tFluid != null) {
-
-                if (tFluid.getFluid() == mLava || tFluid.getFluid() == mPahoehoe) {
-                    if (depleteInput(tFluid)) {
-                        this.mMaxProgresstime = Math.max(1, runtimeBoost(tRecipe.mSpecialValue * 2));
-                        this.lEUt = getEUt();
-                        this.mEfficiencyIncrease = (this.mMaxProgresstime * getEfficiencyIncrease());
-
-                        int loot_MAXCHANCE = 100000;
-                        if (controllerStack != null && controllerStack.getItem() == mLavaFilter) {
-                            if ((tRecipe.getOutput(0) != null)
-                                    && (getBaseMetaTileEntity().getRandomNumber(loot_MAXCHANCE)
-                                            < tRecipe.getOutputChance(0))) {
-                                this.mOutputItems = new ItemStack[] { GT_Utility.copy(tRecipe.getOutput(0)) };
-                            }
-                            if ((tRecipe.getOutput(1) != null)
-                                    && (getBaseMetaTileEntity().getRandomNumber(loot_MAXCHANCE)
-                                            < tRecipe.getOutputChance(1))) {
-                                this.mOutputItems = new ItemStack[] { GT_Utility.copy(tRecipe.getOutput(1)) };
-                            }
-                            if ((tRecipe.getOutput(2) != null)
-                                    && (getBaseMetaTileEntity().getRandomNumber(loot_MAXCHANCE)
-                                            < tRecipe.getOutputChance(2))) {
-                                this.mOutputItems = new ItemStack[] { GT_Utility.copy(tRecipe.getOutput(2)) };
-                            }
-                            if ((tRecipe.getOutput(3) != null)
-                                    && (getBaseMetaTileEntity().getRandomNumber(loot_MAXCHANCE)
-                                            < tRecipe.getOutputChance(3))) {
-                                this.mOutputItems = new ItemStack[] { GT_Utility.copy(tRecipe.getOutput(3)) };
-                            }
-                            if ((tRecipe.getOutput(4) != null)
-                                    && (getBaseMetaTileEntity().getRandomNumber(loot_MAXCHANCE)
-                                            < tRecipe.getOutputChance(4))) {
-                                this.mOutputItems = new ItemStack[] { GT_Utility.copy(tRecipe.getOutput(4)) };
-                            }
-                            if ((tRecipe.getOutput(5) != null)
-                                    && (getBaseMetaTileEntity().getRandomNumber(loot_MAXCHANCE)
-                                            < tRecipe.getOutputChance(5))) {
-                                this.mOutputItems = new ItemStack[] { GT_Utility.copy(tRecipe.getOutput(5)) };
-                            }
+    @Override
+    public @NotNull CheckRecipeResult checkProcessing() {
+        // super.checkProcessing() instantly sets efficiency to maximum, override this.
+        int efficiency = mEfficiency;
+        CheckRecipeResult result = super.checkProcessing();
+        if (result.wasSuccessful()) {
+            mEfficiency = efficiency;
+            mEfficiencyIncrease = mMaxProgresstime * getEfficiencyIncrease();
+
+            // Adjust steam output based on efficiency.
+            if (mOutputFluids != null) {
+                for (FluidStack outputFluid : mOutputFluids) {
+                    if (outputFluid != null
+                            && (outputFluid.getFluid() == fluidSteam || outputFluid.getFluid() == fluidSHSteam)) {
+
+                        // Purely for display reasons, we don't actually make any EU.
+                        if (outputFluid.getFluid() == fluidSteam) {
+                            lEUt = outputFluid.amount / mMaxProgresstime / 2;
+                        } else {
+                            lEUt = outputFluid.amount / mMaxProgresstime;
                         }
-                        final FluidStack[] mFluidOutputs = tRecipe.mFluidOutputs;
-                        this.mOutputFluids = new FluidStack[mFluidOutputs.length];
-                        for (int i = 0, mFluidOutputsLength = mFluidOutputs.length; i < mFluidOutputsLength; i++) {
-                            this.mOutputFluids[i] = mFluidOutputs[i].copy();
+
+                        // Adjust steam output based on efficiency.
+                        // TODO: This is not reflected in the GUI while the player has it open??
+                        if (mEfficiency < getMaxEfficiency(null)) {
+                            outputFluid.amount = Math
+                                    .max(1, (outputFluid.amount * mEfficiency) / getMaxEfficiency(null));
                         }
-                        // Give Obsidian without Lava Filter
-                        if (tFluid.getFluid() == mLava) {
-                            if ((tRecipe.getOutput(6) != null)
-                                    && (getBaseMetaTileEntity().getRandomNumber(loot_MAXCHANCE)
-                                            < tRecipe.getOutputChance(6))) {
-                                this.mOutputItems = new ItemStack[] { GT_Utility.copy(tRecipe.getOutput(6)) };
-                            }
+
+                        // Consume water to run recipe.
+                        if (!useWater(outputFluid.amount)) {
+                            outputFluid.amount = 0;
+                            lEUt = 0;
                         }
-                        return CheckRecipeResultRegistry.SUCCESSFUL;
                     }
-                } else if (tFluid.getFluid() == mSolarSaltHot) {
-                    if (depleteInput(tFluid)) {
-                        this.mMaxProgresstime = tRecipe.mDuration;
-                        this.lEUt = 0;
-                        this.mEfficiency = 10000;
-                        for (FluidStack aOutput : tRecipe.mFluidOutputs) {
-                            this.addOutput(FluidUtils.getFluidStack(aOutput, aOutput.amount));
+                }
+            }
+
+            // Remove non-obsidian outputs if we can't damage lava filter.
+            if (mOutputItems != null && mOutputItems.length > 0) {
+                if (!damageLavaFilter()) {
+                    for (ItemStack outputItem : mOutputItems) {
+                        if (outputItem != null && outputItem.getItem() != itemObsidian) {
+                            outputItem.stackSize = 0;
                         }
-                        return CheckRecipeResultRegistry.SUCCESSFUL;
                     }
                 }
             }
         }
-        this.mMaxProgresstime = 0;
-        this.lEUt = 0;
-        return CheckRecipeResultRegistry.NO_RECIPE;
+        return result;
     }
 
-    @Override
-    public int getMaxParallelRecipes() {
-        return 1;
-    }
-
-    @Override
-    public boolean onRunningTick(ItemStack aStack) {
-        if (this.lEUt > 0) {
-            if (this.mSuperEfficencyIncrease > 0) {
-                this.mEfficiency = Math.min(10000, this.mEfficiency + this.mSuperEfficencyIncrease);
-            }
-            int tGeneratedEU = (int) (this.lEUt * 2L * this.mEfficiency / 10000L);
-            if (tGeneratedEU > 0) {
-                long amount = (tGeneratedEU + 160) / 160;
-                if (depleteInput(Materials.Water.getFluid(amount))
-                        || depleteInput(GT_ModHandler.getDistilledWater(amount))) {
-                    addOutput(GT_ModHandler.getSteam(tGeneratedEU));
-                } else {
-                    explodeMultiblock();
+    private boolean findLavaFilter() {
+        if (getControllerSlot() == null) {
+            for (var bus : mInputBusses) {
+                for (ItemStack stack : bus.mInventory) {
+                    if (stack != null && stack.getItem() == itemLavaFilter) {
+                        setGUIItemStack(stack);
+                        return true;
+                    }
                 }
             }
-            return true;
+            return false;
+        } else {
+            return getControllerSlot().getItem() == itemLavaFilter;
         }
-        return true;
     }
 
-    public int getEUt() {
-        return 400;
-    }
+    private boolean damageLavaFilter() {
+        if (!findLavaFilter()) return false;
+        if (getBaseMetaTileEntity().getRandomNumber(lavaFilterResilience) > 0) return true;
 
-    public int getEfficiencyIncrease() {
-        return 12;
+        ItemStack filter = getControllerSlot();
+        if (filter.attemptDamageItem(1, getBaseMetaTileEntity().getWorld().rand)) {
+            mInventory[1] = null;
+        }
+        return true;
     }
 
-    int runtimeBoost(int mTime) {
-        return mTime * 150 / 100;
+    private boolean useWater(int steamAmount) {
+        // Round up to not dupe decimal amounts of water.
+        int waterAmount = Math.floorDiv(steamAmount + GT_Values.STEAM_PER_WATER - 1, GT_Values.STEAM_PER_WATER);
+        if (depleteInput(FluidUtils.getWater(waterAmount)) || depleteInput(FluidUtils.getDistilledWater(waterAmount))) {
+            dryHeatCounter = 0;
+            return true;
+        } else {
+            // Add some leniency with explosions.
+            if (dryHeatCounter < dryHeatMaximum) {
+                ++dryHeatCounter;
+            } else {
+                GT_Log.exp.println(this.mName + " was too hot and had no more Water!");
+                explodeMultiblock(); // Generate crater
+            }
+            return false;
+        }
     }
 
     @Override
-    public boolean explodesOnComponentBreak(ItemStack aStack) {
-        return false;
+    public int getMaxParallelRecipes() {
+        return 1;
+    }
+
+    public int getEfficiencyIncrease() {
+        return 12;
     }
 
     @Override
@@ -259,12 +276,12 @@ public class GT4Entity_ThermalBoiler extends GregtechMeta_MultiBlockBase<GT4Enti
     protected GT_Multiblock_Tooltip_Builder createTooltip() {
         GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
         tt.addMachineType(getMachineType()).addInfo("Thermal Boiler Controller")
-                .addInfo("Converts Water & Heat into Steam").addInfo("Explodes if water is not supplied")
-                .addInfo("Consult user manual for more information").addPollutionAmount(getPollutionPerSecond(null))
-                .addSeparator().beginStructureBlock(3, 3, 3, true).addController("Front Center")
-                .addCasingInfoMin("Thermal Containment Casings", 10, false).addInputBus("Any Casing", 1)
-                .addOutputBus("Any Casing", 1).addInputHatch("Any Casing", 1).addOutputHatch("Any Casing", 1)
-                .addMaintenanceHatch("Any Casing", 1).addMufflerHatch("Any Casing", 1)
+                .addInfo("Converts Water & Heat into Steam").addInfo("Filters raw materials from lava")
+                .addInfo("Explodes if water is not supplied").addInfo("Consult user manual for more information")
+                .addPollutionAmount(getPollutionPerSecond(null)).beginStructureBlock(3, 3, 3, true)
+                .addController("Front Center").addCasingInfoMin("Thermal Containment Casings", 10, false)
+                .addInputBus("Any Casing", 1).addOutputBus("Any Casing", 1).addInputHatch("Any Casing", 1)
+                .addOutputHatch("Any Casing", 1).addMaintenanceHatch("Any Casing", 1).addMufflerHatch("Any Casing", 1)
                 .toolTipFinisher(CORE.GT_Tooltip_Builder.get());
         return tt;
     }
@@ -320,47 +337,4 @@ public class GT4Entity_ThermalBoiler extends GregtechMeta_MultiBlockBase<GT4Enti
         mCasing = 0;
         return checkPiece(mName, 1, 1, 0) && mCasing >= 10 && checkHatch();
     }
-
-    public void damageFilter() {
-        ItemStack filter = this.mInventory[1];
-        if (filter != null) {
-            if (filter.getItem() instanceof ItemLavaFilter) {
-
-                long currentUse = ItemLavaFilter.getFilterDamage(filter);
-
-                // Remove broken Filter
-                if (currentUse >= 100 - 1) {
-                    this.mInventory[1] = null;
-                } else {
-                    // Do Damage
-                    ItemLavaFilter.setFilterDamage(filter, currentUse + 1);
-                }
-            }
-        }
-    }
-
-    @Override
-    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
-        if (aBaseMetaTileEntity.isServerSide()) {
-            // Reload Lava Filter
-            if (this.getControllerSlot() == null) {
-                if (this.mInputBusses.size() > 0) {
-                    for (GT_MetaTileEntity_Hatch_InputBus aBus : this.mInputBusses) {
-                        for (ItemStack aStack : aBus.mInventory) {
-                            if (aStack != null && aStack.getItem() instanceof ItemLavaFilter) {
-                                this.setGUIItemStack(aStack);
-                            }
-                        }
-                    }
-                }
-            }
-
-            if (this.lEUt > 0) {
-                if (aTick % 600L == 0L) {
-                    damageFilter();
-                }
-            }
-        }
-        super.onPostTick(aBaseMetaTileEntity, aTick);
-    }
 }