Fix bridges crossing state model

frontend/src/components/PuzzleEditor.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useState } from "react";
+import { useEffect, useRef, useState } from "react";
 
 import type { PuzzleType } from "../lib/api";
 
@@ -191,6 +191,18 @@ function sortedBridgeCandidates(opportunities: BridgesOpportunity[]): BridgesOpp
   });
 }
 
+function clearBridgeConflicts(
+  parsed: ReturnType<typeof parseBridges>,
+  states: Record<string, 0 | 1 | 2>,
+  selected: BridgesOpportunity,
+) {
+  for (const opportunity of parsed.opportunities) {
+    if (opportunity.id !== selected.id && bridgeOpportunitiesShareCell(opportunity, selected)) {
+      states[opportunity.id] = 0;
+    }
+  }
+}
+
 function bridgeClickCountForOpportunity(
   opportunities: BridgesOpportunity[],
   opportunity: BridgesOpportunity,
@@ -209,7 +221,6 @@ function cycleBridgesOpportunities(
   parsed: ReturnType<typeof parseBridges>,
   states: Record<string, 0 | 1 | 2>,
   opportunities: BridgesOpportunity[],
-  clickedChar = ".",
 ): Record<string, 0 | 1 | 2> {
   if (opportunities.length === 0) {
     return states;
@@ -223,11 +234,7 @@ function cycleBridgesOpportunities(
     const level = (((nextStates[opportunity.id] ?? 0) + 1) % 3) as 0 | 1 | 2;
     nextStates[opportunity.id] = level;
     if (level > 0) {
-      for (const other of parsed.opportunities) {
-        if (other.id !== opportunity.id && bridgeOpportunitiesShareCell(other, opportunity)) {
-          nextStates[other.id] = 0;
-        }
-      }
+      clearBridgeConflicts(parsed, nextStates, opportunity);
     }
     return nextStates;
   }
@@ -239,18 +246,25 @@ function cycleBridgesOpportunities(
     ]),
     null,
   ];
-  const currentIndex =
-    sequence.findIndex(
-      (entry) => entry !== null && bridgeSymbol(entry.opportunity, entry.level) === clickedChar,
-    ) ?? -1;
-  const normalizedCurrentIndex = currentIndex === -1 ? sequence.length - 1 : currentIndex;
+  const currentIndex = sequence.findIndex((entry) =>
+    candidates.every((opportunity) => {
+      const expected = entry?.opportunity.id === opportunity.id ? entry.level : 0;
+      return (nextStates[opportunity.id] ?? 0) === expected;
+    }),
+  );
+  const fallbackIndex = sequence.findIndex(
+    (entry) => entry !== null && (nextStates[entry.opportunity.id] ?? 0) === entry.level,
+  );
+  const safeCurrentIndex =
+    currentIndex === -1 ? (fallbackIndex === -1 ? sequence.length - 1 : fallbackIndex) : currentIndex;
 
-  const nextEntry = sequence[(normalizedCurrentIndex + 1) % sequence.length];
+  const nextEntry = sequence[(safeCurrentIndex + 1) % sequence.length];
   for (const opportunity of candidates) {
     nextStates[opportunity.id] = 0;
   }
   if (nextEntry) {
     nextStates[nextEntry.opportunity.id] = nextEntry.level;
+    clearBridgeConflicts(parsed, nextStates, nextEntry.opportunity);
   }
   return nextStates;
 }
@@ -553,17 +567,25 @@ function legendColor(letter: string) {
 
 function BridgesEditor({ problemAscii, boardAscii, onChange }: Omit<Props, "puzzleType">) {
   const parsed = parseBridges(problemAscii);
-  const states = bridgesStatesFromBoard(problemAscii, boardAscii);
-  const boardLines = splitLines(boardAscii);
+  const [states, setStates] = useState(() => bridgesStatesFromBoard(problemAscii, boardAscii));
+  const lastEmittedBoard = useRef<string | null>(null);
+  const renderedBoardAscii = bridgesBoardFromStates(problemAscii, states);
+  const boardLines = splitLines(renderedBoardAscii);
 
-  function cycle(opportunities: BridgesOpportunity[], r: number, c: number) {
-    const nextStates = cycleBridgesOpportunities(
-      parsed,
-      states,
-      opportunities,
-      boardLines[r]?.[c] ?? ".",
-    );
-    onChange(bridgesBoardFromStates(problemAscii, nextStates));
+  useEffect(() => {
+    if (lastEmittedBoard.current === boardAscii) {
+      return;
+    }
+    setStates(bridgesStatesFromBoard(problemAscii, boardAscii));
+    lastEmittedBoard.current = null;
+  }, [problemAscii, boardAscii]);
+
+  function cycle(opportunities: BridgesOpportunity[]) {
+    const nextStates = cycleBridgesOpportunities(parsed, states, opportunities);
+    const nextBoard = bridgesBoardFromStates(problemAscii, nextStates);
+    setStates(nextStates);
+    lastEmittedBoard.current = nextBoard;
+    onChange(nextBoard);
   }
 
   return (
@@ -589,7 +611,7 @@ function BridgesEditor({ problemAscii, boardAscii, onChange }: Omit<Props, "puzz
                 key={`${r}-${c}`}
                 type="button"
                 className={className}
-                onClick={() => cycle(opportunities, r, c)}
+                onClick={() => cycle(opportunities)}
                 disabled={opportunities.length === 0}
               >
                 {isClueChar(char) ? char : display}

frontend/test/pipeline/bridges_clickplan.json

@@ -125,6 +125,9 @@
   43
  ],
  "bridges_7x7dm_24cecc91.txt": [
+  17,
+  17,
+  17,
   1,
   7,
   7,
@@ -134,9 +137,6 @@
   9,
   22,
   22,
-  17,
-  17,
-  17,
   21,
   37,
   37,
@@ -170,6 +170,14 @@
   93
  ],
  "bridges_10x10dh_dbb54860.txt": [
+  35,
+  35,
+  35,
+  35,
+  44,
+  44,
+  44,
+  44,
   1,
   1,
   10,
@@ -186,14 +194,6 @@
   31,
   24,
   33,
-  35,
-  35,
-  35,
-  35,
-  44,
-  44,
-  44,
-  44,
   49,
   49,
   55,
@@ -211,6 +211,17 @@
   94
  ],
  "bridges_10x10dh_9a2eb1a6.txt": [
+  73,
+  73,
+  73,
+  75,
+  75,
+  75,
+  71,
+  71,
+  84,
+  84,
+  84,
   2,
   4,
   13,
@@ -234,21 +245,10 @@
   62,
   62,
   64,
-  73,
-  73,
-  73,
   66,
-  75,
-  75,
-  75,
   79,
-  71,
-  71,
   80,
   80,
-  84,
-  84,
-  84,
   86,
   82,
   91,
@@ -257,11 +257,11 @@
   97
  ],
  "bridges_10x10dh_1e764d30.txt": [
+  11,
+  11,
   2,
   2,
   19,
-  11,
-  11,
   20,
   13,
   13,
@@ -287,6 +287,13 @@
   95
  ],
  "bridges_10x10dh_714c4838.txt": [
+  65,
+  65,
+  67,
+  67,
+  84,
+  84,
+  88,
   1,
   10,
   3,
@@ -312,15 +319,8 @@
   54,
   63,
   63,
-  65,
-  65,
-  67,
-  67,
   76,
   76,
-  84,
-  84,
-  88,
   91,
   95,
   97

frontend/test/pipeline/roundtrip.test.ts

@@ -66,15 +66,16 @@ for (const f of fixtures.filter((x) => x.family === "bridges")) {
   const lineLens: number[] = parsed.lines.map((l: string) => l.length);
   const indexOf = (r: number, c: number) =>
     lineLens.slice(0, r).reduce((a: number, b: number) => a + b, 0) + c;
-  const clicks: number[] = [];
+  const clickEntries: Array<{ clickCount: number; idx: number; ambiguousOnly: boolean }> = [];
   for (const opp of parsed.opportunities) {
     const level = target[opp.id] ?? 0;
     if (level === 0) continue;
+    const uniqueCell = opp.cells.find(([r, c]: [number, number]) => {
+      const candidates = parsed.cellToOpportunities.get(`${r}:${c}`) ?? [];
+      return candidates.length === 1 && candidates[0].id === opp.id;
+    });
     const owned =
-      opp.cells.find(([r, c]: [number, number]) => {
-        const candidates = parsed.cellToOpportunities.get(`${r}:${c}`) ?? [];
-        return candidates.length === 1 && candidates[0].id === opp.id;
-      }) ??
+      uniqueCell ??
       opp.cells.find(([r, c]: [number, number]) =>
         (parsed.cellToOpportunities.get(`${r}:${c}`) ?? []).some(
           (candidate: { id: string }) => candidate.id === opp.id,
@@ -83,8 +84,15 @@ for (const f of fixtures.filter((x) => x.family === "bridges")) {
       opp.cells[0];
     const idx = indexOf(owned[0], owned[1]);
     const candidates = parsed.cellToOpportunities.get(`${owned[0]}:${owned[1]}`) ?? [];
-    const clickCount = T.bridgeClickCountForOpportunity(candidates, opp, level);
-    for (let i = 0; i < clickCount; i += 1) clicks.push(idx);
+    clickEntries.push({
+      ambiguousOnly: !uniqueCell && candidates.length > 1,
+      clickCount: T.bridgeClickCountForOpportunity(candidates, opp, level),
+      idx,
+    });
+  }
+  const clicks: number[] = [];
+  for (const entry of clickEntries.sort((a, b) => Number(b.ambiguousOnly) - Number(a.ambiguousOnly))) {
+    for (let i = 0; i < entry.clickCount; i += 1) clicks.push(entry.idx);
   }
   bridgesClickPlan[f.filename] = clicks;
 }
@@ -124,18 +132,14 @@ describe("bridges generated click plans", () => {
         throw new Error(`click index out of bounds: ${idx}`);
       };
 
-      let board = f.problem;
       let states: Record<string, 0 | 1 | 2> = {};
       for (const idx of bridgesClickPlan[f.filename] ?? []) {
         const [r, c] = indexToCoord(idx);
-        const clickedChar = T.splitLines(board)[r]?.[c] ?? ".";
         states = T.cycleBridgesOpportunities(
           parsed,
           states,
           parsed.cellToOpportunities.get(`${r}:${c}`) ?? [],
-          clickedChar,
         );
-        board = T.bridgesBoardFromStates(f.problem, states);
       }
 
       for (const opportunity of parsed.opportunities) {
@@ -171,49 +175,61 @@ describe("bridges ambiguous route cells", () => {
     expect(vertical).toBeTruthy();
 
     let states: Record<string, 0 | 1 | 2> = {};
-    states = T.cycleBridgesOpportunities(parsed, states, centerCandidates, ".");
+    states = T.cycleBridgesOpportunities(parsed, states, centerCandidates);
     expect(states[horizontal!.id]).toBe(1);
     expect(states[vertical!.id] ?? 0).toBe(0);
 
-    states = T.cycleBridgesOpportunities(parsed, states, centerCandidates, "-");
+    states = T.cycleBridgesOpportunities(parsed, states, centerCandidates);
     expect(states[horizontal!.id]).toBe(2);
     expect(states[vertical!.id] ?? 0).toBe(0);
 
-    states = T.cycleBridgesOpportunities(parsed, states, centerCandidates, "=");
+    states = T.cycleBridgesOpportunities(parsed, states, centerCandidates);
     expect(states[horizontal!.id] ?? 0).toBe(0);
     expect(states[vertical!.id]).toBe(1);
 
-    states = T.cycleBridgesOpportunities(parsed, states, centerCandidates, "|");
+    states = T.cycleBridgesOpportunities(parsed, states, centerCandidates);
     expect(states[horizontal!.id] ?? 0).toBe(0);
     expect(states[vertical!.id]).toBe(2);
 
-    states = T.cycleBridgesOpportunities(parsed, states, centerCandidates, "\"");
+    states = T.cycleBridgesOpportunities(parsed, states, centerCandidates);
     expect(states[horizontal!.id] ?? 0).toBe(0);
     expect(states[vertical!.id] ?? 0).toBe(0);
   });
 
-  it("cycles a shared cell through all visible states after each board render", () => {
+  it("keeps the shared-cell cycle across board renders", () => {
     const parsed = T.parseBridges(crossingProblem);
     const centerCandidates = parsed.cellToOpportunities.get("2:2") ?? [];
-    let board = crossingProblem;
+    let states: Record<string, 0 | 1 | 2> = {};
     const visible: string[] = [];
 
     for (let i = 0; i < 5; i += 1) {
-      const states = T.bridgesStatesFromBoard(crossingProblem, board);
-      const nextStates = T.cycleBridgesOpportunities(
-        parsed,
-        states,
-        centerCandidates,
-        T.splitLines(board)[2]?.[2] ?? ".",
-      );
-      board = T.bridgesBoardFromStates(crossingProblem, nextStates);
+      states = T.cycleBridgesOpportunities(parsed, states, centerCandidates);
+      const board = T.bridgesBoardFromStates(crossingProblem, states);
       visible.push(T.splitLines(board)[2]?.[2] ?? ".");
     }
 
     expect(visible).toEqual(["-", "=", "|", "\"", "."]);
   });
 
-  it("cycles a unique cell route independently", () => {
+
+  it("never leaves two active bridge routes sharing a cell", () => {
+    const parsed = T.parseBridges(crossingProblem);
+    const centerCandidates = parsed.cellToOpportunities.get("2:2") ?? [];
+    const verticalCandidates = parsed.cellToOpportunities.get("1:2") ?? [];
+    let states: Record<string, 0 | 1 | 2> = {};
+
+    for (const candidates of [centerCandidates, centerCandidates, verticalCandidates, centerCandidates]) {
+      states = T.cycleBridgesOpportunities(parsed, states, candidates);
+      for (const candidatesAtCell of parsed.cellToOpportunities.values()) {
+        const activeAtCell = candidatesAtCell.filter(
+          (opportunity: { id: string }) => (states[opportunity.id] ?? 0) > 0,
+        );
+        expect(activeAtCell.length).toBeLessThanOrEqual(1);
+      }
+    }
+  });
+
+  it("clears crossing bridges when cycling a unique cell route", () => {
     const parsed = T.parseBridges(crossingProblem);
     const centerCandidates = parsed.cellToOpportunities.get("2:2") ?? [];
     const verticalCandidates = parsed.cellToOpportunities.get("1:2") ?? [];
@@ -227,8 +243,8 @@ describe("bridges ambiguous route cells", () => {
     expect(vertical).toBeTruthy();
 
     let states: Record<string, 0 | 1 | 2> = {};
-    states = T.cycleBridgesOpportunities(parsed, states, centerCandidates, ".");
-    states = T.cycleBridgesOpportunities(parsed, states, verticalCandidates, ".");
+    states = T.cycleBridgesOpportunities(parsed, states, centerCandidates);
+    states = T.cycleBridgesOpportunities(parsed, states, verticalCandidates);
 
     expect(states[horizontal!.id] ?? 0).toBe(0);
     expect(states[vertical!.id]).toBe(1);