add killer move heuristics to engine

Author: RubikNube

cmd/engine/alpha_beta_engine.go

@@ -2,14 +2,20 @@ package engine
 
 import "github.com/RubikNube/GoInGo/cmd/game"
 
-// AlphaBetaEngine implements Engine using an evaluation function and alpha-beta pruning.
-type AlphaBetaEngine struct{}
+// AlphaBetaEngine implements Engine using alpha-beta pruning with killer move heuristic.
+type AlphaBetaEngine struct {
+	killerMoves map[int]*game.Point // depth -> killer move
+}
+
+func NewAlphaBetaEngine() *AlphaBetaEngine {
+	return &AlphaBetaEngine{killerMoves: make(map[int]*game.Point)}
+}
 
 // Move in AlphaBetaEngine uses alpha-beta pruning to select the best move or pass if no beneficial move exists.
 func (e *AlphaBetaEngine) Move(board game.Board, player game.FieldState, ko *game.Point) *game.Point {
 	bestScore := -1 << 30
 	var bestMove *game.Point
-	depth := 3 // Shallow for performance; increase for stronger play
+	depth := 4 // Shallow for performance; increase for stronger play
 	moveFound := false
 
 	for i := 0; i < 9; i++ {
@@ -42,7 +48,7 @@ func (e *AlphaBetaEngine) Move(board game.Board, player game.FieldState, ko *gam
 			if len(libs) == 0 {
 				continue
 			}
-			score := -alphaBeta(nextBoard, opp, player, ko, depth-1, -1<<30, 1<<30)
+			score := -e.alphaBeta(nextBoard, opp, player, ko, depth-1, -1<<30, 1<<30)
 			moveFound = true
 			if score > bestScore {
 				bestScore = score
@@ -52,7 +58,7 @@ func (e *AlphaBetaEngine) Move(board game.Board, player game.FieldState, ko *gam
 		}
 	}
 	// Pass if no move found or if passing is as good or better than any move
-	passScore := -alphaBeta(board, opponent(player), player, ko, depth-1, -1<<30, 1<<30)
+	passScore := -e.alphaBeta(board, opponent(player), player, ko, depth-1, -1<<30, 1<<30)
 	if !moveFound || passScore >= bestScore {
 		return nil // pass
 	}
@@ -67,12 +73,46 @@ func opponent(player game.FieldState) game.FieldState {
 	return game.Black
 }
 
-// alphaBeta is a minimax search with alpha-beta pruning and pass support.
-func alphaBeta(board game.Board, player, opp game.FieldState, ko *game.Point, depth, alpha, beta int) int {
+// alphaBeta is a minimax search with alpha-beta pruning and killer move heuristic.
+func (e *AlphaBetaEngine) alphaBeta(board game.Board, player, opp game.FieldState, ko *game.Point, depth, alpha, beta int) int {
 	if depth == 0 {
 		return evaluate(board, player, opp)
 	}
 	foundMove := false
+
+	// Try killer move first if available
+	if killer, ok := e.killerMoves[depth]; ok && killer != nil && board[killer.Row][killer.Col] == game.Empty {
+		pt := *killer
+		if ko == nil || pt.Row != ko.Row || pt.Col != ko.Col {
+			var nextBoard game.Board
+			copy(nextBoard[:], board[:])
+			nextBoard[pt.Row][pt.Col] = player
+			for _, n := range game.Neighbors(pt) {
+				if nextBoard[n.Row][n.Col] == opp {
+					group, libs := game.Group(nextBoard, n)
+					if len(libs) == 0 {
+						for stonePt := range group {
+							nextBoard[stonePt.Row][stonePt.Col] = game.Empty
+						}
+					}
+				}
+			}
+			_, libs := game.Group(nextBoard, pt)
+			if len(libs) != 0 {
+				foundMove = true
+				score := -e.alphaBeta(nextBoard, opp, player, ko, depth-1, -beta, -alpha)
+				if score > alpha {
+					alpha = score
+					// Update killer move if this move caused a beta cutoff
+					if alpha >= beta {
+						e.killerMoves[depth] = &pt
+						return alpha
+					}
+				}
+			}
+		}
+	}
+
 	for i := 0; i < 9; i++ {
 		for j := 0; j < 9; j++ {
 			if board[i][j] != game.Empty {
@@ -82,6 +122,10 @@ func alphaBeta(board game.Board, player, opp game.FieldState, ko *game.Point, de
 			if ko != nil && pt.Row == ko.Row && pt.Col == ko.Col {
 				continue
 			}
+			// Skip killer move (already tried)
+			if killer, ok := e.killerMoves[depth]; ok && killer != nil && pt.Row == killer.Row && pt.Col == killer.Col {
+				continue
+			}
 			var nextBoard game.Board
 			copy(nextBoard[:], board[:])
 			nextBoard[pt.Row][pt.Col] = player
@@ -100,17 +144,20 @@ func alphaBeta(board game.Board, player, opp game.FieldState, ko *game.Point, de
 				continue
 			}
 			foundMove = true
-			score := -alphaBeta(nextBoard, opp, player, ko, depth-1, -beta, -alpha)
+			score := -e.alphaBeta(nextBoard, opp, player, ko, depth-1, -beta, -alpha)
 			if score > alpha {
 				alpha = score
-			}
-			if alpha >= beta {
-				return alpha
+				// Update killer move if this move caused a beta cutoff
+				if alpha >= beta {
+					move := pt
+					e.killerMoves[depth] = &move
+					return alpha
+				}
 			}
 		}
 	}
 	// Consider passing if no move found or passing is better
-	passScore := -alphaBeta(board, opp, player, ko, depth-1, -beta, -alpha)
+	passScore := -e.alphaBeta(board, opp, player, ko, depth-1, -beta, -alpha)
 	if !foundMove || passScore > alpha {
 		alpha = passScore
 	}

main.go

@@ -363,7 +363,7 @@ func main() {
 	keybindings = cfg.Keybindings
 
 	// selectedEngine = &engine.RandomEngine{}
-	selectedEngine = &engine.AlphaBetaEngine{}
+	selectedEngine = engine.NewAlphaBetaEngine()
 	engineEnabled = true // Enable engine by default
 
 	defer g.Close()