feat: a responder may decline, and a mirror is glass again

- ContactResult.noOpinion: the default law decides, as for a plain block
- IContactResponder no longer tells implementers to decline by passing through
- mirror plating declines a solid round instead of waving it through free
- one lowercase regex row prices the mirror family as glass, not hull plate

Author: StannisMod

src/main/java/zmaster587/advancedRocketry/api/damage/ContactResult.java

@@ -5,8 +5,14 @@
 /**
  * What a block answered when a travelling body met it.
  *
- * <h3>Three states, four behaviours</h3>
+ * <h3>Three behaviours, and a way to have none</h3>
  * <ul>
+ *   <li>{@link #noOpinion} — <b>this block has nothing to say about THIS body</b>, and the default law
+ *       applies exactly as if it answered nothing at all. It is not a behaviour, it is a declining to
+ *       have one, and it exists because the alternative was to decline by saying
+ *       {@code passedThrough(everything)} — which is a real answer meaning "through, for free". A
+ *       mirror shipped saying that about slugs and became an armour plate that kinetic fire could
+ *       neither pay for nor break.</li>
  *   <li>{@link #passedThrough} — the body carries on, worth less. The default: it is what an ordinary
  *       block does, and what "weakened penetration" means.</li>
  *   <li>{@link #stopped} — nothing continues past this block. <b>Reactive armour is this</b>, plus the
@@ -24,24 +30,51 @@
  */
 public final class ContactResult {
 
+    /**
+     * The one instance of "nothing to say". A singleton because it carries no facts: two declinings
+     * are the same declining, and giving it a residual energy would invite somebody to read one.
+     */
+    private static final ContactResult NO_OPINION = new ContactResult(false, 0, null, true);
+
     private final boolean stopped;
     private final int residualEnergy;
     private final Vec3d deflectedVelocity;
+    private final boolean noOpinion;
 
-    private ContactResult(boolean stopped, int residualEnergy, Vec3d deflectedVelocity) {
+    private ContactResult(boolean stopped, int residualEnergy, Vec3d deflectedVelocity,
+                          boolean noOpinion) {
         this.stopped = stopped;
         this.residualEnergy = Math.max(0, residualEnergy);
         this.deflectedVelocity = deflectedVelocity;
+        this.noOpinion = noOpinion;
+    }
+
+    /**
+     * This block declines to answer for this body: the default law applies, exactly as it does for the
+     * two thousand blocks that implement nothing at all.
+     *
+     * <p>A responder answers for the arrivals it has a mechanism for and declines for the rest —
+     * a mirror has a law about light and none about a solid round, and the round should then be priced
+     * and resisted like any other piece of glass. Whoever declines here is asking for the ordinary
+     * treatment, not asking to be skipped.</p>
+     */
+    public static ContactResult noOpinion() {
+        return NO_OPINION;
+    }
+
+    /** True when this block declined to answer and the default law should decide instead. */
+    public boolean isNoOpinion() {
+        return noOpinion;
     }
 
     /** The body carries on along its own course with {@code residualEnergy} left. */
     public static ContactResult passedThrough(int residualEnergy) {
-        return new ContactResult(false, residualEnergy, null);
+        return new ContactResult(false, residualEnergy, null, false);
     }
 
     /** Nothing continues past this block. */
     public static ContactResult stopped() {
-        return new ContactResult(true, 0, null);
+        return new ContactResult(true, 0, null, false);
     }
 
     /**
@@ -55,7 +88,7 @@ public static ContactResult deflected(Vec3d newVelocity, int residualEnergy) {
         if (newVelocity == null || newVelocity.lengthVector() <= 1.0E-9D) {
             return stopped();
         }
-        return new ContactResult(false, residualEnergy, newVelocity);
+        return new ContactResult(false, residualEnergy, newVelocity, false);
     }
 
     /** True when nothing continues past the block that answered. */

src/main/java/zmaster587/advancedRocketry/api/damage/IContactResponder.java

@@ -21,7 +21,14 @@ public interface IContactResponder {
 
     /**
      * Answer for one body meeting this block. Never null: return
-     * {@link ContactResult#passedThrough(int)} to decline having an opinion.
+     * {@link ContactResult#noOpinion()} to decline having one, and the default law decides instead —
+     * price, stages, ricochet, the lot — exactly as it does for a block that implements nothing.
+     *
+     * <p><b>Do not decline with {@link ContactResult#passedThrough(int)}.</b> That is an answer, and
+     * what it says is "through, carrying this much", so declining with the arriving energy says
+     * "through, for free". This javadoc told implementers to do exactly that until 2026-08-19, and
+     * mirror plating followed it: a solid round crossed the film spending nothing and left it standing,
+     * so the one armour a beam could strip was the one kinetic fire could not.</p>
      *
      * <p>The world is passed rather than carried on the {@link Contact} on purpose. A contact states
      * the FACTS of a meeting — that is what lets a held beam, which is not a shot in any registry, use

src/main/java/zmaster587/advancedRocketry/block/BlockMirrorPlating.java

@@ -68,8 +68,13 @@ public ContactResult onContact(World world, Contact contact) {
             return null;
         }
         if (!isRadiant(contact.getKind())) {
-            // A mirror is glass and foil. A slug does not care that it is shiny.
-            return ContactResult.passedThrough(contact.getEnergy());
+            // A mirror is glass and foil, and a solid round does not care that it is shiny — but it
+            // does have to get through it. Declining hands the meeting to the default law, which
+            // prices the film off the table and the eighth of a voxel it fills and breaks it like any
+            // other pane. Answering "passed through" here instead would let a round cross for nothing
+            // and leave the plating standing, which made it armour that only its own counter could
+            // remove.
+            return ContactResult.noOpinion();
         }
 
         int absorbed = (int) Math.ceil(contact.getEnergy() * (1.0D - reflectance));

src/main/java/zmaster587/advancedRocketry/projectile/ContactResolver.java

@@ -77,7 +77,10 @@ public static Resolution resolve(World world, TravellingBody body, StructureCros
         IContactResponder responder = responderAt(world, hit.block);
         if (responder != null) {
             ContactResult answer = responder.onContact(world, contact);
-            if (answer != null) {
+            // Declining is not answering. A responder has a law about some arrivals and none about the
+            // rest, and the rest must fall through to the ordinary treatment — otherwise the only
+            // phrase available for "nothing to say" is one that means "through, for free".
+            if (answer != null && !answer.isNoOpinion()) {
                 // A block that answered for itself did not walk anything, so the body is advanced past
                 // the block it was answered by — otherwise the next test finds the same block, asks
                 // again, and a round argues with one plate until the tick's crossing budget runs out.

src/main/java/zmaster587/advancedRocketry/util/WeightEngine.java

@@ -380,6 +380,9 @@ public void load() {
             ablationIndividual = readMap(gson, root, "ablationIndividual", mapType);
             ablationByRegex = readMap(gson, root, "ablationByRegex", mapType);
             toughnessByRegex = readMap(gson, root, "toughnessByRegex", linkedType);
+            if (toughnessByRegex.isEmpty()) {
+                toughnessByRegex = defaultToughnessByRegex();
+            }
             toughnessMaterials = readMap(gson, root, "toughnessMaterials", mapType);
             if (toughnessMaterials.isEmpty()) {
                 toughnessMaterials = defaultToughnessMaterials();
@@ -412,7 +415,7 @@ private void seedDefaults() {
         fallback = 0.1;
         fluidFallback = 0.001;
         toughnessIndividual = new HashMap<>();
-        toughnessByRegex = new LinkedHashMap<>();
+        toughnessByRegex = defaultToughnessByRegex();
         toughnessMaterials = defaultToughnessMaterials();
         toughnessFallback = 2.0;
     }
@@ -519,6 +522,33 @@ private static Map<String, Double> defaultMaterials() {
      * survive retuning is the ordering, because that is what a player perceives when a shot goes
      * through a window and stops in the plating.
      */
+    /**
+     * Rows this mod ships for its own blocks, where the material alone gets them badly wrong.
+     *
+     * <p>Written as regexes rather than one row per block so that a family is priced as a family: the
+     * three mirror films differ in how much light they return, not in how hard the glass is, and a
+     * fourth tier should not need a fifth row.</p>
+     *
+     * <p><b>Mirror plating is glass and foil declared as {@code Material.IRON}</b> — iron because that
+     * is what it is mined and sounded like, which then priced a mirror film as hull plate. It answers
+     * a beam by its own law, so this row governs what it costs to smash: a solid round, an explosion,
+     * anything with no optics in it. Reactive plating deliberately has NO row: its casing IS metal,
+     * and what makes it interesting is the charge rather than what the charge is wrapped in.</p>
+     *
+     * <p>Seeded when the config carries no regex rows at all, exactly as the material table is — so a
+     * pack cannot express "no regex rows whatsoever". That is a real limitation and it is inherited
+     * rather than chosen; a pack that disagrees with a row overrides it by value, or by an individual
+     * row, which outranks every regex.</p>
+     */
+    private static Map<String, Double> defaultToughnessByRegex() {
+        Map<String, Double> m = new LinkedHashMap<>();
+        // LOWERCASE, and it is not a style choice: a registry name arrives here already lowercased,
+        // so a pattern written the way the block was declared ("mirrorPlating...") matches nothing and
+        // the row silently does not exist. The block keeps its declared price and nobody is told.
+        m.put("advancedrocketry:mirrorplating.*", 1.0);
+        return m;
+    }
+
     private static Map<String, Double> defaultToughnessMaterials() {
         Map<String, Double> m = new LinkedHashMap<>();
         m.put("AIR", 0.0);

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

@@ -23,17 +23,27 @@ public class ArmourBlocksAnswerForThemselvesE2ETest extends AbstractSharedServer
     private static final int Y = 70, X = 2100;
     private static final int MIRROR_Z = 1200, MIRROR_SLUG_Z = 1220, BETTER_Z = 1240;
     private static final int REACTIVE_Z = 1260, REACTIVE_TWICE_Z = 1280, RAILGUN_Z = 1300;
+    private static final int PRICE_Z = 1320;
 
     private static final double SPEED = 0.45D;
     private static final Pattern ID = Pattern.compile("\"id\":(-?\\d+)");
     private static final Pattern VX = Pattern.compile("\"vx\":(-?[\\d.eE+-]+)");
+    private static final Pattern STAGE_COST = Pattern.compile("\"stageCost\":(-?\\d+)");
 
     /**
-     * A mirror returns a beam and lets a slug through, and the difference is the kind in the contact
-     * and nothing else — the same block, the same face, the same energy.
+     * A mirror returns a beam and is SMASHED by a solid round, and the difference is the kind in the
+     * contact and nothing else — the same block, the same face, the same energy.
+     *
+     * <p>The second half used to read "lets a solid round straight through", and it was pinning a
+     * defect. A mirror has no OPTICAL opinion about a solid round, and it said so by answering "passed
+     * through, carrying everything" — which is not "no opinion", it is "through, for free". So the
+     * round paid nothing, the film was untouched, and the one armour a beam could strip was the one
+     * kinetic fire could not. The block now DECLINES, and declining hands the meeting to the ordinary
+     * law: the film is priced off the table and the eighth of a voxel it fills, and it breaks like the
+     * glass it is.</p>
      */
     @Test
-    public void aMirrorReturnsABeamAndLetsASlugStraightThrough() throws Exception {
+    public void aMirrorReturnsABeamAndIsSmashedByASolidRound() throws Exception {
         prepare(MIRROR_Z);
         prepare(MIRROR_SLUG_Z);
         place("advancedrocketry:mirrorPlatingAluminium", MIRROR_Z);
@@ -47,10 +57,13 @@ public void aMirrorReturnsABeamAndLetsASlugStraightThrough() throws Exception {
 
         long slug = fire(MIRROR_SLUG_Z, 3_000, "KINETIC");
         assertTrue("the slug was refused", slug >= 0);
-        assertTrue("a solid round bounced off glass and foil: a mirror has no opinion about a slug,"
-                + " and the kind in the contact is the only thing that separates the two cases: "
-                + read(slug), !awaitTurnedBack(slug));
-        assertTrue("the mirror is still standing after a slug went through it", stillThere(MIRROR_SLUG_Z));
+        assertTrue("a solid round bounced off glass and foil: a mirror has no OPTICAL opinion about"
+                + " a solid round, and the kind in the contact is the only thing that separates the"
+                + " two cases: " + read(slug), !awaitTurnedBack(slug));
+        awaitGone(slug);
+        assertTrue("the film is still standing after a solid round crossed it: then the round paid"
+                + " nothing for it, and a mirror is armour that only the weapon it was built to stop"
+                + " can remove", !stillThere(MIRROR_SLUG_Z));
     }
 
     /**
@@ -67,16 +80,26 @@ public void aBetterMirrorSurvivesWhatKillsAWorseOne() throws Exception {
         // exceeds what the film sheds, and a thirtieth of it does not.
         int killsAluminium = 60_000;
 
-        // CONTROL, and the test is worthless without it: the same energy as a SLUG must leave the
-        // plate standing. Ordinary damage does not know one mirror from another, so if it were doing
-        // the work below, this is where it would show — and the first cut of this test passed with the
-        // whole responder switched off, which is exactly what this catches.
-        long slug = fire(BETTER_Z, killsAluminium, "KINETIC");
-        assertTrue("the control round was refused", slug >= 0);
-        awaitGone(slug);
-        assertTrue("a slug carrying what the beams below carry destroyed the plating: then what kills"
-                + " a mirror here is ordinary damage, and nothing in this test is about mirrors",
-                stillThere(BETTER_Z));
+        // CONTROL, and the test is worthless without it — the first cut of this test passed with
+        // the whole responder switched off. It used to be a solid round carrying the same energy,
+        // which had to leave the plate standing; that stopped being available the day such a round
+        // started paying for the film and breaking it, which is correct and kills the old control.
+        //
+        // This is the stronger replacement, and it aims at the mechanism rather than at one sample:
+        // ordinary damage prices the two tiers IDENTICALLY, so it cannot produce a difference between
+        // them at all. Whatever separates aluminium from gold below is therefore the reflectance, and
+        // can be nothing else.
+        placeAt(X + 4, BETTER_Z, "advancedrocketry:mirrorPlatingGold");
+        long aluminiumCost = costOf(exec("artest damage stage " + DIM + " " + X + " " + Y + " "
+                + BETTER_Z));
+        long goldCost = costOf(exec("artest damage stage " + DIM + " " + (X + 4) + " " + Y + " "
+                + BETTER_Z));
+        assertTrue("the two mirror tiers cost different amounts to break by ordinary damage"
+                + " (aluminium=" + aluminiumCost + " gold=" + goldCost + "): then the ladder below can"
+                + " be produced without any mirror law at all, and this test measures the toughness"
+                + " table", aluminiumCost == goldCost);
+        placeAt(X + 4, BETTER_Z, "minecraft:air");
+
         long first = fire(BETTER_Z, killsAluminium, "BEAM");
         assertTrue("the beam was refused", first >= 0);
         awaitGone(first);
@@ -143,6 +166,49 @@ public void twiceTheReactiveVolumeEatsMoreOfTheSameImpact() throws Exception {
                 clean(X + 2, RAILGUN_Z));
     }
 
+    /**
+     * A mirror film is priced as the glass and foil it is, not as the hull plate its MATERIAL says.
+     *
+     * <p>Both plating families are declared {@code Material.IRON} — which is what they are mined and
+     * sounded like — and the damage table resolves by material when nothing has written a row. That
+     * priced a mirror film as solid hull.</p>
+     *
+     * <p><b>The comparator is REACTIVE plating, and the choice is the whole test.</b> The obvious
+     * comparison — a film against a solid block of iron — passes whether or not the mirror has a row
+     * of its own, because a film fills an eighth of its voxel and the volume alone makes it cheaper.
+     * It would measure the occupancy factor and report it as evidence about the table. Reactive
+     * plating is the same class, the same thickness and the same declared material, and it
+     * deliberately has NO row: its casing IS metal, and what makes it interesting is the charge rather
+     * than what the charge is wrapped in. So the two differ in exactly one thing, and a difference in
+     * price can come from exactly one place.</p>
+     *
+     * <p>Only the ORDERING is claimed. The numbers behind it are balance and will move; an assertion
+     * on them would go red the first time anyone retunes the table without breaking anything a player
+     * would notice.</p>
+     */
+    @Test
+    public void aMirrorFilmCostsLessToBreakThanTheMetalItsMaterialClaims() throws Exception {
+        prepare(PRICE_Z);
+        place("advancedrocketry:mirrorPlatingAluminium", PRICE_Z);
+        placeAt(X + 4, PRICE_Z, "advancedrocketry:reactivePlate");
+
+        String film = exec("artest damage stage " + DIM + " " + X + " " + Y + " " + PRICE_Z);
+        String metal = exec("artest damage stage " + DIM + " " + (X + 4) + " " + Y + " " + PRICE_Z);
+        long filmCost = costOf(film), metalCost = costOf(metal);
+
+        assertTrue("a mirror film costs what the identically shaped plating beside it costs (film="
+                + filmCost + " reactive=" + metalCost + "): the two differ only in that one has a row"
+                + " of its own, so this says the row is not being read at all and glass with foil on"
+                + " it still resists like hull plate. film=" + film + " reactive=" + metal,
+                filmCost < metalCost);
+    }
+
+    private static long costOf(String json) {
+        Matcher m = STAGE_COST.matcher(json);
+        assertTrue("no stageCost in: " + json, m.find());
+        return Long.parseLong(m.group(1));
+    }
+
     // ---- driving
 
     private long fire(int lane, int energy, String kind) throws Exception {