Fix more big face bugs with fog

Author: Copilot

src/lib/mapdata.ts

@@ -1360,12 +1360,21 @@ class ReusableMapdataCellUpdate implements MapdataCellUpdate {
   clear_space(): void {
     const cell = this.requireWorkingCell();
     const { px, py } = this.absoluteCoords();
+    const original = this.originalCell;
+    const originalHasData =
+      (original?.darkness ?? 0) !== 0 ||
+      (original?.labels.length ?? 0) > 0 ||
+      (original?.heads.some((head) => head.face !== 0) ?? false) ||
+      (original?.tails.some((tail) => tail.face !== 0) ?? false) ||
+      (original?.smooth.some((value) => value !== 0) ?? false);
     notifyWatchedCell(px, py, "space cleared (transitioning to fog)");
     if (mapdata_contains(px, py)) {
       const idxL = ci(px, py) * L;
       layerUpdatedAfterClear.fill(0, idxL, idxL + L);
     }
-    if (this.originalState === MapCellState.Empty) {
+    // Some clear_space updates arrive with state=Empty while legacy tail/head
+    // data is still populated; only hard-clear when the cell is truly blank.
+    if (this.originalState === MapCellState.Empty && !originalHasData) {
       for (let l = 0; l < L; l++) {
         this.clearHeadLayer(cell.heads[l]!);
         this.clearTailLayer(cell.tails[l]!);
@@ -1376,7 +1385,6 @@ class ReusableMapdataCellUpdate implements MapdataCellUpdate {
       // Preserve remembered content when transitioning from Visible→Fog.
       // In particular, keep big-face heads so objects remain visible in fog
       // until a later explicit layer update replaces or clears them.
-      const original = this.originalCell;
       if (original) {
         for (let l = 0; l < L; l++) {
           const prevHead = original.heads[l]!;
@@ -1401,7 +1409,10 @@ class ReusableMapdataCellUpdate implements MapdataCellUpdate {
     ) {
       cell.needUpdate = true;
     }
-    cell.state = MapCellState.Fog;
+    cell.state =
+      this.originalState === MapCellState.Empty
+        ? MapCellState.Empty
+        : MapCellState.Fog;
     this.clearSpaceCalled = true;
   }
 
@@ -1599,6 +1610,25 @@ class ReusableMapdataCellUpdate implements MapdataCellUpdate {
         const idx = ci(px, py);
         const idxL = idx * L;
         const original = this.originalCell;
+        if (
+          this.clearSpaceCalled &&
+          original &&
+          this.originalState !== MapCellState.Empty
+        ) {
+          // A clear_space can arrive without per-layer updates; keep remembered
+          // tail coverage on untouched layers so fog transitions don't drop it.
+          for (let l = 0; l < L; l++) {
+            if (this.dirtyLayers[l]) {
+              continue;
+            }
+            if (
+              this.workingCell.tails[l]!.face === 0 &&
+              original.tails[l]!.face !== 0
+            ) {
+              this.workingCell.tails[l] = { ...original.tails[l]! };
+            }
+          }
+        }
         const originalHasBigFaceHead =
           original?.heads.some(
             (head) => head.face !== 0 && (head.sizeX > 1 || head.sizeY > 1),
@@ -1616,6 +1646,34 @@ class ReusableMapdataCellUpdate implements MapdataCellUpdate {
             if (this.dirtyLayers[l] || layerUpdatedAfterClear[idxL + l]) {
               continue;
             }
+            const staleTail = original?.tails[l];
+            if (
+              staleTail &&
+              staleTail.face !== 0 &&
+              (staleTail.sizeX > 0 || staleTail.sizeY > 0)
+            ) {
+              const staleHeadX = px + staleTail.sizeX;
+              const staleHeadY = py + staleTail.sizeY;
+              let danglingTail = !mapdata_contains(staleHeadX, staleHeadY);
+              if (!danglingTail) {
+                const staleHeadIdxL = ci(staleHeadX, staleHeadY) * L + l;
+                const staleHeadFace = headFace[staleHeadIdxL]!;
+                const staleHeadW = headSizeX[staleHeadIdxL]!;
+                const staleHeadH = headSizeY[staleHeadIdxL]!;
+                danglingTail =
+                  staleHeadFace === 0 ||
+                  staleHeadFace !== staleTail.face ||
+                  (staleHeadW <= 1 && staleHeadH <= 1);
+              }
+              if (danglingTail && mapdata_contains(staleHeadX, staleHeadY)) {
+                // Clear stale fog-era big-face coverage that points to a missing
+                // or mismatched head so it no longer lingers in fog cells.
+                expandClearFaceFromLayer(staleHeadX, staleHeadY, l);
+              }
+              if (danglingTail) {
+                this.clearTailLayer(this.workingCell.tails[l]!);
+              }
+            }
             this.clearHeadLayer(this.workingCell.heads[l]!);
           }
         }
@@ -1745,10 +1803,12 @@ class ReusableMapdataCellUpdate implements MapdataCellUpdate {
             }
           }
 
-          // Clear tails of the previous big face from neighboring cells.
-          // For Fog cells mapdata_clear_old already did this; for Visible cells
-          // we must do it here so stale neighbor tails don't linger.
-          expandClearFaceFromLayer(px, py, l);
+          // Clear tails of the previous big face from neighboring cells only
+          // when this update leaves the cell visible. For Visible->Fog
+          // transitions, keep remembered tail coverage in fog.
+          if (this.workingCell.state !== MapCellState.Fog) {
+            expandClearFaceFromLayer(px, py, l);
+          }
 
           headFace[lOff] = head.face;
           headSizeX[lOff] = head.sizeX;

tests/replay-mapdata/replay-mapdata.spec.ts

@@ -29,9 +29,11 @@ let mapdata_cell: (
   mx: number,
   my: number,
 ) => {
-  heads: Array<{ face: number }>;
+  heads: Array<{ face: number; sizeX: number; sizeY: number }>;
+  tails: Array<{ face: number; sizeX: number; sizeY: number }>;
   state: number;
 };
+let mapdata_contains: (x: number, y: number) => boolean;
 let pl_mpos: () => { px: number; py: number };
 let getFaceTileSize: (face: number) => { w: number; h: number };
 let parseReplayLogFile: (text: string) => {
@@ -117,6 +119,32 @@ function parseRawRxLine(line: string): Uint8Array | null {
   return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
 }
 
+function assertNoDanglingTailsInView(): void {
+  const player = pl_mpos();
+  for (let dx = -12; dx <= 12; dx++) {
+    for (let dy = -12; dy <= 12; dy++) {
+      const ax = player.px + dx;
+      const ay = player.py + dy;
+      if (!mapdata_contains(ax, ay)) {
+        continue;
+      }
+      const cell = mapdata_cell(ax, ay);
+      for (let layer = 0; layer < cell.tails.length; layer++) {
+        const tail = cell.tails[layer]!;
+        if (tail.face === 0) {
+          continue;
+        }
+        const headX = ax + tail.sizeX;
+        const headY = ay + tail.sizeY;
+        expect(mapdata_contains(headX, headY)).toBe(true);
+        const head = mapdata_cell(headX, headY).heads[layer]!;
+        expect(head.face).toBe(tail.face);
+        expect(head.sizeX > 1 || head.sizeY > 1).toBe(true);
+      }
+    }
+  }
+}
+
 beforeAll(() => {
   installNodeTestGlobals();
   // Avoid browser-only globals failing during module evaluation.
@@ -136,7 +164,7 @@ beforeAll(async () => {
   ({ dispatchPacket } = await import("../../src/lib/commands"));
   ({ clientInit } = await import("../../src/lib/init"));
   ({ getFaceTileSize } = await import("../../src/lib/image"));
-  ({ setGetMapImageSize, mapdata_cell, pl_mpos } =
+  ({ setGetMapImageSize, mapdata_cell, mapdata_contains, pl_mpos } =
     await import("../../src/lib/mapdata"));
   ({ initCommands } = await import("../../src/lib/p_cmd"));
   ({ parseReplayLogFile, resetReplaySandboxState, toPacketBuffer } =
@@ -207,4 +235,43 @@ describe("replay mapdata states", () => {
     expect(cell.heads[0]!.face).toBe(1005);
     expect(cell.heads[6]!.face).toBe(0);
   });
+
+  test("big-face head cell stays empty when only fog bookkeeping changes", () => {
+    const logText = readFileSync(
+      path.join(
+        rootDir,
+        "tests/replay-mapdata/logs/around-scorn-with-ui-log.log",
+      ),
+      "utf8",
+    );
+
+    resetReplaySandboxState();
+    replayToMark(logText, "before arena disapears #1");
+
+    const headX = 280;
+    const headY = 272;
+    let cell = mapdata_cell(headX, headY);
+    expect(cell.state).toBe(0);
+    expect(cell.heads[0]!.face).toBe(0);
+    expect(cell.heads[1]!.face).toBe(645);
+
+    resetReplaySandboxState();
+    replayToMark(logText, "after arena disapears #1");
+
+    cell = mapdata_cell(headX, headY);
+    expect(cell.state).toBe(0);
+    expect(cell.heads[0]!.face).toBe(0);
+    expect(cell.heads[1]!.face).toBe(645);
+  });
+
+  test("zoo replay has no dangling in-view tail-to-head links", () => {
+    const logText = readFileSync(
+      path.join(rootDir, "tests/replay-mapdata/logs/zoo.log"),
+      "utf8",
+    );
+
+    resetReplaySandboxState();
+    replayToMark(logText, "after retributor moves right #2");
+    assertNoDanglingTailsInView();
+  });
 });