Add more evaluation

Author: ArcticXWolf

.github/workflows/ci.yml

@@ -2,7 +2,7 @@ name: Go Build & Test
 on:
   push:
     branches:
-      - 'main'
+      - 'master'
   pull_request:
     branches:
       - '*'

README.md

@@ -29,10 +29,14 @@ implemented.
 
 * Written in golang
 * Basic UCI interface
+* Simple timemanagement
 * Simple evaluation function using
     * Gamephase detection of mid- and endgame
     * Piece value
     * Piece square tables
+    * Tempo evaluation
+    * Pair bonus
+    * Rook on (half-)open files bonus
 * Simple search algorithm using
     * Negamax with alpha-beta-pruning
     * Quiescence search
@@ -43,13 +47,9 @@ implemented.
 ## Features ideas
 
 * Evaluation improvements
-    * Tempo evaluation
-    * Pair bonus
-    * Rook on (half-)open files bonus
     * Pawnshield bonus
     * Blocked piece penalty
     * Passed pawn bonus
-* Simple timemanagement
 * Search improvements
     * Killer move heuristics
     * Multiprocessing (Lazy SMP?)

evaluation/evaluation.go

@@ -12,6 +12,12 @@ type EvaluationPart struct {
 	PieceScore              int
 	PieceSquareScoreMidgame int
 	PieceSquareScoreEndgame int
+	PairModifier            int
+	TempoModifier           int
+	RookFileModifier        int
+	BlockedPiecesModifier   int
+	KingShieldModifier      int
+	PassedPawnModifier      int
 }
 
 type Evaluation struct {
@@ -23,6 +29,26 @@ type Evaluation struct {
 	TotalScorePerspective int
 }
 
+func (e *Evaluation) CalculateEvaluation(g *game.Game) int {
+	e.Game = g
+	e.GameOver = e.Game.Result != game.GameNotOver
+
+	e.White = EvaluationPart{}
+	e.Black = EvaluationPart{}
+
+	if !e.GameOver {
+		e.White = calculateEvaluationPart(g, game.White)
+		e.Black = calculateEvaluationPart(g, game.Black)
+	}
+
+	e.updateTotal()
+	return e.TotalScorePerspective
+}
+
+func (e *Evaluation) GetPieceTypeValue(pieceType dragontoothmg.Piece) int {
+	return weights[game.White].Midgame.Material[pieceType]
+}
+
 func (e *Evaluation) updateTotal() {
 	if e.GameOver {
 		if e.Game.Result == game.WhiteWon {
@@ -48,35 +74,35 @@ func (e *Evaluation) updateTotal() {
 	e.TotalScore += (gamePhase*e.White.PieceSquareScoreMidgame + (24-gamePhase)*e.White.PieceSquareScoreEndgame) / 24
 	e.TotalScore -= (gamePhase*e.Black.PieceSquareScoreMidgame + (24-gamePhase)*e.Black.PieceSquareScoreEndgame) / 24
 
+	e.TotalScore += e.White.PairModifier
+	e.TotalScore -= e.Black.PairModifier
+	e.TotalScore += e.White.TempoModifier
+	e.TotalScore -= e.Black.TempoModifier
+	e.TotalScore += e.White.RookFileModifier
+	e.TotalScore -= e.Black.RookFileModifier
+	e.TotalScore += e.White.BlockedPiecesModifier
+	e.TotalScore -= e.Black.BlockedPiecesModifier
+	e.TotalScore += e.White.KingShieldModifier
+	e.TotalScore -= e.Black.KingShieldModifier
+	e.TotalScore += e.White.PassedPawnModifier
+	e.TotalScore -= e.Black.PassedPawnModifier
+
 	e.TotalScorePerspective = e.TotalScore
 	if !e.Game.Position.Wtomove {
 		e.TotalScorePerspective = -e.TotalScore
 	}
 }
 
-func (e *Evaluation) CalculateEvaluation(g *game.Game) int {
-	e.Game = g
-	e.GameOver = e.Game.Result != game.GameNotOver
-
-	e.White = EvaluationPart{}
-	e.Black = EvaluationPart{}
-
-	if !e.GameOver {
-		e.White = calculateEvaluationPart(g, game.White)
-		e.Black = calculateEvaluationPart(g, game.Black)
-	}
-
-	e.updateTotal()
-	return e.TotalScorePerspective
-}
-
 func calculateEvaluationPart(g *game.Game, color game.PlayerColor) EvaluationPart {
 	ps, pstMid, pstEnd := calculateMaterialScore(g, color)
 	evalPart := EvaluationPart{
 		GamePhase:               calculateGamephase(g, color),
 		PieceScore:              ps,
 		PieceSquareScoreMidgame: pstMid,
 		PieceSquareScoreEndgame: pstEnd,
+		PairModifier:            calculatePairModifier(g, color),
+		TempoModifier:           calculateTempoModifier(g, color),
+		RookFileModifier:        calculateRookModifier(g, color),
 	}
 	return evalPart
 }
@@ -143,6 +169,61 @@ func calculateMaterialScoreForPieceType(g *game.Game, color game.PlayerColor, pi
 	return ps, pstMid, pstEnd
 }
 
-func (e *Evaluation) GetPieceTypeValue(pieceType dragontoothmg.Piece) int {
-	return weights[game.White].Midgame.Material[pieceType]
+func calculatePairModifier(g *game.Game, color game.PlayerColor) (result int) {
+	bboards := g.Position.White
+	if color == game.Black {
+		bboards = g.Position.Black
+	}
+
+	if bits.OnesCount64(bboards.Bishops) >= 2 {
+		result += weights[color].AdditionalModifier.BishopPairModifier
+	}
+	if bits.OnesCount64(bboards.Knights) >= 2 {
+		result += weights[color].AdditionalModifier.KnightPairModifier
+	}
+	if bits.OnesCount64(bboards.Rooks) >= 2 {
+		result += weights[color].AdditionalModifier.RookPairModifier
+	}
+
+	return
+}
+
+func calculateTempoModifier(g *game.Game, color game.PlayerColor) (result int) {
+	if g.Position.Wtomove == bool(color) {
+		result += weights[color].AdditionalModifier.TempoModifier
+	}
+	return
+}
+
+func calculateRookModifier(g *game.Game, color game.PlayerColor) (result int) {
+	bboardsOwn := g.Position.White
+	bboardsOther := g.Position.Black
+	if color == game.Black {
+		bboardsOwn = g.Position.Black
+		bboardsOther = g.Position.White
+	}
+
+	pawnFillOwn := calculatePawnFileFill(bboardsOwn.Pawns)
+	pawnFillOther := calculatePawnFileFill(bboardsOther.Pawns)
+
+	openFiles := ^pawnFillOwn & ^pawnFillOther
+	halfOpenFiles := ^pawnFillOwn ^ openFiles
+
+	rooksOnOpenFiles := bits.OnesCount64(bboardsOwn.Rooks & openFiles)
+	rooksOnHalfOpenFiles := bits.OnesCount64(bboardsOwn.Rooks & halfOpenFiles)
+
+	return rooksOnOpenFiles*weights[color].AdditionalModifier.OpenRookModifier + rooksOnHalfOpenFiles*weights[color].AdditionalModifier.HalfRookModifier
+}
+
+func calculatePawnFileFill(pawnBitboard uint64) uint64 {
+	// Northfill
+	pawnBitboard |= (pawnBitboard << 8)
+	pawnBitboard |= (pawnBitboard << 16)
+	pawnBitboard |= (pawnBitboard << 32)
+	// Southfill
+	pawnBitboard |= (pawnBitboard >> 8)
+	pawnBitboard |= (pawnBitboard >> 16)
+	pawnBitboard |= (pawnBitboard >> 32)
+
+	return pawnBitboard
 }

evaluation/evaluation_test.go

@@ -205,7 +205,7 @@ func TestCalculateEvaluation(t *testing.T) {
 		{
 			"GameStart",
 			game_gamestart,
-			0,
+			10,
 		},
 	}
 	for _, tt := range tests {

evaluation/weights.go

@@ -5,17 +5,41 @@ import (
 	"go.janniklasrichter.de/axwchessbot/game"
 )
 
+type AdditionalModifier struct {
+	BishopPairModifier        int
+	KnightPairModifier        int
+	RookPairModifier          int
+	OpenRookModifier          int
+	HalfRookModifier          int
+	TempoModifier             int
+	KingShieldRank2Modifier   int
+	KingShieldRank3Modifier   int
+	RookBlockedByKingModifier int
+}
+
 type GamephaseWeights struct {
 	Material          map[dragontoothmg.Piece]int
 	PieceSquareTables map[dragontoothmg.Piece][64]int
 }
 
 type Weights struct {
-	Midgame GamephaseWeights
-	Endgame GamephaseWeights
+	Midgame            GamephaseWeights
+	Endgame            GamephaseWeights
+	AdditionalModifier AdditionalModifier
 }
 
 var (
+	additionalModifiers = AdditionalModifier{
+		BishopPairModifier:        30,
+		KnightPairModifier:        -8,
+		RookPairModifier:          -16,
+		OpenRookModifier:          10,
+		HalfRookModifier:          5,
+		TempoModifier:             10,
+		KingShieldRank2Modifier:   10,
+		KingShieldRank3Modifier:   5,
+		RookBlockedByKingModifier: 24,
+	}
 	weightsForAllPhases = GamephaseWeights{
 		Material: map[dragontoothmg.Piece]int{
 			dragontoothmg.Pawn:   100,
@@ -130,8 +154,9 @@ func flipPstArrayVertically(pst [64]int) [64]int {
 var (
 	weights = map[game.PlayerColor]Weights{
 		game.White: Weights{
-			Midgame: midgameWeights,
-			Endgame: endgameWeights,
+			Midgame:            midgameWeights,
+			Endgame:            endgameWeights,
+			AdditionalModifier: additionalModifiers,
 		},
 		game.Black: Weights{
 			Midgame: GamephaseWeights{
@@ -156,6 +181,7 @@ var (
 					dragontoothmg.King:   flipPstArrayVertically(endgameWeights.PieceSquareTables[dragontoothmg.King]),
 				},
 			},
+			AdditionalModifier: additionalModifiers,
 		},
 	}
 )

search/search.go

@@ -96,7 +96,10 @@ func (s *Search) alphaBeta(ctx context.Context, depthLeft, alpha, beta int, move
 	var cancelled bool = false
 
 	if depthLeft <= 0 || s.Game.Result != game.GameNotOver {
-		score := s.quiescenceSearch(alpha, beta, int(s.MaximumDepthQuiescence)-1)
+		// add leaf to nodecount, but do not count it in qnodecount (prevent overlap in both counts)
+		s.SearchInfo.NodesTraversed++
+		s.SearchInfo.QNodesTraversed--
+		score := s.quiescenceSearch(alpha, beta, int(s.MaximumDepthQuiescence))
 		if s.Game.Result == game.BlackWon || s.Game.Result == game.WhiteWon {
 			if score > 0 {
 				score -= int(s.MaximumDepthAlphaBeta) - depthLeft // game won, minimize path to victory
@@ -189,7 +192,6 @@ moveIterator:
 }
 
 func (s *Search) quiescenceSearch(alpha, beta, depthLeft int) int {
-	s.SearchInfo.NodesTraversed++
 	s.SearchInfo.QNodesTraversed++
 
 	standPat := s.evaluationProvider.CalculateEvaluation(s.Game)
@@ -200,7 +202,7 @@ func (s *Search) quiescenceSearch(alpha, beta, depthLeft int) int {
 		alpha = standPat
 	}
 
-	if depthLeft <= 0 || s.Game.Result != game.GameNotOver {
+	if depthLeft > 0 && s.Game.Result == game.GameNotOver {
 		for _, move := range s.getCapturesInOrder() {
 			s.Game.PushMove(move)
 			score := -s.quiescenceSearch(-beta, -alpha, depthLeft-1)
@@ -243,29 +245,31 @@ func (s *Search) getCapturesInOrder() []dragontoothmg.Move {
 	legalMoves := s.Game.Position.GenerateLegalMoves()
 	var captures []dragontoothmg.Move = make([]dragontoothmg.Move, 0, len(legalMoves))
 
-	bitboards := s.Game.Position.White
+	bitboardsOwn := s.Game.Position.White
+	bitboardsOpponent := s.Game.Position.Black
 	if !s.Game.Position.Wtomove {
-		bitboards = s.Game.Position.Black
+		bitboardsOwn = s.Game.Position.Black
+		bitboardsOpponent = s.Game.Position.White
 	}
 
 	for _, move := range legalMoves {
-		if bitboards.All&(1<<move.To()) > 0 {
+		if bitboardsOpponent.All&(1<<move.To()) > 0 {
 			captures = append(captures, move)
 		}
 	}
 
 	sort.Slice(captures, func(i, j int) bool {
-		return s.getCaptureMVVLVA(captures[i], bitboards) < s.getCaptureMVVLVA(captures[j], bitboards)
+		return s.getCaptureMVVLVA(captures[i], bitboardsOwn, bitboardsOpponent) < s.getCaptureMVVLVA(captures[j], bitboardsOwn, bitboardsOpponent)
 	})
 
 	return captures
 }
 
-func (s *Search) getCaptureMVVLVA(move dragontoothmg.Move, bitboards dragontoothmg.Bitboards) (score int) {
-	pieceTypeFrom, _ := s.getPieceTypeAtPosition(move.From(), bitboards)
-	pieceTypeTo, _ := s.getPieceTypeAtPosition(move.To(), bitboards)
+func (s *Search) getCaptureMVVLVA(move dragontoothmg.Move, bitboardsOwn dragontoothmg.Bitboards, bitboardsOpponent dragontoothmg.Bitboards) (score int) {
+	pieceTypeFrom, _ := s.getPieceTypeAtPosition(move.From(), bitboardsOwn)
+	pieceTypeTo, _ := s.getPieceTypeAtPosition(move.To(), bitboardsOpponent)
 
-	return s.evaluationProvider.GetPieceTypeValue(pieceTypeTo) + (10 - int(pieceTypeFrom))
+	return (1200 - s.evaluationProvider.GetPieceTypeValue(pieceTypeTo)) + int(pieceTypeFrom)
 }
 
 func (s *Search) getPieceTypeAtPosition(position uint8, bitboards dragontoothmg.Bitboards) (pieceType dragontoothmg.Piece, occupied bool) {

search/search_test.go

@@ -25,7 +25,7 @@ func benchmarkSearchEvaluation(evaluator evaluation_provider.EvaluationProvider,
 
 	for n := 0; n < b.N; n++ {
 		start = time.Now()
-		searchObj := New(game.New(), logger, transpositionTable, evaluator, abdepth, 4)
+		searchObj := New(game.New(), logger, transpositionTable, evaluator, abdepth, 1)
 		searchObj.SearchBestMove(ctx)
 		nps += float64(searchObj.SearchInfo.NodesTraversed) / float64(time.Since(start).Seconds())
 	}
@@ -137,3 +137,34 @@ func TestProblematicGames(t *testing.T) {
 		})
 	}
 }
+
+func TestSearch_getCapturesInOrder(t *testing.T) {
+	type fields struct {
+		Game *game.Game
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   []dragontoothmg.Move
+	}{
+		{"No Captures in Starting Position", fields{game.New()}, []dragontoothmg.Move{}},
+		{"One Capture in Scandinavian Defense", fields{game.NewFromFen("rnbqkbnr/ppp1pppp/8/3p4/4P3/8/PPPP1PPP/RNBQKBNR w KQkq - 0 2")}, []dragontoothmg.Move{1827}},
+		{"Multiple Captures on Enemy Queen", fields{game.NewFromFen("rn2kb1r/ppp1pppp/8/2bpq2n/3P4/5NQ1/PPP1PPPP/RNB1KB1R w KQkq - 0 1")}, []dragontoothmg.Move{1764, 1380, 1444, 1762, 1462}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			logger := log.New(os.Stdout, "", log.LstdFlags)
+			evaluator := evaluation.Evaluation{}
+			transpositionTable := NewTranspositionTable(1000000)
+			s := &Search{
+				Game:               tt.fields.Game,
+				logger:             logger,
+				evaluationProvider: &evaluator,
+				transpositionTable: transpositionTable,
+			}
+			if got := s.getCapturesInOrder(); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("Search.getCapturesInOrder() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}