fix: a mirror sends the beam back, and the second plate gets asked

- HeldBeam resolves a tick as a bounded loop of segments
- a deflected beam continues along the mirrored direction
- a melted film hands the rest of the beam on in the same tick
- the beam path reaches the client, so a bend is drawn as a bend
- a round that got out keeps its travel and meets what stands beyond
- REACH_EXHAUSTED separates running out of path from leaving

Author: StannisMod

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

@@ -16,6 +16,18 @@ public enum StopReason {
     /** The path left the structure with budget to spare. Pairs with {@link DamageOutcome#EXITED}. */
     EXITED_FAR_SIDE,
 
+    /**
+     * The granted PATH ran out while the body was still inside structure, with budget in hand.
+     * Pairs with {@link DamageOutcome#EXITED}, because the budget is handed back either way — and
+     * that shared outcome is exactly why this reason has to exist separately.
+     *
+     * <p>"Budget left over" and "came out the other side" are different facts, and a caller that
+     * has to decide whether the body is still IN there can only tell them apart here. Reported as
+     * {@code EXITED_FAR_SIDE} until 2026-08-20, which told a round that had bored a fifth of a
+     * block that it had left the plate.</p>
+     */
+    REACH_EXHAUSTED,
+
     /**
      * The target region is not loaded, so nothing could be resolved. <b>Not</b> a statement that there
      * is nothing there — a caller able to retry should, and one that treats this as "clean miss"

src/main/java/zmaster587/advancedRocketry/client/ClientBeamTracker.java

@@ -2,6 +2,10 @@
 
 import net.minecraft.util.math.Vec3d;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
 import java.util.Collection;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -37,14 +41,17 @@ public final class ClientBeamTracker {
     private ClientBeamTracker() {
     }
 
-    /** This gun's beam is burning along this segment, as of now. */
-    public static void lit(long gun, Vec3d from, Vec3d to) {
+    /** This gun's beam is burning along this PATH, as of now. */
+    public static void lit(long gun, List<Vec3d> path) {
+        if (path == null || path.size() < 2) {
+            return;
+        }
         ClientBeam beam = BEAMS.get(gun);
         if (beam == null) {
-            BEAMS.put(gun, new ClientBeam(from, to));
+            BEAMS.put(gun, new ClientBeam(path));
             return;
         }
-        beam.refresh(from, to);
+        beam.refresh(path);
     }
 
     /** This gun's beam has gone out. */
@@ -62,6 +69,24 @@ public static int count() {
         return BEAMS.size();
     }
 
+    /**
+     * How many of them have a CORNER in them — a beam something turned.
+     *
+     * <p>The second observable, and it exists because the first cannot see the thing that goes
+     * wrong here. A bent beam sent to a client as two ends is still one drawn beam, so a count of
+     * beams is green whether the corner arrived or not; what a player would see is a laser drawn
+     * straight through the mirror that turned it.</p>
+     */
+    public static int bentCount() {
+        int bent = 0;
+        for (ClientBeam beam : BEAMS.values()) {
+            if (beam.isBent()) {
+                bent++;
+            }
+        }
+        return bent;
+    }
+
     public static void clear() {
         BEAMS.clear();
     }
@@ -82,34 +107,47 @@ public static void tick() {
         BEAMS.values().removeIf(ClientBeam::ageAndCheckStale);
     }
 
-    /** One drawn beam: where it starts, where it ends, both in world coordinates. */
+    /**
+     * One drawn beam: the path it occupies, in world coordinates, muzzle first.
+     *
+     * <p>Two points for the ordinary beam, more where something turned it. {@link #getFrom} and
+     * {@link #getTo} are kept because the ends are what most readers want, and because a beam that
+     * has not been bent is exactly its two ends.</p>
+     */
     public static final class ClientBeam {
 
-        private Vec3d from;
-        private Vec3d to;
+        private List<Vec3d> path;
         private int sinceHeard;
 
-        private ClientBeam(Vec3d from, Vec3d to) {
-            this.from = from;
-            this.to = to;
+        private ClientBeam(List<Vec3d> path) {
+            this.path = new ArrayList<Vec3d>(path);
         }
 
-        private void refresh(Vec3d newFrom, Vec3d newTo) {
-            from = newFrom;
-            to = newTo;
+        private void refresh(List<Vec3d> newPath) {
+            path = new ArrayList<Vec3d>(newPath);
             sinceHeard = 0;
         }
 
         private boolean ageAndCheckStale() {
             return ++sinceHeard > STALE_TICKS;
         }
 
+        /** Every point of the line, muzzle first. Never fewer than two. */
+        public List<Vec3d> getPath() {
+            return Collections.unmodifiableList(path);
+        }
+
+        /** Whether something turned this beam, which is the only case the path has a corner. */
+        public boolean isBent() {
+            return path.size() > 2;
+        }
+
         public Vec3d getFrom() {
-            return from;
+            return path.get(0);
         }
 
         public Vec3d getTo() {
-            return to;
+            return path.get(path.size() - 1);
         }
     }
 }

src/main/java/zmaster587/advancedRocketry/client/render/RenderBeams.java

@@ -93,25 +93,34 @@ public void onRenderWorldLast(RenderWorldLastEvent event) {
         buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_COLOR);
 
         for (ClientBeamTracker.ClientBeam beam : ClientBeamTracker.burning()) {
-            Vec3d from = beam.getFrom();
-            Vec3d to = beam.getTo();
-            if (from == null || to == null) {
-                continue;
+            // A beam is a PATH: one leg for the ordinary one, more where a mirror turned it. Each
+            // leg is a ribbon of its own because each faces the camera differently, and only the
+            // LAST one ends in a spot — the corners are places the beam went on from, not places it
+            // landed, and a glow at a corner would read as a hit that never happened.
+            java.util.List<Vec3d> path = beam.getPath();
+            for (int leg = 0; leg + 1 < path.size(); leg++) {
+                Vec3d from = path.get(leg);
+                Vec3d to = path.get(leg + 1);
+                if (from == null || to == null) {
+                    continue;
+                }
+                Vec3d axis = to.subtract(from);
+                if (axis.lengthVector() < 1.0E-6D) {
+                    continue;
+                }
+                axis = axis.normalize();
+                Vec3d across = across(axis, from, to, eye);
+                if (across == null) {
+                    continue;
+                }
+                ribbon(buffer, from, to, across.scale(HALO_HALF_WIDTH), eye,
+                        1.0F, 0.32F, 0.16F, 0.35F);
+                ribbon(buffer, from, to, across.scale(CORE_HALF_WIDTH), eye,
+                        1.0F, 0.93F, 0.85F, 1.0F);
+                if (leg + 2 == path.size()) {
+                    spot(buffer, to, axis, eye);
+                }
             }
-            Vec3d axis = to.subtract(from);
-            if (axis.lengthVector() < 1.0E-6D) {
-                continue;
-            }
-            axis = axis.normalize();
-            Vec3d across = across(axis, from, to, eye);
-            if (across == null) {
-                continue;
-            }
-            ribbon(buffer, from, to, across.scale(HALO_HALF_WIDTH), eye,
-                    1.0F, 0.32F, 0.16F, 0.35F);
-            ribbon(buffer, from, to, across.scale(CORE_HALF_WIDTH), eye,
-                    1.0F, 0.93F, 0.85F, 1.0F);
-            spot(buffer, to, axis, eye);
         }
 
         tessellator.draw();

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

@@ -342,8 +342,13 @@ private WalkResult finish() {
                 return result;
             }
             // Budget still in hand at the path limit: hand it back rather than absorb it silently.
+            // WHERE it ran out is the caller's question, though, and the two answers are not the
+            // same fact: still in the material with the path spent, or out the far side with path
+            // to spare. A body that "exited" without leaving would be advanced past whatever stood
+            // beyond it, which is not a thing it ever reached.
             result.outcome = DamageOutcome.EXITED;
-            result.stopReason = StopReason.EXITED_FAR_SIDE;
+            result.stopReason = previousWasSolid
+                    ? StopReason.REACH_EXHAUSTED : StopReason.EXITED_FAR_SIDE;
             result.exitPoint = previousWasSolid ? farEnd : lastSolidExit;
             return result;
         }

src/main/java/zmaster587/advancedRocketry/network/PacketBeamState.java

@@ -6,6 +6,9 @@
 import net.minecraft.network.PacketBuffer;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;
+
+import java.util.ArrayList;
+import java.util.List;
 import zmaster587.advancedRocketry.client.ClientBeamTracker;
 import zmaster587.libVulpes.network.BasePacket;
 
@@ -28,25 +31,35 @@
  */
 public class PacketBeamState extends BasePacket {
 
+    /**
+     * A beam is a PATH and not a segment, because something can turn it.
+     *
+     * <p>Two points for the ordinary beam. More where a mirror sent it back: the corner is a real
+     * point on the line the beam occupies, and a bent beam drawn muzzle-to-end would be drawn
+     * straight through the very plating that turned it. The cap is a wire bound and matches the
+     * server's own segment budget, so a path that reaches it is drawn as far as it was resolved.</p>
+     */
+    private static final int MAX_POINTS = 9;
+
     private long gun;
     private boolean lit;
-    private double fromX, fromY, fromZ;
-    private double toX, toY, toZ;
+    private final List<Vec3d> path = new ArrayList<Vec3d>(2);
 
     public PacketBeamState() {
     }
 
-    public static PacketBeamState of(BlockPos gun, Vec3d from, Vec3d to, boolean lit) {
+    public static PacketBeamState of(BlockPos gun, List<Vec3d> path, boolean lit) {
         PacketBeamState packet = new PacketBeamState();
         packet.gun = gun.toLong();
-        packet.lit = lit && from != null && to != null;
+        packet.lit = lit && path != null && path.size() >= 2;
         if (packet.lit) {
-            packet.fromX = from.x;
-            packet.fromY = from.y;
-            packet.fromZ = from.z;
-            packet.toX = to.x;
-            packet.toY = to.y;
-            packet.toZ = to.z;
+            for (Vec3d point : path) {
+                if (point == null || packet.path.size() >= MAX_POINTS) {
+                    break;
+                }
+                packet.path.add(point);
+            }
+            packet.lit = packet.path.size() >= 2;
         }
         return packet;
     }
@@ -59,12 +72,12 @@ public void write(ByteBuf out) {
         if (!lit) {
             return;
         }
-        buffer.writeDouble(fromX);
-        buffer.writeDouble(fromY);
-        buffer.writeDouble(fromZ);
-        buffer.writeDouble(toX);
-        buffer.writeDouble(toY);
-        buffer.writeDouble(toZ);
+        buffer.writeByte(path.size());
+        for (Vec3d point : path) {
+            buffer.writeDouble(point.x);
+            buffer.writeDouble(point.y);
+            buffer.writeDouble(point.z);
+        }
     }
 
     @Override
@@ -75,12 +88,12 @@ public void readClient(ByteBuf in) {
         if (!lit) {
             return;
         }
-        fromX = buffer.readDouble();
-        fromY = buffer.readDouble();
-        fromZ = buffer.readDouble();
-        toX = buffer.readDouble();
-        toY = buffer.readDouble();
-        toZ = buffer.readDouble();
+        int count = Math.min(MAX_POINTS, buffer.readUnsignedByte());
+        path.clear();
+        for (int i = 0; i < count; i++) {
+            path.add(new Vec3d(buffer.readDouble(), buffer.readDouble(), buffer.readDouble()));
+        }
+        lit = path.size() >= 2;
     }
 
     @Override
@@ -91,7 +104,7 @@ public void read(ByteBuf in) {
     @Override
     public void executeClient(EntityPlayer player) {
         if (lit) {
-            ClientBeamTracker.lit(gun, new Vec3d(fromX, fromY, fromZ), new Vec3d(toX, toY, toZ));
+            ClientBeamTracker.lit(gun, path);
         } else {
             ClientBeamTracker.extinguished(gun);
         }