feat: an emergency dump that throws heat overboard inside a lump of iron

- Only runs once the ship is already losing, never as cooling
- Charges whatever you load it with, at what that substance can take
- A full slug goes out of the port; a blocked port holds it instead
- The heat rides the matter, so what leaves the ship is really gone

Author: StannisMod

src/main/java/zmaster587/advancedRocketry/AdvancedRocketry.java

@@ -428,6 +428,7 @@ public void preInit(FMLPreInitializationEvent event) {
         GameRegistry.registerTileEntity(zmaster587.advancedRocketry.tile.heat.TileHeatAccumulator.class, "ARheatAccumulator");
         GameRegistry.registerTileEntity(zmaster587.advancedRocketry.tile.heat.TileHeatRadiator.class, "ARheatRadiator");
         GameRegistry.registerTileEntity(zmaster587.advancedRocketry.tile.heat.TileHeatChiller.class, "ARheatChiller");
+        GameRegistry.registerTileEntity(zmaster587.advancedRocketry.tile.heat.TileHeatDump.class, "ARheatDump");
         GameRegistry.registerTileEntity(zmaster587.advancedRocketry.tile.heat.TileHeatIntakeDuct.class, "ARheatIntakeDuct");
         GameRegistry.registerTileEntity(TileWarpController.class, "ARStationMonitor");
         GameRegistry.registerTileEntity(TileAtmosphereDetector.class, "AROxygenDetector");
@@ -795,6 +796,7 @@ public void registerBlocks(RegistryEvent.Register<Block> evt) {
         AdvancedRocketryBlocks.blockHeatAccumulator = new zmaster587.advancedRocketry.block.BlockHeatAccumulator().setCreativeTab(tabAdvRocketry).setUnlocalizedName("heatAccumulator").setHardness(3f);
         AdvancedRocketryBlocks.blockHeatRadiator = new zmaster587.advancedRocketry.block.BlockHeatRadiator().setCreativeTab(tabAdvRocketry).setUnlocalizedName("heatRadiator").setHardness(1f);
         AdvancedRocketryBlocks.blockHeatChiller = new BlockTile(zmaster587.advancedRocketry.tile.heat.TileHeatChiller.class, GuiHandler.guiId.MODULAR.ordinal()).setCreativeTab(tabAdvRocketry).setUnlocalizedName("heatChiller").setHardness(3f);
+        AdvancedRocketryBlocks.blockHeatDump = new BlockTile(zmaster587.advancedRocketry.tile.heat.TileHeatDump.class, GuiHandler.guiId.MODULAR.ordinal()).setCreativeTab(tabAdvRocketry).setUnlocalizedName("heatDump").setHardness(3f);
         AdvancedRocketryBlocks.blockHeatIntakeDuct = new zmaster587.advancedRocketry.block.BlockHeatIntakeDuct().setCreativeTab(tabAdvRocketry).setUnlocalizedName("heatIntakeDuct").setHardness(1f);
         AdvancedRocketryBlocks.blockOxygenVent = new BlockTile(TileOxygenVent.class, GuiHandler.guiId.MODULAR.ordinal()).setUnlocalizedName("oxygenVent").setCreativeTab(tabAdvRocketry).setHardness(3f);
         AdvancedRocketryBlocks.blockOxygenCharger = new BlockHalfTile(TileGasChargePad.class, GuiHandler.guiId.MODULAR.ordinal()).setUnlocalizedName("oxygenCharger").setCreativeTab(tabAdvRocketry).setHardness(3f);
@@ -996,6 +998,7 @@ public void registerBlocks(RegistryEvent.Register<Block> evt) {
         LibVulpesBlocks.registerBlock(AdvancedRocketryBlocks.blockHeatAccumulator.setRegistryName("heatAccumulator"));
         LibVulpesBlocks.registerBlock(AdvancedRocketryBlocks.blockHeatRadiator.setRegistryName("heatRadiator"));
         LibVulpesBlocks.registerBlock(AdvancedRocketryBlocks.blockHeatChiller.setRegistryName("heatChiller"));
+        LibVulpesBlocks.registerBlock(AdvancedRocketryBlocks.blockHeatDump.setRegistryName("heatDump"));
         LibVulpesBlocks.registerBlock(AdvancedRocketryBlocks.blockHeatIntakeDuct.setRegistryName("heatIntakeDuct"));
         LibVulpesBlocks.registerBlock(AdvancedRocketryBlocks.blockOxygenVent.setRegistryName("oxygenVent"));
         LibVulpesBlocks.registerBlock(AdvancedRocketryBlocks.blockOxygenCharger.setRegistryName("oxygenCharger"));
@@ -1179,6 +1182,7 @@ public void postInit(FMLPostInitializationEvent event) {
         zmaster587.advancedRocketry.api.capability.CapabilityWear.register();
         zmaster587.advancedRocketry.api.capability.CapabilityHeatEmitter.register();
         zmaster587.advancedRocketry.api.capability.CapabilityHeatPump.register();
+        zmaster587.advancedRocketry.api.capability.CapabilityHeatSink.register();
         //Need to raise the Max Entity Radius to allow player interaction with rockets
         World.MAX_ENTITY_RADIUS = 20;
 

src/main/java/zmaster587/advancedRocketry/api/ARConfiguration.java

@@ -337,6 +337,10 @@ public class ARConfiguration {
     @ConfigProperty
     public int shipHeatMeltCheckTicks;
     @ConfigProperty
+    public int shipHeatDumpThroughput;
+    @ConfigProperty
+    public int shipHeatDumpTriggerKelvin;
+    @ConfigProperty
     public int solarGeneratorMult;
     @ConfigProperty
     public boolean gravityAffectsFuel;
@@ -642,6 +646,8 @@ public static void loadPreInit() {
         arConfig.shipHeatSlugMarginKelvin = config.get(HEAT, "shipHeatSlugMarginKelvin", 100, "How far below its own melting point a heat slug is charged, in kelvin. This is the margin that keeps a slug a solid object you can eject and pick up again instead of a puddle in the machine, so it is subtracted from every material's usable span. Raise it for a safer, weaker slug.", 0, 5000).getInt();
         arConfig.shipHeatSlugJoulesPerUnit = config.get(HEAT, "shipHeatSlugJoulesPerUnit", 1000, "How many real joules one heat unit stands for when a slug's capacity is worked out from its material. The materials table is ordinary physics in SI, and this is the single place those joules become the currency the rest of the thermal system deals in - so it scales every slug at once and changes no material's standing relative to another. At the default a litre of iron is worth about five thousand heat units.", 1, Integer.MAX_VALUE).getInt();
         arConfig.shipHeatMeltCheckTicks = config.get(HEAT, "shipHeatMeltCheckTicks", 20, "How often a coolant loop looks at what it is cooking, in ticks. This is the melting rung: past a material's own limit the block stops being damaged and is gone. Checking is the expensive half - it walks the loop and its neighbours - so this is the freshness of that answer rather than a balance number. Raising it does not make a ship safer, only slower to lose its hull.", 1, 1200).getInt();
+        arConfig.shipHeatDumpThroughput = config.get(HEAT, "shipHeatDumpThroughput", 40000, "How much heat an emergency dump pushes into the slug it is charging each second. Deliberately well under what a radiator array sheds: the dump buys seconds while something else is fixed, and a value large enough to keep a ship cool would turn an emergency into a cooling system that eats iron.", 0, Integer.MAX_VALUE).getInt();
+        arConfig.shipHeatDumpTriggerKelvin = config.get(HEAT, "shipHeatDumpTriggerKelvin", 700, "How hot the loop must be before an emergency dump will run at all, in kelvin. Below this it does nothing and costs nothing - a ship that is coping does not throw its cargo overboard. 700 K is far past anything a working ship sits at and short of the temperature at which the drive refuses to fire.", 1, 5000).getInt();
         arConfig.solarGeneratorMult = config.get(ENERGY, "solarGeneratorMultiplier", 1, "Power produced per tick by the solar generator.").getInt();
         arConfig.microwaveRecieverMulitplier = (float) config.get(ENERGY, "MicrowaveRecieverMultiplier", 1f, "Multiplier for microwave receiver power output.").getDouble();
         arConfig.defaultItemTimeBlackHole = config.get(ENERGY, "defaultBurnTime", 500, "Burn time in ticks for items not listed in blackHoleTimings.").getInt();

src/main/java/zmaster587/advancedRocketry/api/AdvancedRocketryBlocks.java

@@ -96,6 +96,7 @@ public class AdvancedRocketryBlocks {
     public static Block blockHeatAccumulator;
     public static Block blockHeatRadiator;
     public static Block blockHeatChiller;
+    public static Block blockHeatDump;
     public static Block blockHeatIntakeDuct;
     public static Block blockCircleLight;
     public static Block blockSolarGenerator;

src/main/java/zmaster587/advancedRocketry/api/capability/CapabilityHeatSink.java

@@ -0,0 +1,79 @@
+package zmaster587.advancedRocketry.api.capability;
+
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumFacing;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.capabilities.CapabilityInject;
+import net.minecraftforge.common.capabilities.CapabilityManager;
+
+import javax.annotation.Nullable;
+
+/**
+ * The capability through which a coolant loop finds a machine that will TAKE its heat, registered
+ * exactly like {@link CapabilityHeatEmitter}. The host keeps its own state in its own NBT, so the
+ * {@code IStorage} is a no-op.
+ * <p>
+ * One read path and no {@code instanceof}: a loop does not know what a heat dump is, only that
+ * something beside it answers this capability.
+ */
+public class CapabilityHeatSink {
+
+    @CapabilityInject(IHeatSink.class)
+    public static Capability<IHeatSink> HEAT_SINK = null;
+
+    public CapabilityHeatSink() {
+    }
+
+    /** Convenience: the sink capability on a tile entity, or null if it takes no heat. */
+    @Nullable
+    public static IHeatSink get(@Nullable TileEntity te) {
+        if (te == null || te.isInvalid() || HEAT_SINK == null) {
+            return null;
+        }
+        return te.getCapability(HEAT_SINK, null);
+    }
+
+    public static void register() {
+        CapabilityManager.INSTANCE.register(IHeatSink.class, new Capability.IStorage<IHeatSink>() {
+            @Override
+            public void readNBT(Capability<IHeatSink> capability, IHeatSink instance, EnumFacing side, NBTBase nbt) {
+            }
+
+            @Override
+            public NBTBase writeNBT(Capability<IHeatSink> capability, IHeatSink instance, EnumFacing side) {
+                return null;
+            }
+        }, () -> new DefaultHeatSink(0L));
+    }
+
+    /** A backing store for a foreign host that wants one, with the drain contract implemented. */
+    /**
+     * The plain implementation for a machine that simply holds what it is given up to a limit - the
+     * dump keeps its own, so this exists for anything given the capability from outside.
+     */
+    public static class DefaultHeatSink implements IHeatSink {
+        private final long capacity;
+        private long held;
+
+        public DefaultHeatSink(long capacity) {
+            this.capacity = Math.max(0L, capacity);
+        }
+
+        public long held() {
+            return held;
+        }
+
+        @Override
+        public long getSinkRequestPerTick(double loopKelvin) {
+            return Math.max(0L, capacity - held);
+        }
+
+        @Override
+        public long acceptHeat(long amount) {
+            long taken = Math.max(0L, Math.min(amount, capacity - held));
+            held += taken;
+            return taken;
+        }
+    }
+}

src/main/java/zmaster587/advancedRocketry/api/capability/IHeatSink.java

@@ -0,0 +1,28 @@
+package zmaster587.advancedRocketry.api.capability;
+
+/**
+ * A machine that TAKES heat off a coolant loop and puts it somewhere that is not the loop.
+ *
+ * <p>The mirror of {@link IHeatEmitter}, and deliberately the same shape read backwards: the loop
+ * asks how much this machine wants and then hands over what it can, so a sink standing between two
+ * loops is fed by both instead of being counted twice. The loop decides how much moves, never the
+ * machine - the same asymmetry a radiator lives under, and for the same reason.</p>
+ *
+ * <p>A capability rather than a plain interface for the reason the emitter is one: the machines this
+ * system exists to serve mostly belong to other mods, and a mod that wants to soak a ship's heat
+ * into something of its own can be given this without either side importing the other.</p>
+ */
+public interface IHeatSink {
+
+    /**
+     * How much heat this machine would take this tick, given how hot the loop offering it is.
+     *
+     * <p>The temperature is an ARGUMENT because a sink is allowed to be conditional - the emergency
+     * dump only runs when the ship is already losing, which is what keeps it an emergency rather than
+     * a cooling system. A sink that wants nothing answers zero and the loop moves nothing.</p>
+     */
+    long getSinkRequestPerTick(double loopKelvin);
+
+    /** Take up to {@code amount}; returns what was actually absorbed, which is what the loop loses. */
+    long acceptHeat(long amount);
+}

src/main/java/zmaster587/advancedRocketry/command/test/TestProbeCommand.java

@@ -10905,7 +10905,12 @@ private void handleMachineTickUntil(MinecraftServer server, ICommandSender sende
                     // and world time does not advance inside one probe call - so the interval is
                     // set to 1 to make the sweep run on the tick the test asks for rather than on
                     // whichever tick the phase happens to land on.
-                    "shipHeatMeltCheckTicks"));
+                    "shipHeatMeltCheckTicks",
+                    // The dump's trigger and rate. A test of "it runs only when the ship is
+                    // already losing" has to arrange BOTH sides of that threshold, and naming the
+                    // temperature in the test instead would restate the tuned number.
+                    "shipHeatDumpTriggerKelvin",
+                    "shipHeatDumpThroughput"));
 
     private void handleConfig(ICommandSender sender, String[] args) {
         if (args.length == 0) {
@@ -16775,6 +16780,46 @@ private void handleHeat(MinecraftServer server, ICommandSender sender, String[]
             handleHeatCycle(server, sender, args);
             return;
         }
+        if (args.length >= 5 && "dump".equalsIgnoreCase(args[0])) {
+            // The emergency dump's own state: what the slug it holds has taken, what it can still
+            // take, and whether the port is clear. Reported separately because "charge went to zero"
+            // is BOTH "nothing happened" and "it fired", and a test must be able to tell those apart.
+            int dim = parseIntOr(args[1], Integer.MIN_VALUE);
+            net.minecraft.world.WorldServer world = server.getWorld(dim);
+            if (world == null) {
+                send(sender, "{\"error\":\"world not loaded\",\"dim\":" + dim + "}");
+                return;
+            }
+            BlockPos pos = new BlockPos(parseIntOr(args[2], 0), parseIntOr(args[3], 0),
+                    parseIntOr(args[4], 0));
+            net.minecraft.tileentity.TileEntity tile = world.getTileEntity(pos);
+            if (!(tile instanceof zmaster587.advancedRocketry.tile.heat.TileHeatDump)) {
+                send(sender, "{\"ok\":true,\"isDump\":false,\"charge\":0,\"headroom\":0,"
+                        + "\"hasStack\":false,\"obstruction\":0}");
+                return;
+            }
+            zmaster587.advancedRocketry.tile.heat.TileHeatDump dump =
+                    (zmaster587.advancedRocketry.tile.heat.TileHeatDump) tile;
+            net.minecraft.item.ItemStack held = dump.getStackInSlot(0);
+            if (args.length >= 7 && "load".equalsIgnoreCase(args[5])) {
+                net.minecraft.item.Item item = net.minecraft.item.Item.getByNameOrId(args[6]);
+                if (item == null) {
+                    send(sender, "{\"error\":\"unknown item id\",\"id\":\"" + escapeJson(args[6]) + "\"}");
+                    return;
+                }
+                dump.setInventorySlotContents(0, new net.minecraft.item.ItemStack(item, 1));
+                held = dump.getStackInSlot(0);
+            }
+            send(sender, "{\"ok\":true,\"isDump\":true,\"charge\":"
+                    + zmaster587.advancedRocketry.tile.heat.TileHeatDump.chargeOf(held)
+                    + ",\"headroom\":" + dump.headroom()
+                    + ",\"hasStack\":" + (!held.isEmpty())
+                    + ",\"obstruction\":" + dump.getObstruction()
+                    + ",\"chargedThisTick\":" + dump.getChargedThisTick()
+                    + ",\"powered\":" + dump.isPowered()
+                    + ",\"request\":" + dump.getSinkRequestPerTick(9999.0D) + "}");
+            return;
+        }
         if (args.length >= 2 && "item".equalsIgnoreCase(args[0])) {
             // The same question asked of an ITEM rather than a position: an item has no collision
             // boxes, so this is the path that falls back to the shape of the block it would place.
@@ -16997,6 +17042,7 @@ private void handleHeatCycle(MinecraftServer server, ICommandSender sender, Stri
                 + ",\"rejected\":" + after.getRejectedThisTick()
                 + ",\"heatStored\":" + after.getStoredHeat()
                 + ",\"heatCapacity\":" + after.getHeatCapacity()
+                + ",\"sunk\":" + after.getSunkThisTick()
                 + ",\"temperatureMilliK\":" + Math.round(after.getTemperatureKelvin() * 1000.0D)
                 + ",\"exchangers\":" + after.getExchangerCount()
                 + ",\"radiatingCells\":" + after.getRadiatingCells()