Fix bridges crossing cell selection

frontend/src/components/PuzzleEditor.tsx

@@ -85,10 +85,31 @@ function isClueChar(char: string): boolean {
   return /[0-9A-G]/.test(char);
 }
 
+function addBridgeOpportunityForCell(
+  cellToOpportunities: Map<string, BridgesOpportunity[]>,
+  r: number,
+  c: number,
+  opportunity: BridgesOpportunity,
+) {
+  const key = `${r}:${c}`;
+  cellToOpportunities.set(key, [...(cellToOpportunities.get(key) ?? []), opportunity]);
+}
+
+function bridgeSymbol(opportunity: BridgesOpportunity, level: 1 | 2): string {
+  return opportunity.kind === "horizontal" ? (level === 2 ? "=" : "-") : level === 2 ? '"' : "|";
+}
+
+function bridgeLevelFromChar(opportunity: BridgesOpportunity, char: string): 0 | 1 | 2 {
+  if (opportunity.kind === "horizontal") {
+    return char === "=" ? 2 : char === "-" ? 1 : 0;
+  }
+  return char === '"' ? 2 : char === "|" ? 1 : 0;
+}
+
 function parseBridges(problemAscii: string) {
   const lines = splitLines(problemAscii);
   const opportunities: BridgesOpportunity[] = [];
-  const cellToOpportunity = new Map<string, BridgesOpportunity>();
+  const cellToOpportunities = new Map<string, BridgesOpportunity[]>();
   for (let r = 0; r < lines.length; r += 1) {
     for (let c = 0; c < lines[r].length; c += 1) {
       if (!isClueChar(lines[r][c])) {
@@ -109,7 +130,7 @@ function parseBridges(problemAscii: string) {
         };
         for (let cell = c + 1; cell < next; cell += 1) {
           opp.cells.push([r, cell]);
-          cellToOpportunity.set(`${r}:${cell}`, opp);
+          addBridgeOpportunityForCell(cellToOpportunities, r, cell, opp);
         }
         opportunities.push(opp);
       }
@@ -133,13 +154,106 @@ function parseBridges(problemAscii: string) {
         };
         for (let cell = r + 1; cell < nextRow; cell += 1) {
           opp.cells.push([cell, c]);
-          cellToOpportunity.set(`${cell}:${c}`, opp);
+          addBridgeOpportunityForCell(cellToOpportunities, cell, c, opp);
         }
         opportunities.push(opp);
       }
     }
   }
-  return { lines, opportunities, cellToOpportunity };
+  return { lines, opportunities, cellToOpportunities };
+}
+
+function bridgeLevelFromCells(opportunity: BridgesOpportunity, boardLines: string[]): 0 | 1 | 2 {
+  let level: 0 | 1 | 2 = 0;
+  for (const [r, c] of opportunity.cells) {
+    const cellLevel = bridgeLevelFromChar(opportunity, boardLines[r]?.[c] ?? ".");
+    if (cellLevel === 2) {
+      return 2;
+    }
+    if (cellLevel === 1) {
+      level = 1;
+    }
+  }
+  return level;
+}
+
+function sortedBridgeCandidates(opportunities: BridgesOpportunity[]): BridgesOpportunity[] {
+  return [...opportunities].sort((a, b) => {
+    if (a.kind !== b.kind) {
+      return a.kind === "horizontal" ? -1 : 1;
+    }
+    return a.id.localeCompare(b.id);
+  });
+}
+
+function bridgeClickCountForOpportunity(
+  opportunities: BridgesOpportunity[],
+  opportunity: BridgesOpportunity,
+  level: 0 | 1 | 2,
+): number {
+  if (level === 0 || opportunities.length <= 1) {
+    return level;
+  }
+  const index = sortedBridgeCandidates(opportunities).findIndex(
+    (candidate) => candidate.id === opportunity.id,
+  );
+  return index === -1 ? level : index * 2 + level;
+}
+
+function cycleBridgesOpportunities(
+  states: Record<string, 0 | 1 | 2>,
+  opportunities: BridgesOpportunity[],
+): Record<string, 0 | 1 | 2> {
+  if (opportunities.length === 0) {
+    return states;
+  }
+
+  const nextStates = { ...states };
+  const candidates = sortedBridgeCandidates(opportunities);
+
+  if (candidates.length === 1) {
+    const opportunity = candidates[0];
+    const level = (((nextStates[opportunity.id] ?? 0) + 1) % 3) as 0 | 1 | 2;
+    nextStates[opportunity.id] = level;
+    return nextStates;
+  }
+
+  const sequence: Array<{ opportunity: BridgesOpportunity; level: 1 | 2 } | null> = [
+    ...candidates.flatMap((opportunity) => [
+      { opportunity, level: 1 as const },
+      { opportunity, level: 2 as const },
+    ]),
+    null,
+  ];
+  const isSequenceMatch = (entry: (typeof sequence)[number]) =>
+    candidates.every((opportunity) => {
+      const expected = entry?.opportunity.id === opportunity.id ? entry.level : 0;
+      return (nextStates[opportunity.id] ?? 0) === expected;
+    });
+  let currentIndex = sequence.findIndex(isSequenceMatch);
+
+  if (currentIndex === -1) {
+    const active = candidates.find((opportunity) => (nextStates[opportunity.id] ?? 0) > 0);
+    currentIndex = active
+      ? sequence.findIndex(
+          (entry) =>
+            entry?.opportunity.id === active.id &&
+            entry.level === (nextStates[active.id] ?? 0),
+        )
+      : sequence.length - 1;
+    if (currentIndex === -1) {
+      currentIndex = sequence.length - 1;
+    }
+  }
+
+  const nextEntry = sequence[(currentIndex + 1) % sequence.length];
+  for (const opportunity of candidates) {
+    nextStates[opportunity.id] = 0;
+  }
+  if (nextEntry) {
+    nextStates[nextEntry.opportunity.id] = nextEntry.level;
+  }
+  return nextStates;
 }
 
 function bridgesBoardFromStates(
@@ -158,8 +272,7 @@ function bridgesBoardFromStates(
     if (level === 0) {
       continue;
     }
-    const symbol =
-      opportunity.kind === "horizontal" ? (level === 2 ? "=" : "-") : level === 2 ? '"' : "|";
+    const symbol = bridgeSymbol(opportunity, level);
     for (const [r, c] of opportunity.cells) {
       grid[r][c] = symbol;
     }
@@ -175,13 +288,7 @@ function bridgesStatesFromBoard(
   const boardLines = splitLines(boardAscii);
   const states: Record<string, 0 | 1 | 2> = {};
   for (const opportunity of parsed.opportunities) {
-    const [r, c] = opportunity.cells[0];
-    const char = boardLines[r]?.[c] ?? ".";
-    if (opportunity.kind === "horizontal") {
-      states[opportunity.id] = char === "=" ? 2 : char === "-" ? 1 : 0;
-    } else {
-      states[opportunity.id] = char === '"' ? 2 : char === "|" ? 1 : 0;
-    }
+    states[opportunity.id] = bridgeLevelFromCells(opportunity, boardLines);
   }
   return states;
 }
@@ -449,10 +556,8 @@ function BridgesEditor({ problemAscii, boardAscii, onChange }: Omit<Props, "puzz
   const parsed = parseBridges(problemAscii);
   const states = bridgesStatesFromBoard(problemAscii, boardAscii);
 
-  function cycle(opportunity: BridgesOpportunity) {
-    const nextStates = { ...states };
-    const current = nextStates[opportunity.id] ?? 0;
-    nextStates[opportunity.id] = ((current + 1) % 3) as 0 | 1 | 2;
+  function cycle(opportunities: BridgesOpportunity[]) {
+    const nextStates = cycleBridgesOpportunities(states, opportunities);
     onChange(bridgesBoardFromStates(problemAscii, nextStates));
   }
 
@@ -465,11 +570,11 @@ function BridgesEditor({ problemAscii, boardAscii, onChange }: Omit<Props, "puzz
       >
         {parsed.lines.flatMap((line, r) =>
           [...line].map((char, c) => {
-            const opportunity = parsed.cellToOpportunity.get(`${r}:${c}`);
+            const opportunities = parsed.cellToOpportunities.get(`${r}:${c}`) ?? [];
             const boardChar = splitLines(boardAscii)[r]?.[c] ?? char;
             const className = isClueChar(char)
               ? "board-cell fixed island-cell"
-              : opportunity
+              : opportunities.length > 0
                 ? "board-cell bridge-cell"
                 : "board-cell water";
             const display =
@@ -479,8 +584,8 @@ function BridgesEditor({ problemAscii, boardAscii, onChange }: Omit<Props, "puzz
                 key={`${r}-${c}`}
                 type="button"
                 className={className}
-                onClick={() => opportunity && cycle(opportunity)}
-                disabled={!opportunity}
+                onClick={() => cycle(opportunities)}
+                disabled={opportunities.length === 0}
               >
                 {isClueChar(char) ? char : display}
               </button>
@@ -952,6 +1057,8 @@ export const __testables = {
   cloneGrid,
   joinGrid,
   parseBridges,
+  cycleBridgesOpportunities,
+  bridgeClickCountForOpportunity,
   bridgesBoardFromStates,
   bridgesStatesFromBoard,
   parseLoopy,

frontend/test/pipeline/bridges_clickplan.json

@@ -135,6 +135,8 @@
   22,
   22,
   17,
+  17,
+  17,
   21,
   37,
   37,
@@ -186,6 +188,10 @@
   33,
   35,
   35,
+  35,
+  35,
+  44,
+  44,
   44,
   44,
   49,
@@ -214,7 +220,7 @@
   15,
   18,
   18,
-  21,
+  22,
   30,
   30,
   32,
@@ -229,14 +235,20 @@
   62,
   64,
   73,
+  73,
+  73,
   66,
   75,
+  75,
+  75,
   79,
   71,
   71,
   80,
   80,
   84,
+  84,
+  84,
   86,
   82,
   91,
@@ -263,7 +275,7 @@
   63,
   67,
   76,
-  71,
+  72,
   80,
   80,
   82,

frontend/test/pipeline/roundtrip.test.ts

@@ -71,11 +71,20 @@ for (const f of fixtures.filter((x) => x.family === "bridges")) {
     const level = target[opp.id] ?? 0;
     if (level === 0) continue;
     const owned =
-      opp.cells.find(
-        ([r, c]: [number, number]) => parsed.cellToOpportunity.get(`${r}:${c}`)?.id === opp.id,
-      ) ?? opp.cells[0];
+      opp.cells.find(([r, c]: [number, number]) => {
+        const candidates = parsed.cellToOpportunities.get(`${r}:${c}`) ?? [];
+        return candidates.length === 1 && candidates[0].id === opp.id;
+      }) ??
+      opp.cells.find(([r, c]: [number, number]) =>
+        (parsed.cellToOpportunities.get(`${r}:${c}`) ?? []).some(
+          (candidate: { id: string }) => candidate.id === opp.id,
+        ),
+      ) ??
+      opp.cells[0];
     const idx = indexOf(owned[0], owned[1]);
-    for (let i = 0; i < level; i += 1) clicks.push(idx);
+    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);
   }
   bridgesClickPlan[f.filename] = clicks;
 }
@@ -97,3 +106,120 @@ describe("editor round-trip preserves a valid solution (idempotency)", () => {
     });
   }
 });
+
+describe("bridges generated click plans", () => {
+  for (const f of fixtures.filter((fixture) => fixture.family === "bridges")) {
+    it(`${f.filename}: replays to the reference solution state`, () => {
+      const parsed = T.parseBridges(f.problem);
+      const target = T.bridgesStatesFromBoard(f.problem, f.solution);
+      const lineLens: number[] = parsed.lines.map((line: string) => line.length);
+      const indexToCoord = (idx: number): [number, number] => {
+        let offset = idx;
+        for (let r = 0; r < lineLens.length; r += 1) {
+          if (offset < lineLens[r]) {
+            return [r, offset];
+          }
+          offset -= lineLens[r];
+        }
+        throw new Error(`click index out of bounds: ${idx}`);
+      };
+
+      let states: Record<string, 0 | 1 | 2> = {};
+      for (const idx of bridgesClickPlan[f.filename] ?? []) {
+        const [r, c] = indexToCoord(idx);
+        states = T.cycleBridgesOpportunities(
+          states,
+          parsed.cellToOpportunities.get(`${r}:${c}`) ?? [],
+        );
+      }
+
+      for (const opportunity of parsed.opportunities) {
+        expect(states[opportunity.id] ?? 0).toBe(target[opportunity.id] ?? 0);
+      }
+    });
+  }
+});
+
+describe("bridges ambiguous route cells", () => {
+  const crossingProblem = ["..2..", ".....", "2...2", ".....", "..2.."].join("\n");
+
+  it("keeps both crossing bridge opportunities selectable from the shared cell", () => {
+    const parsed = T.parseBridges(crossingProblem);
+    const centerCandidates = parsed.cellToOpportunities.get("2:2") ?? [];
+
+    expect(centerCandidates.map((candidate: { kind: string }) => candidate.kind).sort()).toEqual([
+      "horizontal",
+      "vertical",
+    ]);
+  });
+
+  it("cycles a shared cell through both bridge directions and back to empty", () => {
+    const parsed = T.parseBridges(crossingProblem);
+    const centerCandidates = parsed.cellToOpportunities.get("2:2") ?? [];
+    const horizontal = centerCandidates.find(
+      (candidate: { kind: string }) => candidate.kind === "horizontal",
+    );
+    const vertical = centerCandidates.find(
+      (candidate: { kind: string }) => candidate.kind === "vertical",
+    );
+    expect(horizontal).toBeTruthy();
+    expect(vertical).toBeTruthy();
+
+    let states: Record<string, 0 | 1 | 2> = {};
+    states = T.cycleBridgesOpportunities(states, centerCandidates);
+    expect(states[horizontal!.id]).toBe(1);
+    expect(states[vertical!.id] ?? 0).toBe(0);
+
+    states = T.cycleBridgesOpportunities(states, centerCandidates);
+    expect(states[horizontal!.id]).toBe(2);
+    expect(states[vertical!.id] ?? 0).toBe(0);
+
+    states = T.cycleBridgesOpportunities(states, centerCandidates);
+    expect(states[horizontal!.id] ?? 0).toBe(0);
+    expect(states[vertical!.id]).toBe(1);
+
+    states = T.cycleBridgesOpportunities(states, centerCandidates);
+    expect(states[horizontal!.id] ?? 0).toBe(0);
+    expect(states[vertical!.id]).toBe(2);
+
+    states = T.cycleBridgesOpportunities(states, centerCandidates);
+    expect(states[horizontal!.id] ?? 0).toBe(0);
+    expect(states[vertical!.id] ?? 0).toBe(0);
+  });
+
+  it("cycles a unique cell route independently", () => {
+    const parsed = T.parseBridges(crossingProblem);
+    const centerCandidates = parsed.cellToOpportunities.get("2:2") ?? [];
+    const verticalCandidates = parsed.cellToOpportunities.get("1:2") ?? [];
+    const horizontal = centerCandidates.find(
+      (candidate: { kind: string }) => candidate.kind === "horizontal",
+    );
+    const vertical = centerCandidates.find(
+      (candidate: { kind: string }) => candidate.kind === "vertical",
+    );
+    expect(horizontal).toBeTruthy();
+    expect(vertical).toBeTruthy();
+
+    let states: Record<string, 0 | 1 | 2> = {};
+    states = T.cycleBridgesOpportunities(states, centerCandidates);
+    states = T.cycleBridgesOpportunities(states, verticalCandidates);
+
+    expect(states[horizontal!.id]).toBe(1);
+    expect(states[vertical!.id]).toBe(1);
+  });
+
+  it("decodes bridge state from non-leading route cells", () => {
+    const parsed = T.parseBridges(crossingProblem);
+    const horizontal = parsed.cellToOpportunities
+      .get("2:2")
+      ?.find((candidate: { kind: string }) => candidate.kind === "horizontal");
+    expect(horizontal).toBeTruthy();
+
+    const states = T.bridgesStatesFromBoard(
+      crossingProblem,
+      ["..2..", ".....", "2..-2", ".....", "..2.."].join("\n"),
+    );
+
+    expect(states[horizontal!.id]).toBe(1);
+  });
+});