dualfroz/gambit
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(search): add pvs search with quiescence and pruning

Browse Source
This commit is contained in:
dualfroz committed 2026-08-25 15:50:00 +02:00
1 parent 1f8e60c168
commit 2a9bf0c22f
1 file changed
+390
Download Patch File Download Diff File Expand all files Collapse all files
Search.scala
+390
View File
@@ -0,0 +1,390 @@
package gambit
final case class SearchResult(bestMove: Int, score: Int, depth: Int, nodes: Long, pv: List[Int])
final class Searcher:
import Searcher.*
val tt = new TranspositionTable()
var nodes: Long = 0L
var useTt: Boolean = true
var useNullMove: Boolean = true
var onIteration: (Int, Int, Long, Long, List[Int]) => Unit = (_, _, _, _, _) => ()
private val maxPly = 128
private val killers = Array.ofDim[Int](maxPly, 2)
private val historyTable = Array.ofDim[Int](2, 128 * 128)
private val pathHashes = new Array[Long](4096)
private val staticEvals = new Array[Int](maxPly + 4)
private var historyLen = 0
var useLmr: Boolean = true
var usePruning: Boolean = true
private var deadline = 0L
private var useTime = false
@volatile private var stopped = false
private var startNanos = 0L
def stop(): Unit = stopped = true
def setGameHistory(hashes: Array[Long], len: Int): Unit =
var i = 0
while i < len do
pathHashes(i) = hashes(i)
i += 1
historyLen = len
def wouldRepeat(pos: Position, ancestors: Array[Long]): Boolean =
setGameHistory(ancestors, ancestors.length)
pathHashes(historyLen) = pos.hash
isRepetition(pos, 0)
def search(pos: Position, maxDepth: Int, timeMs: Long): SearchResult =
newSearch()
useTime = timeMs > 0
startNanos = System.nanoTime()
deadline = startNanos + timeMs * 1000000L
val depthCap = math.min(maxDepth, maxPly - 1)
var bestMove = 0
var bestScore = 0
var pv: List[Int] = Nil
var completed = 0
var window = AspirationWindow
var depth = 1
while depth <= depthCap && !stopped do
val useAspiration = depth >= 4
val alpha0 = if useAspiration then bestScore - window else -Infinity
val beta0 = if useAspiration then bestScore + window else Infinity
var (score, move) = searchRoot(pos, depth, alpha0, beta0)
if !stopped && (score <= alpha0 || score >= beta0) then
val res = searchRoot(pos, depth, -Infinity, Infinity)
score = res._1
move = res._2
if !stopped then
bestMove = move
bestScore = score
completed = depth
pv = extractPv(pos, depth)
onIteration(depth, bestScore, nodes, elapsedMs(), pv)
depth += 1
SearchResult(bestMove, bestScore, completed, nodes, pv)
def bestMove(pos: Position, depth: Int): (Int, Int) =
historyLen = 0
val r = search(pos, depth, 0)
(r.bestMove, r.score)
private def newSearch(): Unit =
nodes = 0L
stopped = false
var p = 0
while p < maxPly do
killers(p)(0) = 0
killers(p)(1) = 0
p += 1
java.util.Arrays.fill(historyTable(0), 0)
java.util.Arrays.fill(historyTable(1), 0)
private def elapsedMs(): Long = (System.nanoTime() - startNanos) / 1000000L
private def searchRoot(pos: Position, depth: Int, alpha0: Int, beta: Int): (Int, Int) =
pathHashes(historyLen) = pos.hash
val moves = new MoveList()
MoveGen.generateLegal(pos, moves)
val ttMove = if useTt then tt.probeMove(pos.hash) else 0
orderMoves(pos, moves, ttMove, 0)
var alpha = alpha0
var best = -Infinity
var bestMove = if moves.size > 0 then moves(0) else 0
var i = 0
while i < moves.size && !stopped do
val m = moves(i)
val undo = pos.make(m)
var score =
if i == 0 then -negamax(pos, depth - 1, -beta, -alpha, 1)
else
val trial = -negamax(pos, depth - 1, -alpha - 1, -alpha, 1)
if !stopped && trial > alpha && trial < beta then -negamax(pos, depth - 1, -beta, -alpha, 1)
else trial
pos.unmake(m, undo)
if !stopped then
if score > best then
best = score
bestMove = m
if best > alpha then alpha = best
if alpha >= beta then i = moves.size
i += 1
if !stopped && useTt then
val flag = if best <= alpha0 then TT.Upper else if best >= beta then TT.Lower else TT.Exact
tt.store(pos.hash, depth, best, flag, bestMove, 0)
(best, bestMove)
private def negamax(pos: Position, depth0: Int, alpha0: Int, beta: Int, ply: Int): Int =
nodes += 1
if useTime && (nodes & 2047L) == 0L && System.nanoTime() >= deadline then stopped = true
if stopped then return 0
pathHashes(historyLen + ply) = pos.hash
if isRepetition(pos, ply) || Draw.isFiftyMove(pos) then return DrawScore
val pvNode = beta - alpha0 > 1
val side = pos.sideToMove
val inChk = pos.inCheck(side)
val depth = if inChk && ply < maxPly - 1 then depth0 + 1 else depth0
val ttScore = if useTt then tt.probe(pos.hash, depth, alpha0, beta, ply) else TT.Unknown
val ttMove = if useTt then tt.hitMove else 0
if ttScore != TT.Unknown && !pvNode then return ttScore
if depth <= 0 then return quiescence(pos, alpha0, beta, ply)
val notMateBound = beta < TT.MateBound && beta > -TT.MateBound
val staticEval = if inChk then -Infinity else Eval.evaluate(pos)
staticEvals(ply) = staticEval
val improving = !inChk && ply >= 2 && staticEval > staticEvals(ply - 2)
if usePruning && !pvNode && !inChk && notMateBound then
if depth <= SearchParams.reverseFutilityDepth
&& staticEval - SearchParams.reverseFutilityMargin * depth >= beta
then return staticEval - SearchParams.reverseFutilityMargin * depth
if depth <= SearchParams.razorDepth
&& staticEval + SearchParams.razorMargin(depth) <= alpha0
then
val razorScore = quiescence(pos, alpha0, alpha0 + 1, ply)
if razorScore <= alpha0 then return razorScore
if useNullMove && !pvNode && !inChk && depth >= 3 && notMateBound
&& staticEval >= beta && hasNonPawnMaterial(pos, side)
then
val reduction = 2 + depth / 6
val nullState = makeNull(pos)
val nullScore = -negamax(pos, depth - 1 - reduction, -beta, -beta + 1, ply + 1)
unmakeNull(pos, nullState)
if stopped then return 0
if nullScore >= beta then return beta
val moves = new MoveList()
MoveGen.generateLegal(pos, moves)
if moves.size == 0 then
if inChk then return -MateValue + ply else return 0
orderMoves(pos, moves, ttMove, ply)
val futilityBase = staticEval + SearchParams.futilityMargin * depth
var alpha = alpha0
var best = -Infinity
var bestMove = 0
var cutoff = false
var searched = 0
var i = 0
while i < moves.size && !cutoff do
val m = moves(i)
val quiet = !Move.isCapture(m) && !Move.isPromotion(m)
val undo = pos.make(m)
val givesCheck = pos.inCheck(pos.sideToMove)
val prune =
usePruning && !pvNode && !inChk && quiet && !givesCheck && searched > 0 && best > -TT.MateBound &&
((depth <= SearchParams.lmpDepth && i >= SearchParams.lmpBase(if improving then 1 else 0)(depth))
|| (depth <= SearchParams.futilityDepth && futilityBase <= alpha))
if prune then pos.unmake(m, undo)
else
val reduction =
if useLmr && depth >= SearchParams.lmrMinDepth && searched >= SearchParams.lmrMinIndex
&& quiet && !inChk && !givesCheck
then
var r = SearchParams.lmrReduction(depth, searched)
if !pvNode then r += 1
if m == killers(if ply < maxPly then ply else maxPly - 1)(0) then r -= 1
math.max(0, math.min(r, depth - 2))
else 0
val score =
if searched == 0 then -negamax(pos, depth - 1, -beta, -alpha, ply + 1)
else
var trial = -negamax(pos, depth - 1 - reduction, -alpha - 1, -alpha, ply + 1)
if !stopped && reduction > 0 && trial > alpha then
trial = -negamax(pos, depth - 1, -alpha - 1, -alpha, ply + 1)
if !stopped && trial > alpha && trial < beta then
trial = -negamax(pos, depth - 1, -beta, -alpha, ply + 1)
trial
pos.unmake(m, undo)
searched += 1
if stopped then return 0
if score > best then
best = score
bestMove = m
if best > alpha then alpha = best
if alpha >= beta then
cutoff = true
if quiet then
recordKiller(ply, m)
recordHistory(side, m, depth)
i += 1
if searched == 0 then
if inChk then return -MateValue + ply else return DrawScore
if useTt then
val flag = if best <= alpha0 then TT.Upper else if cutoff then TT.Lower else TT.Exact
tt.store(pos.hash, depth, best, flag, bestMove, ply)
best
private def makeNull(pos: Position): (Int, Long) =
val savedEp = pos.epSquare
val savedHash = pos.hash
if savedEp >= 0 then pos.hash ^= Zobrist.epFileKeys(Square.fileOf(savedEp))
pos.epSquare = -1
pos.sideToMove = pos.sideToMove ^ 1
pos.hash ^= Zobrist.sideKey
(savedEp, savedHash)
private def unmakeNull(pos: Position, state: (Int, Long)): Unit =
pos.sideToMove = pos.sideToMove ^ 1
pos.epSquare = state._1
pos.hash = state._2
private def hasNonPawnMaterial(pos: Position, color: Int): Boolean =
val board = pos.board
var sq = 0
while sq < 128 do
if Square.onBoard(sq) then
val p = board(sq)
if p != Piece.Empty && (p >> 3) == color then
val pt = p & 7
if pt == Piece.Knight || pt == Piece.Bishop || pt == Piece.Rook || pt == Piece.Queen then
return true
sq += 1
false
private def quiescence(pos: Position, alpha0: Int, beta: Int): Int =
nodes += 1
val standPat = Eval.evaluate(pos)
if standPat >= beta then return beta
var alpha = math.max(alpha0, standPat)
val moves = new MoveList()
MoveGen.generatePseudo(pos, moves, capturesOnly = true)
orderCaptures(pos, moves)
val mover = pos.sideToMove
var i = 0
while i < moves.size do
val m = moves(i)
val undo = pos.make(m)
if pos.isAttacked(pos.kingSquare(mover), pos.sideToMove) then pos.unmake(m, undo)
else
val score = -quiescence(pos, -beta, -alpha)
pos.unmake(m, undo)
if score >= beta then return beta
if score > alpha then alpha = score
i += 1
alpha
private def isRepetition(pos: Position, ply: Int): Boolean =
val current = historyLen + ply
val stop = math.max(0, current - pos.halfmove)
var i = current - 2
while i >= stop do
if pathHashes(i) == pos.hash then return true
i -= 2
false
private def recordKiller(ply: Int, m: Int): Unit =
if ply < maxPly && killers(ply)(0) != m then
killers(ply)(1) = killers(ply)(0)
killers(ply)(0) = m
private def recordHistory(side: Int, m: Int, depth: Int): Unit =
historyTable(side)(Move.from(m) * 128 + Move.to(m)) += depth * depth
private def orderMoves(pos: Position, moves: MoveList, ttMove: Int, ply: Int): Unit =
val n = moves.size
val scores = new Array[Int](n)
val side = pos.sideToMove
val kply = if ply < maxPly then ply else maxPly - 1
val k0 = killers(kply)(0)
val k1 = killers(kply)(1)
var i = 0
while i < n do
val m = moves(i)
scores(i) =
if m == ttMove && ttMove != 0 then 2000000
else if Move.isCapture(m) then 1000000 + mvvLva(pos, m)
else if Move.isPromotion(m) then 900000 + Eval.pieceValue(Move.promo(m))
else if m == k0 && k0 != 0 then 800000
else if m == k1 && k1 != 0 then 700000
else historyTable(side)(Move.from(m) * 128 + Move.to(m))
i += 1
sortByScores(moves, scores)
private def orderCaptures(pos: Position, moves: MoveList): Unit =
val n = moves.size
val scores = new Array[Int](n)
var i = 0
while i < n do
val m = moves(i)
scores(i) =
if Move.isCapture(m) then mvvLva(pos, m)
else if Move.isPromotion(m) then Eval.pieceValue(Move.promo(m))
else 0
i += 1
sortByScores(moves, scores)
private def sortByScores(moves: MoveList, scores: Array[Int]): Unit =
val n = moves.size
var i = 0
while i < n do
var bestIdx = i
var j = i + 1
while j < n do
if scores(j) > scores(bestIdx) then bestIdx = j
j += 1
if bestIdx != i then
val tmpMove = moves(i)
moves(i) = moves(bestIdx)
moves(bestIdx) = tmpMove
val tmpScore = scores(i)
scores(i) = scores(bestIdx)
scores(bestIdx) = tmpScore
i += 1
private def mvvLva(pos: Position, m: Int): Int =
val victim = if Move.isEnPassant(m) then Piece.Pawn else Piece.typeOf(pos.board(Move.to(m)))
val attacker = Piece.typeOf(pos.board(Move.from(m)))
Eval.pieceValue(victim) * 16 - Eval.pieceValue(attacker)
private def extractPv(pos: Position, maxLen: Int): List[Int] =
val out = List.newBuilder[Int]
val trail = scala.collection.mutable.ArrayDeque[(Int, Undo)]()
var steps = 0
var continue = true
while continue && steps < maxLen do
val m = tt.probeMove(pos.hash)
if m == 0 || !isLegal(pos, m) then continue = false
else
out += m
trail.append((m, pos.make(m)))
steps += 1
while trail.nonEmpty do
val (m, u) = trail.removeLast()
pos.unmake(m, u)
out.result()
private def isLegal(pos: Position, m: Int): Boolean =
val legal = new MoveList()
MoveGen.generateLegal(pos, legal)
var i = 0
while i < legal.size do
if legal(i) == m then return true
i += 1
false
object Searcher:
val MateValue = 30000
val Infinity = 1000000
val DrawScore = 0
val AspirationWindow = 25