Update dragons

shared/bot/BotDefinitions.ts

@@ -105,9 +105,9 @@ export function getSelfPlayBotIds(): DatasetBotId[] {
 export function createDatasetBot(id: DatasetBotId, options: DatasetBotOptions = {}): DatasetBot {
   if (id === 'random') return new RandomBot()
   if (id === 'greedy') return new GreedyBot()
-  if (id === 'minimax_weak') return new MinimaxDatasetBot(id, { maxDepth: 1, timeBudgetMs: 80, candidateRadius: 1 })
-  if (id === 'minimax_balanced') return new MinimaxDatasetBot(id, { maxDepth: 2, timeBudgetMs: 180, candidateRadius: 2 })
-  if (id === 'minimax_strong') return new MinimaxDatasetBot(id, { maxDepth: 3, timeBudgetMs: 320, candidateRadius: 2 })
+  if (id === 'minimax_weak') return new MinimaxDatasetBot(id, { maxDepth: 1, timeBudgetMs: 80, candidateRadius: 1, panicPly: 1 })
+  if (id === 'minimax_balanced') return new MinimaxDatasetBot(id, { maxDepth: 2, timeBudgetMs: 180, candidateRadius: 2, panicPly: 1 })
+  if (id === 'minimax_strong') return new MinimaxDatasetBot(id, { maxDepth: 3, timeBudgetMs: 320, candidateRadius: 2, panicPly: 2 })
   if (id === 'mcts_weak') return new MctsDatasetBot(id, { simulations: 48, rolloutDepth: 12, exploration: 1.4, candidateRadius: 1, earlyTemperature: 1, lateTemperature: 0.15 }, options)
   if (id === 'mcts_balanced') return new MctsDatasetBot(id, { simulations: 96, rolloutDepth: 18, exploration: 1.2, candidateRadius: 2, earlyTemperature: 0.75, lateTemperature: 0.08 }, options)
   if (id === 'mcts_strong') return new MctsDatasetBot(id, { simulations: 192, rolloutDepth: 24, exploration: 1.05, candidateRadius: 2, earlyTemperature: 0.6, lateTemperature: 0.03 }, options)
@@ -177,7 +177,7 @@ class MinimaxDatasetBot implements DatasetBot {
   readonly params: Record<string, number | string | boolean>
   private readonly bot: MinimaxAlphaBetaBot
 
-  constructor(id: DatasetBotId, options: { maxDepth: number; timeBudgetMs: number; candidateRadius: number }) {
+  constructor(id: DatasetBotId, options: { maxDepth: number; timeBudgetMs: number; candidateRadius: number; panicPly?: number }) {
     this.id = id
     this.params = { strategy: 'minimax', attitude: minimaxAttitude(id), aggressionWeight: 0.65, defensiveBias: 0.85, ...options }
     this.bot = new MinimaxAlphaBetaBot({ ...options, enableThreatSpaceSearch: false })

shared/bot/MinimaxAlphaBetaBot.ts

@@ -27,6 +27,7 @@ export interface MinimaxAlphaBetaOptions {
   enableKillerMoves?: boolean
   enableIterativeDeepening?: boolean
   enableThreatSpaceSearch?: boolean
+  panicPly?: number
 }
 
 interface ThreatSummary {
@@ -61,7 +62,10 @@ export class MinimaxAlphaBetaBot {
   private readonly enableKillerMoves: boolean
   private readonly enableIterativeDeepening: boolean
   private readonly enableThreatSpaceSearch: boolean
+  private readonly panicPly: number
   private deadline = 0
+  private hardDeadline = 0
+  private panicked = false
   private hasher = new ZobristHasher(BOARD_SIZE)
   private transpositionTable = new Map<bigint, TranspositionEntry>()
   private killerMoves: BotMove[][] = []
@@ -76,6 +80,7 @@ export class MinimaxAlphaBetaBot {
     this.enableKillerMoves = options.enableKillerMoves ?? true
     this.enableIterativeDeepening = options.enableIterativeDeepening ?? true
     this.enableThreatSpaceSearch = options.enableThreatSpaceSearch ?? true
+    this.panicPly = options.panicPly ?? 1
   }
 
   selectMove(context: BotContext): BotMove {
@@ -84,6 +89,8 @@ export class MinimaxAlphaBetaBot {
     const player = context.currentPlayer
     const opponent = otherPlayer(player)
     this.deadline = Date.now() + this.timeBudgetMs
+    this.hardDeadline = Date.now() + Math.max(this.timeBudgetMs * 1.5, this.timeBudgetMs + 200)
+    this.panicked = false
     this.hasher = new ZobristHasher(boardSize)
     this.transpositionTable.clear()
     this.killerMoves = []
@@ -120,6 +127,7 @@ export class MinimaxAlphaBetaBot {
     let ordered = this.orderMoves(board, candidates, player, context, 0)
     let best = ordered[0]
     let bestScore = -Infinity
+    let searchedAny = false
     const maxDepth = this.enableIterativeDeepening ? this.maxDepth : this.maxDepth
     const startDepth = this.enableIterativeDeepening ? 1 : this.maxDepth
 
@@ -130,12 +138,11 @@ export class MinimaxAlphaBetaBot {
       ordered = this.orderMoves(board, ordered, player, context, 0, best)
 
       for (const move of ordered) {
-        if (this.outOfTime()) {
-          completedDepth = false
-          break
-        }
+        if (this.outOfTime()) break
         const next = this.withMove(board, move, player, context.playerSymbols)
         const score = this.minimax(next, depth - 1, -Infinity, Infinity, false, opponent, player, context, 1)
+        if (this.outOfTime()) break
+        searchedAny = true
         if (score > depthBestScore || (score === depthBestScore && compareMove(move, depthBest) < 0)) {
           depthBest = move
           depthBestScore = score
@@ -149,9 +156,99 @@ export class MinimaxAlphaBetaBot {
       if (!this.enableIterativeDeepening) break
       }
 
+    if (!searchedAny || this.panicked) {
+      const panicMove = this.panicMove(board, player, opponent, context, boardSize)
+      if (panicMove) return panicMove
+    }
+
     return best
   }
 
+  private panicMove(
+    board: Map<string, Cell>,
+    player: number,
+    opponent: number,
+    context: BotContext,
+    boardSize: number,
+  ): BotMove | null {
+    const candidates = this.generateCandidates(board, boardSize)
+    if (candidates.length === 0) return null
+
+    const ownWin = this.findWinningMove(board, candidates, player, context.playerSymbols, context.rules)
+    if (ownWin) return ownWin
+
+    const blockWin = this.findWinningMove(board, candidates, opponent, context.playerSymbols, context.rules)
+    if (blockWin) return blockWin
+
+    const ordered = this.orderMoves(board, candidates, player, context, 0).slice(0, this.maxCandidates)
+    let best = ordered[0]
+    let bestScore = -Infinity
+
+    for (const move of ordered) {
+      if (this.hardOutOfTime()) break
+      const next = this.withMove(board, move, player, context.playerSymbols)
+      const score = this.panicMinimax(next, this.panicPly - 1, -Infinity, Infinity, false, opponent, player, context, 1)
+      if (score > bestScore || (score === bestScore && compareMove(move, best) < 0)) {
+        best = move
+        bestScore = score
+      }
+    }
+
+    return best
+  }
+
+  private panicMinimax(
+    board: Map<string, Cell>,
+    depth: number,
+    alpha: number,
+    beta: number,
+    maximizing: boolean,
+    turn: number,
+    rootPlayer: number,
+    context: BotContext,
+    ply: number,
+  ): number {
+    if (depth <= 0 || this.hardOutOfTime()) {
+      return this.evaluate(board, rootPlayer, context)
+    }
+
+    const boardSize = context.boardSize ?? context.rules.boardSize ?? BOARD_SIZE
+    const candidates = this.orderMoves(board, this.generateCandidates(board, boardSize), turn, {
+      ...context,
+      board: Object.fromEntries(board),
+      currentPlayer: turn,
+    }, ply).slice(0, this.maxCandidates)
+
+    if (candidates.length === 0) return this.evaluate(board, rootPlayer, context)
+
+    if (maximizing) {
+      let value = -Infinity
+      for (const move of candidates) {
+        const next = this.withMove(board, move, turn, context.playerSymbols)
+        if (checkWin(next, move.x, move.y, String(turn), context.rules.noOverlines).won) {
+          return WIN_SCORE - (this.panicPly - depth)
+        }
+        value = Math.max(value, this.panicMinimax(next, depth - 1, alpha, beta, false, otherPlayer(turn), rootPlayer, context, ply + 1))
+        alpha = Math.max(alpha, value)
+        if (alpha >= beta || this.hardOutOfTime()) break
+      }
+      return value
+    }
+
+    let value = Infinity
+    for (const move of candidates) {
+      const next = this.withMove(board, move, turn, context.playerSymbols)
+      if (checkWin(next, move.x, move.y, String(turn), context.rules.noOverlines).won) {
+        return -WIN_SCORE + (this.panicPly - depth)
+      }
+      value = Math.min(value, this.panicMinimax(next, depth - 1, alpha, beta, true, otherPlayer(turn), rootPlayer, context, ply + 1))
+      beta = Math.min(beta, value)
+      if (alpha >= beta || this.hardOutOfTime()) break
+    }
+
+    return value
+  }
+
   private minimax(
     board: Map<string, Cell>,
     depth: number,
@@ -659,7 +756,15 @@ export class MinimaxAlphaBetaBot {
   }
 
   private outOfTime(): boolean {
-    return Date.now() >= this.deadline
+    if (Date.now() >= this.deadline) {
+      this.panicked = true
+      return true
+    }
+    return false
+  }
+
+  private hardOutOfTime(): boolean {
+    return Date.now() >= this.hardDeadline
   }
 
   private recordKillerMove(ply: number, move: BotMove): void {