fix: a block pays for the volume it has, with no floor invented under it

- drop MIN_OCCUPANCY: a multiplier cannot express a detach cost
- occupancyOf answers [0, 1] honestly; STAGE_COST_BASE holds the bottom
- pin the contract: one material, two volumes, never free

Author: StannisMod

src/main/java/zmaster587/advancedRocketry/damage/StructureDamageEngine.java

@@ -58,13 +58,6 @@ public final class StructureDamageEngine {
      */
     private static final int GAP_TOLERANCE = 6;
 
-    /**
-     * The least of its voxel a block is ever treated as filling. A pane is not a wall and should not
-     * cost like one, but nothing is free either: a body still has to break the thing off its mounting,
-     * and a floor here is what stops a torch or a tripwire from being a hole in a hull.
-     */
-    private static final double MIN_OCCUPANCY = 0.1D;
-
     /** One whole voxel at the origin — the box a block is asked to report its collision shape within. */
     private static final AxisAlignedBB FULL_VOXEL = new AxisAlignedBB(0.0D, 0.0D, 0.0D, 1.0D, 1.0D, 1.0D);
 
@@ -419,7 +412,7 @@ public static int stageCost(World world, BlockPos pos, double areaFactor, Impact
     }
 
     /**
-     * How much of its voxel this block actually fills, in {@code [MIN_OCCUPANCY, 1]}.
+     * How much of its voxel this block actually fills, in {@code [0, 1]}.
      *
      * <h3>Why a price has to know this at all</h3>
      * <p>The law is an energy per unit of VOLUME removed — that is the whole of why the mechanical and
@@ -437,6 +430,18 @@ public static int stageCost(World world, BlockPos pos, double areaFactor, Impact
      * states its real shape, box by box, so that is what is summed. Overlapping boxes would double
      * count, which is why the sum is clamped: over-counting can only ever produce "a full cube", the
      * answer we started from.</p>
+     *
+     * <h3>There is no floor under it, and nothing is free anyway</h3>
+     * <p>A floor was tried and removed: it was a MULTIPLIER, so it priced "the least a block can cost"
+     * out of that block's own material, and what it was meant to represent — the work of breaking a
+     * thing off its mounting — has nothing to do with what the thing is made of. What actually keeps a
+     * near-empty voxel from being free is {@code STAGE_COST_BASE}, which is material-independent and
+     * already inside the product: a standing torch answers 0.024 here and still costs 6 against the
+     * 1000 a full block of stone costs. Below that the price itself floors at 1.</p>
+     *
+     * <p>The floor's stated reason — that a torch must not be a hole in a hull — does not survive
+     * being looked at: a voxel holding a torch is a voxel holding no hull block. The hole is the
+     * builder's, and pricing it dearly does not fill it.</p>
      */
     private static double occupancyOf(World world, BlockPos pos) {
         if (world == null || pos == null) {
@@ -451,17 +456,19 @@ private static double occupancyOf(World world, BlockPos pos) {
                 volume += (box.maxX - box.minX) * (box.maxY - box.minY) * (box.maxZ - box.minZ);
             }
             if (volume > 0.0D) {
-                return Math.max(MIN_OCCUPANCY, Math.min(1.0D, volume));
+                return Math.min(1.0D, volume);
             }
             // No collision at all — a torch, a plant, a tripwire. It is still SOMETHING, so it falls
             // back to the shape it draws itself with rather than to nothing.
             AxisAlignedBB drawn = state.getBoundingBox(world, pos);
             if (drawn == null) {
-                return MIN_OCCUPANCY;
+                // It states no shape at all. The price floors at 1 rather than at nothing, which is
+                // the whole of what "still SOMETHING" needs to mean here.
+                return 0.0D;
             }
             double drawnVolume = (drawn.maxX - drawn.minX) * (drawn.maxY - drawn.minY)
                     * (drawn.maxZ - drawn.minZ);
-            return Math.max(MIN_OCCUPANCY, Math.min(1.0D, drawnVolume));
+            return Math.min(1.0D, drawnVolume);
         } catch (RuntimeException blockDidNotLikeBeingAsked) {
             // A block may compute its shape from neighbours it expects to be loaded. It costs a full
             // cube rather than throwing, which is the answer that changes nothing.

src/test/java/zmaster587/advancedRocketry/test/server/StructuralDamageContractTest.java

@@ -141,6 +141,40 @@ public void aTougherWallIsNotPenetratedFurtherThanAFlimsyOneAtEqualBudget() thro
                 + "its crew nothing.\niron=" + iron, ironDestroyed < glassDestroyed);
     }
 
+    /**
+     * Two blocks of ONE material, differing only in how much of their voxel they fill: a wool block
+     * and a wool carpet. The carpet must cost far less — and must still cost something.
+     *
+     * <p>The law is an energy per unit of VOLUME removed, so the material is deliberately held fixed:
+     * a comparison across materials would pass on the toughness table alone and say nothing about
+     * volume. A carpet fills a sixteenth of its voxel, and for as long as a block was priced as a full
+     * cubic metre it cost what a solid block of wool costs to shoot through.</p>
+     *
+     * <p>The second half is the one that used to be held by a floor under the occupancy, and is now
+     * held by the price itself: the base term of the law is material-independent and the price rounds
+     * up to at least one. So "almost no material" lands at "almost free", never at "free" — which is
+     * what stops a body walking an arbitrarily long run of decoration for nothing.</p>
+     */
+    @Test
+    public void aBlockIsPricedByHowMuchOfItsVoxelItFillsAndNeverAtNothing() throws Exception {
+        int blockX = 1200, blockZ = 1300;
+        int carpetX = 1200, carpetZ = 1320;
+        buildWall("minecraft:wool", blockX, blockZ, 1);
+        buildWall("minecraft:carpet", carpetX, carpetZ, 1);
+
+        String solid = stage(blockX, blockZ);
+        String thin = stage(carpetX, carpetZ);
+        long solidCost = readLong(solid, "stageCost");
+        long thinCost = readLong(thin, "stageCost");
+
+        assertTrue("a carpet costs what a solid block of the same wool costs (carpet=" + thinCost
+                + " block=" + solidCost + "): then a block is priced as a full cubic metre of material"
+                + " however little of its voxel it fills, and the law stops being about volume."
+                + " carpet=" + thin + " block=" + solid, thinCost < solidCost);
+        assertTrue("a carpet costs nothing at all (" + thin + "): then a body crosses any length of"
+                + " decoration for free, and the price has no lower end", thinCost >= 1);
+    }
+
     /** The unified stage reader at a wall's first block: stage, max stage, and what a stage costs there. */
     private String stage(int x, int z) throws Exception {
         return exec("artest damage stage " + DIM + " " + x + " " + Y + " " + z);