Portal Chess: deferred-warp rules. Landing on own portal does nothing immediately; on a later turn the piece may teleport from the portal to any empty square. Piece cannot stay on portal; portal is spent when the piece leaves. Creator does not consume own portals. Removed click-time portal-target picker (unique destinations make it unnecessary). Rewrote engine tests; portal puzzles are temporarily empty pending regeneration.

Author: Swon404

.github/copilot-instructions.md

@@ -7,7 +7,7 @@ Project conventions and gotchas for AI agents working in this repository.
 - React 19 + TypeScript (strict), Vite 8, `vite-plugin-pwa`
 - Vitest 3.2.4 (1400+ tests)
 - Deployed to GitHub Pages at `https://swon404.github.io/SpeedChess/` (base `/SpeedChess/`)
-- Dev server: `npm run dev` (port 5180)
+- Dev server: `npm run dev` (port 6180)
 - `npm install` requires `--legacy-peer-deps`
 
 ## Repo Layout

src/components/Board.tsx

@@ -1,4 +1,4 @@
-import { CSSProperties, useEffect, useState } from "react";
+import { CSSProperties, useState } from "react";
 import { Move, Piece as PieceT, Square, squareName } from "../engine/board";
 import { findKing, inCheck } from "../engine/rules";
 import { useGame } from "../GameContext";
@@ -18,51 +18,22 @@ interface PendingPromo {
   color: "w" | "b";
 }
 
-interface PendingPortal {
-  from: Square;
-  to: Square;
-  targets: Move[];
-}
-
 export function Board({ flipped = false }: Props) {
   const { state, selected, legalFromSelected, select, tryMove, result, store, hint } = useGame();
   const theme = store.settings.theme;
   const pieceSet = store.settings.pieceSet;
   const [pending, setPending] = useState<PendingPromo | null>(null);
-  const [portalChoice, setPortalChoice] = useState<PendingPortal | null>(null);
-
-  // Cancel pending portal selection if the position changes (e.g. opponent move).
-  useEffect(() => {
-    setPortalChoice(null);
-  }, [state.history.length]);
 
   const ranks = flipped ? [0, 1, 2, 3, 4, 5, 6, 7] : [7, 6, 5, 4, 3, 2, 1, 0];
   const files = flipped ? [7, 6, 5, 4, 3, 2, 1, 0] : [0, 1, 2, 3, 4, 5, 6, 7];
 
   const onSquareClick = (sq: Square) => {
     if (result.kind !== "ongoing") return;
-    // If we're picking a teleport target, route the click there first.
-    if (portalChoice) {
-      const t = portalChoice.targets.find(
-        (m) => m.portalTo && m.portalTo.file === sq.file && m.portalTo.rank === sq.rank
-      );
-      if (t && t.portalTo) {
-        tryMove(portalChoice.from, portalChoice.to, undefined, t.portalTo);
-        setPortalChoice(null);
-        return;
-      }
-      // Any other click cancels the teleport selection.
-      setPortalChoice(null);
-      return;
-    }
     const target = isLegalTarget(legalFromSelected, sq);
     if (selected && target) {
-      // Portal entry: gather all teleport options sharing this destination.
-      const portalCandidates = legalFromSelected.filter(
-        (m) => m.isPortalEntry && m.to.file === sq.file && m.to.rank === sq.rank
-      );
-      if (portalCandidates.length > 0) {
-        setPortalChoice({ from: selected, to: sq, targets: portalCandidates });
+      if (target.isPortalEntry) {
+        // Deferred-warp teleport: destination is unique, no picker needed.
+        tryMove(selected, sq, undefined, sq);
         return;
       }
       if (target.promotion) {
@@ -84,10 +55,7 @@ export function Board({ flipped = false }: Props) {
     : null;
   const wPortals = state.portals?.w ?? [];
   const bPortals = state.portals?.b ?? [];
-  const isTeleportMove =
-    !!lastMove?.isPortalEntry &&
-    !!lastMove.portalTo &&
-    !(lastMove.portalTo.file === lastMove.to.file && lastMove.portalTo.rank === lastMove.to.rank);
+  const isTeleportMove = !!lastMove?.isPortalEntry;
 
   return (
     <>
@@ -110,14 +78,12 @@ export function Board({ flipped = false }: Props) {
               const isPortalW = wPortals.some((p) => p.file === f && p.rank === r);
               const isPortalB = bPortals.some((p) => p.file === f && p.rank === r);
               const isTeleportTarget =
-                portalChoice && portalChoice.targets.some(
-                  (m) => m.portalTo && m.portalTo.file === f && m.portalTo.rank === r
-                );
+                !!legal && !!legal.isPortalEntry;
               const classes = [
                 "square",
                 isLight ? "light" : "dark",
                 isSelected ? "selected" : "",
-                legal && !portalChoice ? (piece ? "legal-capture" : "legal-move") : "",
+                legal && !isTeleportTarget ? (piece ? "legal-capture" : "legal-move") : "",
                 isTeleportTarget ? "legal-teleport" : "",
                 (isLastFrom || isLastTo || isLastTeleport) ? "last-move" : "",
                 isChecked ? "in-check" : "",

src/engine/__tests__/portal.test.ts

@@ -67,98 +67,68 @@ describe("Portal Chess: portal creation", () => {
 });
 
 describe("Portal Chess: teleport entry", () => {
-  it("Knight landing on a portal is forced to teleport", () => {
-    // Place a black portal at f3, white knight on g1, no other obstructions.
-    const s = asPortal(parseFEN("8/8/8/8/8/8/8/6N1 w - - 0 1"));
-    s.portals = { w: [], b: [parseSquare("f3")], max: 1 };
-    const moves = legalMovesFrom(s, parseSquare("g1"));
-    const fMoves = moves.filter((m) => m.to.file === 5 && m.to.rank === 2);
-    expect(fMoves.length).toBeGreaterThan(0);
-    // All these must be portal entries.
-    expect(fMoves.every((m) => m.isPortalEntry && m.portalTo)).toBe(true);
-  });
-
-  it("Bishop teleport is restricted to same-colour squares as the portal", () => {
-    // Place a portal at e4 (light square). Bishop must teleport to a light square only.
-    const s = asPortal(parseFEN("8/8/8/8/8/8/8/4B3 w - - 0 1"));
-    s.portals = { w: [], b: [parseSquare("e4")], max: 1 };
-    // First move bishop e1 -> e4? bishops can't move file-only. Use diagonal.
-    // Place bishop at h1 and portal at a8 (both light)? Let's pick portal at d3 (dark).
-    s.portals = { w: [], b: [parseSquare("d3")], max: 1 };
-    s.board[0][4] = null;
-    s.board[0][5] = { type: "B", color: "w" }; // Bf1
-    const moves = legalMovesFrom(s, parseSquare("f1")).filter((m) => sqEq(m.to, parseSquare("d3")));
+  it("Knight standing on its own portal has teleport options on next move", () => {
+    const s = asPortal(parseFEN("8/8/8/8/8/8/8/8 w - - 0 1"));
+    s.board[2][5] = { type: "N", color: "w" }; // Nf3
+    s.portals = { w: [parseSquare("f3")], b: [], max: 1 };
+    const moves = legalMovesFrom(s, parseSquare("f3"));
+    const tele = moves.filter((m) => m.isPortalEntry);
+    expect(tele.length).toBeGreaterThan(0);
+    expect(tele.every((m) => m.portalTo && sqEq(m.portalTo, m.to))).toBe(true);
+  });
+
+  it("Bishop on its own portal teleports only to same-colour squares", () => {
+    const s = asPortal(parseFEN("8/8/8/8/8/8/8/8 w - - 0 1"));
+    s.board[2][3] = { type: "B", color: "w" }; // Bd3
+    s.portals = { w: [parseSquare("d3")], b: [], max: 1 };
+    const moves = legalMovesFrom(s, parseSquare("d3")).filter((m) => m.isPortalEntry);
     expect(moves.length).toBeGreaterThan(0);
-    // d3 is a light square ((3+2)%2=1 -> light). All teleport targets must be light.
+    // d3 is light: (3+2)%2=1.
     for (const m of moves) {
-      expect(m.portalTo).toBeDefined();
-      const t = m.portalTo!;
-      expect((t.file + t.rank) % 2).toBe(1); // light
+      expect((m.to.file + m.to.rank) % 2).toBe(1);
     }
   });
 
   it("Teleport adjacency rule rejects targets next to any piece (when enabled)", () => {
-    // White king a1, white knight h4 (can reach portal at f3), pawn at b3,
-    // black king h8 (far). Adjacency rule on -> teleport target adjacent to
-    // b3 must be excluded; far empty squares like e6 must be allowed.
-    const s = asPortal(parseFEN("7k/8/8/8/7N/1P6/8/K7 w - - 0 1"));
-    s.portals = { w: [], b: [parseSquare("f3")], max: 1 };
+    const s = asPortal(parseFEN("7k/8/8/8/8/1P6/8/K7 w - - 0 1"));
+    s.board[2][5] = { type: "N", color: "w" }; // Nf3 on its own portal
+    s.portals = { w: [parseSquare("f3")], b: [], max: 1 };
     s.portalAdjacencyRule = true;
-    const moves = legalMovesFrom(s, parseSquare("h4"))
-      .filter((m) => sqEq(m.to, parseSquare("f3")) && m.portalTo);
-    const targets = moves.map((m) => m.portalTo!);
-    // Squares adjacent to b3 (and not to any other piece) -> excluded.
+    const moves = legalMovesFrom(s, parseSquare("f3")).filter((m) => m.isPortalEntry);
+    const targets = moves.map((m) => m.to);
     for (const name of ["a2", "a4", "b2", "b4", "c2", "c4"]) {
       expect(targets.some((t) => sqEq(t, parseSquare(name)))).toBe(false);
     }
-    // A far empty square (no adjacent piece) is allowed.
     expect(targets.some((t) => sqEq(t, parseSquare("e6")))).toBe(true);
   });
 
   it("Adjacency rule is bypassed when the teleport delivers check", () => {
-    // Black king e8, black pawn e7, white knight h6, portal at g4,
-    // white king a1. Knight Nh6-g4 lands on portal; teleport target f6 is
-    // adjacent to the e7 pawn (forbidden by adjacency rule) but f6 delivers
-    // a knight check on e8, so the move IS legal.
-    const s = asPortal(parseFEN("4k3/4p3/7N/8/8/8/8/K7 w - - 0 1"));
-    s.portals = { w: [], b: [parseSquare("g4")], max: 1 };
+    const s = asPortal(parseFEN("4k3/4p3/8/8/8/8/8/K7 w - - 0 1"));
+    s.board[3][6] = { type: "N", color: "w" }; // Ng4 on its own portal
+    s.portals = { w: [parseSquare("g4")], b: [], max: 1 };
     s.portalAdjacencyRule = true;
-    const moves = legalMovesFrom(s, parseSquare("h6"))
-      .filter((m) => sqEq(m.to, parseSquare("g4")) && m.portalTo
-        && sqEq(m.portalTo, parseSquare("f6")));
+    const moves = legalMovesFrom(s, parseSquare("g4"))
+      .filter((m) => m.isPortalEntry && sqEq(m.to, parseSquare("f6")));
     expect(moves.length).toBe(1);
   });
 
   it("With adjacency rule OFF (default), targets next to other pieces are allowed", () => {
-    const s = asPortal(parseFEN("8/8/8/8/8/1P6/8/6N1 w - - 0 1"));
-    s.portals = { w: [], b: [parseSquare("f3")], max: 1 };
-    const targets = teleportTargets(s, parseSquare("g1"), parseSquare("f3"), { type: "N", color: "w" });
-    // c2 is adjacent to b3; with the rule off it's permitted.
+    const s = asPortal(parseFEN("8/8/8/8/8/1P6/8/8 w - - 0 1"));
+    s.board[2][5] = { type: "N", color: "w" }; // Nf3 on its own portal
+    s.portals = { w: [parseSquare("f3")], b: [], max: 1 };
+    const targets = teleportTargets(s, parseSquare("f3"), parseSquare("f3"), { type: "N", color: "w" });
     expect(targets.some((t) => sqEq(t, parseSquare("c2")))).toBe(true);
   });
 
   it("Teleport that leaves own king in check is illegal", () => {
-    // White king on e1, white knight on g1, black rook on e8 pinning along e-file.
-    // Portal at f3 lets the knight teleport, but moving the knight to a non-e-file
-    // square is fine — the pin doesn't apply because the knight isn't blocking.
-    // Construct a real pin: White K e1, white N e2 (blocks check from black R e8),
-    // portal at f3 (offered by enemy). Knight Ne2 -> ... wait, Ne2 cannot reach f3
-    // in one move. Use a rook scenario.
-    // Easier: White K a1, white R a2 (only piece blocking black R a8). White R
-    // moving anywhere off the a-file would expose the king. Add portal at b2.
-    // Rook can move a2->b2 (which lands on portal). Teleport must not leave the
-    // king exposed -> all teleport targets are illegal because moving the rook
-    // off the a-file uncovers check.
-    const s = asPortal(parseFEN("r6k/8/8/8/8/8/R7/K7 w - - 0 1"));
-    s.portals = { w: [], b: [parseSquare("b2")], max: 1 };
-    const moves = legalMovesFrom(s, parseSquare("a2"))
-      .filter((m) => sqEq(m.to, parseSquare("b2")));
-    // Any legal teleport must keep the rook on the a-file (file 0) so the
-    // black rook on a8 is still blocked from giving check.
+    // Black rook a8 pins the white rook against the king on a1.
+    const s = asPortal(parseFEN("r6k/8/8/8/8/8/8/K7 w - - 0 1"));
+    s.board[1][0] = { type: "R", color: "w" }; // Ra2 on its own portal
+    s.portals = { w: [parseSquare("a2")], b: [], max: 1 };
+    const moves = legalMovesFrom(s, parseSquare("a2")).filter((m) => m.isPortalEntry);
     expect(moves.length).toBeGreaterThan(0);
     for (const m of moves) {
-      expect(m.portalTo).toBeDefined();
-      expect(m.portalTo!.file).toBe(0);
+      expect(m.to.file).toBe(0); // must stay on the a-file
     }
   });
 });
@@ -178,40 +148,25 @@ describe("Portal Chess: creator pass-through and capture-then-teleport", () => {
     expect(ns.portals?.w).toEqual([]);
   });
 
-  it("Knight captures a piece on a portal then teleports", () => {
-    // White N at g1, black portal at f3 with a black pawn sitting on f3.
+  it("Knight capturing a piece on its own portal lands normally and may teleport later", () => {
     const s = asPortal(parseFEN("8/8/8/8/8/5p2/8/6N1 w - - 0 1"));
-    s.portals = { w: [], b: [parseSquare("f3")], max: 1 };
-    // Pick a non-stay teleport variant so the portal is consumed.
-    const moves = legalMovesFrom(s, parseSquare("g1"))
-      .filter((m) => sqEq(m.to, parseSquare("f3"))
-        && m.portalTo && !sqEq(m.portalTo, parseSquare("f3")));
-    expect(moves.length).toBeGreaterThan(0);
-    expect(moves[0].captured).toBe("P");
-    expect(moves[0].isPortalEntry).toBe(true);
-    const ns = makeMove(s, moves[0]);
-    // Portal consumed.
-    expect(ns.portals?.b).toEqual([]);
-    // Knight is at portalTo, NOT at f3.
-    expect(ns.board[2][5]).toBeNull();
-    expect(ns.board[moves[0].portalTo!.rank][moves[0].portalTo!.file]).toEqual({ type: "N", color: "w" });
-    // The captured pawn is gone.
-    let pawnCount = 0;
-    for (const row of ns.board) for (const p of row) if (p?.type === "P" && p.color === "b") pawnCount++;
-    expect(pawnCount).toBe(0);
+    s.portals = { w: [parseSquare("f3")], b: [], max: 1 };
+    const cap = legalMovesFrom(s, parseSquare("g1")).filter((m) => sqEq(m.to, parseSquare("f3")));
+    expect(cap.length).toBe(1);
+    expect(cap[0].isPortalEntry).toBeFalsy();
+    expect(cap[0].captured).toBe("P");
+    const ns = makeMove(s, cap[0]);
+    expect(ns.board[2][5]).toEqual({ type: "N", color: "w" });
+    expect(ns.portals?.w).toEqual([parseSquare("f3")]);
   });
 
-  it("Stay-in-place teleport: piece can choose portal square as target; portal stays active", () => {
-    const s = asPortal(parseFEN("8/8/8/8/8/8/8/6N1 w - - 0 1"));
-    s.portals = { w: [], b: [parseSquare("f3")], max: 1 };
-    const stayMove = legalMovesFrom(s, parseSquare("g1"))
-      .find((m) => m.isPortalEntry && m.portalTo && sqEq(m.portalTo, parseSquare("f3")));
-    expect(stayMove).toBeDefined();
-    const ns = makeMove(s, stayMove!);
-    // Knight ends on f3 (the portal square).
-    expect(ns.board[2][5]).toEqual({ type: "N", color: "w" });
-    // Portal remains active.
-    expect(ns.portals?.b).toEqual([parseSquare("f3")]);
+  it("Piece on portal cannot teleport to its own portal square (must move off)", () => {
+    const s = asPortal(parseFEN("8/8/8/8/8/8/8/8 w - - 0 1"));
+    s.board[2][5] = { type: "N", color: "w" };
+    s.portals = { w: [parseSquare("f3")], b: [], max: 1 };
+    const stay = legalMovesFrom(s, parseSquare("f3"))
+      .find((m) => m.isPortalEntry && sqEq(m.to, parseSquare("f3")));
+    expect(stay).toBeUndefined();
   });
 });
 
@@ -240,14 +195,14 @@ describe("Portal Chess: creator life", () => {
 });
 
 describe("Portal Chess: legal-move enumeration", () => {
-  it("allLegalMoves expands portal entries into per-target moves", () => {
-    const s = asPortal(parseFEN("8/8/8/8/8/8/8/6N1 w - - 0 1"));
-    s.portals = { w: [], b: [parseSquare("f3")], max: 1 };
+  it("allLegalMoves includes per-target teleport moves from a piece on its portal", () => {
+    const s = asPortal(parseFEN("8/8/8/8/8/8/8/8 w - - 0 1"));
+    s.board[2][5] = { type: "N", color: "w" };
+    s.portals = { w: [parseSquare("f3")], b: [], max: 1 };
     const moves = allLegalMoves(s);
-    const onPortal = moves.filter((m) => sqEq(m.to, parseSquare("f3")));
-    // Multiple teleport targets => multiple legal moves landing on f3.
-    expect(onPortal.length).toBeGreaterThan(1);
-    expect(onPortal.every((m) => m.isPortalEntry && m.portalTo)).toBe(true);
+    const tele = moves.filter((m) => m.isPortalEntry && sqEq(m.from, parseSquare("f3")));
+    expect(tele.length).toBeGreaterThan(1);
+    expect(tele.every((m) => m.portalTo)).toBe(true);
   });
 
   it("Pawn landing on a portal is a single regular move (no teleport variants)", () => {