Refine bot ladders and portal setup

Author: Swon404

src/GameContext.tsx

@@ -21,19 +21,19 @@ import {
 type Mode =
   | { kind: "two-player" }
   | { kind: "bot"; level: number }
-  | { kind: "portal"; opponent: "two-player" | { kind: "bot"; level: number }; creator: PieceType; adjacencyRule?: boolean; portalMax?: number };
+  | { kind: "portal"; opponent: "two-player" | { kind: "bot"; level: number }; creator: PieceType; portalMax?: number };
 export interface Players { w: string; b: string; }
 
 interface NewGameOptions {
   timerSeconds?: number;
 }
 
 /** Build the initial state for Portal Chess (creator-type portals). */
-function portalInitialState(creator: PieceType, adjacencyRule = false, portalMax = 1): GameState {
+function portalInitialState(creator: PieceType, portalMax = 2): GameState {
   const s = initialState();
   s.portals = { w: [], b: [], max: portalMax };
   s.portalCreators = { w: creator, b: creator };
-  s.portalAdjacencyRule = adjacencyRule;
+  s.portalAdjacencyRule = false;
   return s;
 }
 
@@ -181,13 +181,13 @@ export function GameProvider({ children }: { children: ReactNode }) {
       } else if (lastMove?.isPortalEntry) {
         playSound("teleport");
       } else if (lastMove?.captured) {
-        playSound("capture");
+        if (!store.settings.explodeOnCapture) playSound("capture");
       } else {
         playSound("move");
       }
     }
     soundedLenRef.current = state.history.length;
-  }, [state, result, mode, store.settings.sound]);
+  }, [state, result, mode, store.settings.sound, store.settings.explodeOnCapture]);
 
   // Persist active session so a refresh / PWA relaunch resumes the game.
   useEffect(() => {
@@ -389,7 +389,7 @@ export function GameProvider({ children }: { children: ReactNode }) {
           ? `Bot Lv ${m.opponent.level}`
           : "Player 2";
     setPlayers({ w: p?.w ?? defaultW, b: p?.b ?? defaultB });
-    const fresh = m.kind === "portal" ? portalInitialState(m.creator, m.adjacencyRule === true, m.portalMax ?? 1) : initialState();
+    const fresh = m.kind === "portal" ? portalInitialState(m.creator, m.portalMax ?? 2) : initialState();
     dispatch({ type: "new", initial: fresh });
     setSelected(null);
     setPaused(false);

src/components/Board.tsx

@@ -1,6 +1,7 @@
 import { CSSProperties, useLayoutEffect, useState } from "react";
 import { Move, Piece as PieceT, Square, squareName } from "../engine/board";
 import { findKing, inCheck } from "../engine/rules";
+import { playSound } from "../engine/sound";
 import { useGame } from "../GameContext";
 import { Piece } from "./Piece";
 
@@ -104,6 +105,7 @@ export function Board({ flipped = false }: Props) {
       setIsAnimatingLastMove(false);
       if (current.captured && store.settings.explodeOnCapture) {
         setShowCaptureBoom(true);
+        playSound("boom", store.settings.sound);
         const boomId = window.setTimeout(() => setShowCaptureBoom(false), 620);
         return () => window.clearTimeout(boomId);
       }
@@ -116,6 +118,7 @@ export function Board({ flipped = false }: Props) {
       setIsAnimatingLastMove(false);
       if (current.captured && store.settings.explodeOnCapture) {
         setShowCaptureBoom(true);
+        playSound("boom", store.settings.sound);
         boomId = window.setTimeout(() => setShowCaptureBoom(false), 620);
       }
     }, durationMs);

src/engine/__tests__/portal.test.ts

@@ -102,14 +102,14 @@ describe("Portal Chess: teleport entry", () => {
     expect(targets.some((t) => sqEq(t, parseSquare("e6")))).toBe(true);
   });
 
-  it("Adjacency rule is bypassed when the teleport delivers check", () => {
+  it("Teleport into an attacked square is illegal even if it would give check", () => {
     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("g4"))
       .filter((m) => m.isPortalEntry && sqEq(m.to, parseSquare("f6")));
-    expect(moves.length).toBe(1);
+    expect(moves.length).toBe(0);
   });
 
   it("With adjacency rule OFF (default), targets next to other pieces are allowed", () => {
@@ -120,19 +120,16 @@ describe("Portal Chess: teleport entry", () => {
     expect(targets.some((t) => sqEq(t, parseSquare("c2")))).toBe(true);
   });
 
-  it("Teleport that leaves own king in check is illegal", () => {
+  it("Teleport options are empty when every destination is attacked or exposes king", () => {
     // 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.to.file).toBe(0); // must stay on the a-file
-    }
+    expect(moves.length).toBe(0);
   });
 
-  it("Cannot teleport into an attacked square unless that square is also a legal normal move", () => {
+  it("Cannot teleport into an attacked square", () => {
     // Black rook on d8 attacks d-file squares (including d3/d4).
     // White knight on f3 is on its own portal.
     const s = asPortal(parseFEN("3r3k/8/8/8/8/8/8/K7 w - - 0 1"));
@@ -141,11 +138,9 @@ describe("Portal Chess: teleport entry", () => {
 
     const tele = legalMovesFrom(s, parseSquare("f3")).filter((m) => m.isPortalEntry);
 
-    // d3 is attacked by the rook but is NOT a legal normal knight destination.
+    // d3 and d4 are attacked by the rook, so both are illegal teleport targets.
     expect(tele.some((m) => sqEq(m.to, parseSquare("d3")))).toBe(false);
-
-    // d4 is attacked too, but IS a legal normal knight destination from f3.
-    expect(tele.some((m) => sqEq(m.to, parseSquare("d4")))).toBe(true);
+    expect(tele.some((m) => sqEq(m.to, parseSquare("d4")))).toBe(false);
   });
 });
 

src/engine/bot.ts

@@ -70,8 +70,8 @@ interface BotOptions {
 
 /**
  * Choose a move for the bot at a given difficulty (1-20).
- * Levels 1-4 use the built-in minimax with increasing depth and decreasing randomness.
- * Levels 5-20 can delegate to an external Stockfish API when enabled; if unavailable,
+ * Levels 1-5 use the built-in minimax with increasing depth and decreasing randomness.
+ * Levels 6-20 can delegate to an external Stockfish API when enabled; if unavailable,
  * fall back to local minimax.
  */
 export async function chooseBotMove(state: GameState, level: number, opts?: BotOptions): Promise<Move | null> {
@@ -81,7 +81,7 @@ export async function chooseBotMove(state: GameState, level: number, opts?: BotO
   const normalizedLevel = Math.max(1, Math.min(20, Math.round(level)));
   const canUseExternal = opts?.allowExternal !== false && !state.portals;
 
-  if (canUseExternal && normalizedLevel >= 5) {
+  if (canUseExternal && normalizedLevel >= 6) {
     try {
       const { stockfishBestMove } = await import("./bot/stockfish");
       const best = await stockfishBestMove(state, normalizedLevel);
@@ -97,7 +97,8 @@ export async function chooseBotMove(state: GameState, level: number, opts?: BotO
   // Level 2: ~50% random, depth-1 search the rest.
   // Level 3: depth-2, occasional blunder.
   // Level 4: depth-2 clean.
-  // Level 5+: deterministic minimax fallback if external engine is unavailable.
+  // Level 5: strongest local-only learn level.
+  // Level 6+: deterministic minimax fallback if external engine is unavailable.
   const blunderChanceByLevel: Record<number, number> = { 1: 0.8, 2: 0.5, 3: 0.15, 4: 0.03 };
   const blunderChance = blunderChanceByLevel[normalizedLevel] ?? 0;
   const depth = normalizedLevel <= 2 ? 1 : normalizedLevel <= 4 ? 2 : normalizedLevel <= 8 ? 3 : 4;

src/engine/rules.ts

@@ -417,13 +417,6 @@ export function legalMovesFrom(state: GameState, from: Square): Move[] {
     if (!inCheck(ns, p.color)) out.push(m);
   }
 
-  // For portal safety rule: track legal non-portal destinations from this
-  // square. Teleporting into an attacked square is only allowed when this
-  // piece could already move to that destination without using a portal.
-  const normalLegalTargets = new Set(
-    out.map((m) => `${m.to.file},${m.to.rank}`)
-  );
-
   // Portal Chess (deferred warp): if this piece is currently sitting on its
   // own side's portal, it may also teleport to any empty square. Pawns and
   // the creator piece can't use portals.
@@ -446,9 +439,7 @@ export function legalMovesFrom(state: GameState, from: Square): Move[] {
       };
       const ns = makeMove(state, tpMove);
       if (inCheck(ns, p.color)) continue;
-      const attackedAfterTeleport = isSquareAttacked(ns, t, opposite(p.color));
-      const legalNormally = normalLegalTargets.has(`${t.file},${t.rank}`);
-      if (attackedAfterTeleport && !legalNormally) continue;
+      if (isSquareAttacked(ns, t, opposite(p.color))) continue;
       if (adjacency) {
         const adjacent = teleportIsAdjacentToPiece(state, t, from);
         if (adjacent && !inCheck(ns, opposite(p.color))) continue;

src/engine/sound.ts

@@ -1,7 +1,7 @@
 // Lightweight Web Audio synth for UI sounds — no external asset files.
 // Each sound is a tiny oscillator burst so the PWA stays offline-friendly.
 
-type SoundName = "move" | "capture" | "check" | "win" | "draw" | "loss" | "teleport";
+type SoundName = "move" | "capture" | "boom" | "check" | "win" | "draw" | "loss" | "teleport";
 
 let ctx: AudioContext | null = null;
 function getCtx(): AudioContext | null {
@@ -36,6 +36,11 @@ export function playSound(name: SoundName, enabled = true) {
   try {
     if (name === "move")    { tone(440, 70, "triangle", 0.12); }
     else if (name === "capture") { tone(180, 90, "square",  0.14); tone(110, 120, "sawtooth", 0.08, 30); }
+    else if (name === "boom") {
+      tone(82, 220, "sawtooth", 0.2);
+      tone(64, 260, "square", 0.14, 20);
+      tone(220, 120, "triangle", 0.07, 45);
+    }
     else if (name === "check")   { tone(880, 110, "sine",   0.15); tone(1175, 120, "sine", 0.13, 90); }
     else if (name === "win")     { tone(523, 120, "triangle"); tone(659, 120, "triangle", 0.15, 120); tone(784, 180, "triangle", 0.18, 240); }
     else if (name === "loss")    { tone(392, 140, "sawtooth", 0.14); tone(311, 220, "sawtooth", 0.14, 140); }

src/engine/storage.ts

@@ -39,6 +39,9 @@ export interface Settings {
   autoFlip: boolean;
   showThreats: boolean;
   explodeOnCapture: boolean;
+  portalCreatorDefault: PieceType;
+  portalOpponentDefault: "two-player" | "bot";
+  portalMaxDefault: 1 | 2 | 3;
 }
 
 export interface SavedGame {
@@ -67,14 +70,32 @@ const DEFAULT_SETTINGS: Settings = {
   haptics: true,
   autoFlip: true,
   showThreats: false,
-  explodeOnCapture: false
+  explodeOnCapture: false,
+  portalCreatorDefault: "N",
+  portalOpponentDefault: "bot",
+  portalMaxDefault: 2
 };
 
 function normalizePieceSet(value: unknown): PieceSet {
   if (value === "classic" || value === "modern" || value === "neon") return value;
   return "neon";
 }
 
+function normalizePortalCreator(value: unknown): PieceType {
+  if (value === "Q" || value === "R" || value === "B" || value === "N" || value === "K") return value;
+  return "N";
+}
+
+function normalizePortalOpponent(value: unknown): "two-player" | "bot" {
+  if (value === "two-player" || value === "bot") return value;
+  return "bot";
+}
+
+function normalizePortalMax(value: unknown): 1 | 2 | 3 {
+  if (value === 1 || value === 2 || value === 3) return value;
+  return 2;
+}
+
 function emptyStats(): ProfileStats {
   return {
     wins: 0, losses: 0, draws: 0, rating: 800,
@@ -92,7 +113,10 @@ export function load(): Store {
     parsed.settings = {
       ...DEFAULT_SETTINGS,
       ...rawSettings,
-      pieceSet: normalizePieceSet(rawSettings?.pieceSet)
+      pieceSet: normalizePieceSet(rawSettings?.pieceSet),
+      portalCreatorDefault: normalizePortalCreator(rawSettings?.portalCreatorDefault),
+      portalOpponentDefault: normalizePortalOpponent(rawSettings?.portalOpponentDefault),
+      portalMaxDefault: normalizePortalMax(rawSettings?.portalMaxDefault)
     };
     parsed.savedGames = parsed.savedGames ?? {};
     return parsed;

src/screens/NewGameScreen.tsx

@@ -1,4 +1,4 @@
-import { useState } from "react";
+import { useEffect, useState } from "react";
 import { Link, useNavigate } from "react-router-dom";
 import { PieceType } from "../engine/board";
 import { useGame } from "../GameContext";
@@ -12,10 +12,14 @@ export function NewGameScreen() {
   const [whiteName, setWhiteName] = useState<string>(activeProfile?.name ?? "");
   const [blackName, setBlackName] = useState<string>("");
   // Portal Chess sub-options
-  const [portalCreator, setPortalCreator] = useState<PieceType>("N");
-  const [portalOpponentKind, setPortalOpponentKind] = useState<"two-player" | "bot">("bot");
-  const [portalAdjacencyRule, setPortalAdjacencyRule] = useState<boolean>(false);
-  const [portalMax, setPortalMax] = useState<1 | 2 | 3>(1);
+  const [portalCreator, setPortalCreator] = useState<PieceType>(store.settings.portalCreatorDefault);
+  const [portalOpponentKind, setPortalOpponentKind] = useState<"two-player" | "bot">(store.settings.portalOpponentDefault);
+  const [portalMax, setPortalMax] = useState<1 | 2 | 3>(store.settings.portalMaxDefault);
+  const maxLevel = kind === "bot" ? 20 : 10;
+
+  useEffect(() => {
+    if (level > maxLevel) setLevel(maxLevel);
+  }, [level, maxLevel]);
 
   const ensureProfile = (name: string): string => {
     const trimmed = name.trim();
@@ -30,6 +34,9 @@ export function NewGameScreen() {
 
   const start = () => {
     updateSetting("timerSeconds", timer);
+    updateSetting("portalCreatorDefault", portalCreator);
+    updateSetting("portalOpponentDefault", portalOpponentKind);
+    updateSetting("portalMaxDefault", portalMax);
 
     // Ensure white profile exists and is active — stats are tied to this name
     const w = ensureProfile(whiteName || "Player 1");
@@ -46,12 +53,12 @@ export function NewGameScreen() {
       if (portalOpponentKind === "two-player") {
         const b = ensureProfile(blackName || "Player 2");
         newGame(
-          { kind: "portal", opponent: "two-player", creator: portalCreator, adjacencyRule: portalAdjacencyRule, portalMax },
+          { kind: "portal", opponent: "two-player", creator: portalCreator, portalMax },
           { w, b }
         );
       } else {
         newGame(
-          { kind: "portal", opponent: { kind: "bot", level }, creator: portalCreator, adjacencyRule: portalAdjacencyRule, portalMax },
+          { kind: "portal", opponent: { kind: "bot", level }, creator: portalCreator, portalMax },
           { w, b: `Bot Lv ${level}` }
         );
       }
@@ -138,20 +145,6 @@ export function NewGameScreen() {
             </p>
           </section>
 
-          <section>
-            <h3>House rules</h3>
-            <label>
-              <input type="checkbox"
-                checked={portalAdjacencyRule}
-                onChange={(e) => setPortalAdjacencyRule(e.target.checked)} />
-              {" "}Prevent teleport next to any piece
-            </label>
-            <p className="hint">
-              When ticked, teleport targets cannot be adjacent to any other piece.
-              When unticked (default), you can teleport anywhere empty &mdash; or stay
-              on the portal square (the portal remains active).
-            </p>
-          </section>
         </>
       )}
 
@@ -203,17 +196,48 @@ export function NewGameScreen() {
       {showLevel && (
         <section>
           <h3>Bot difficulty</h3>
-          <div className="difficulty">
-            {Array.from({ length: 10 }, (_, i) => i + 1).map((lv) => (
-              <button
-                key={lv}
-                className={lv === level ? "pill active" : "pill"}
-                onClick={() => setLevel(lv)}
-              >{lv}</button>
-            ))}
-          </div>
+          {kind === "bot" ? (
+            <div className="bot-level-groups">
+              <div className="bot-level-group">
+                <div className="bot-level-label">Learn</div>
+                <div className="bot-level-grid learn-grid">
+                  {Array.from({ length: 5 }, (_, i) => i + 1).map((lv) => (
+                    <button
+                      key={lv}
+                      className={lv === level ? "pill active" : "pill"}
+                      onClick={() => setLevel(lv)}
+                    >{lv}</button>
+                  ))}
+                </div>
+              </div>
+              <div className="bot-level-group">
+                <div className="bot-level-label">Challenge</div>
+                <div className="bot-level-grid challenge-grid">
+                  {Array.from({ length: 15 }, (_, i) => i + 6).map((lv) => (
+                    <button
+                      key={lv}
+                      className={lv === level ? "pill active" : "pill"}
+                      onClick={() => setLevel(lv)}
+                    >{lv}</button>
+                  ))}
+                </div>
+              </div>
+            </div>
+          ) : (
+            <div className="difficulty">
+              {Array.from({ length: maxLevel }, (_, i) => i + 1).map((lv) => (
+                <button
+                  key={lv}
+                  className={lv === level ? "pill active" : "pill"}
+                  onClick={() => setLevel(lv)}
+                >{lv}</button>
+              ))}
+            </div>
+          )}
           <p className="hint">
-            Level 1 is very easy (good for a new learner). Levels 6+ use a stronger engine when available.
+            {kind === "bot"
+              ? "Learn levels 1-5 use the local bot and are tuned for practice. Challenge levels 6-20 use Stockfish when online, with local fallback offline."
+              : "Portal-bot mode uses the in-house engine and supports levels 1-10."}
           </p>
         </section>
       )}