Tweak bernstein evaluation and opening

Author: herohde

cmd/bernstein/bernstein/book.go

@@ -0,0 +1,10 @@
+package bernstein
+
+import "github.com/herohde/morlock/pkg/engine"
+
+var opening = engine.Line([]string{"e2e4"})
+
+func NewBook() engine.Book {
+	ret, _ := engine.NewBook([]engine.Line{opening})
+	return ret
+}

cmd/bernstein/bernstein/eval.go

@@ -109,10 +109,16 @@ func Control(pos *board.Position, side board.Color) int {
 }
 
 // KingDefense returns the number of squares around the king defended by the given side, but
-// with no opponent attackers. Populated squares included.
+// with no opponent attackers. Populated squares included. If empty, ignore the King.
 func KingDefense(pos *board.Position, side board.Color) int {
 	ret := 0
 	for _, sq := range board.KingAttackboard(pos.KingSquare(side)).ToSquares() {
+		if pos.IsEmpty(sq) {
+			if pos.IsDefendedBy(side, sq, board.QueenRookKnightBishopPawn) && !pos.IsAttacked(side, sq) {
+				ret++
+			}
+			continue
+		}
 		if pos.IsDefended(side, sq) && !pos.IsAttacked(side, sq) {
 			ret++
 		}

cmd/bernstein/bernstein/eval_test.go

@@ -17,11 +17,12 @@ func TestEval(t *testing.T) {
 		material int
 	}{
 		{fen.Initial, 20, 22, 5, 39},
-		{"k7/8/8/8/8/8/8/K7 w - - 0 1", 3, 3, 3, 0},                                 // K
-		{"k7/7R/8/8/8/8/8/K7 w - - 0 1", 3 + 7 + 7, 3 + 7 + 5 /* -2 for k */, 3, 5}, // K+R
-		{"k7/7R/8/8/8/8/8/K7 b - - 0 1", 1 /* -2 due to R */, 1, 1, 0},              // K with limited mobility
-		{"k7/p6R/8/8/8/8/8/K7 b - - 0 1", 1 + 2, 1 + 1, 1, 1},                       // K+P
-		{"k7/1p5R/8/8/8/8/8/K7 b - - 0 1", 2 + 2, 2 + 2, 2, 1},                      // K+P w/ block
+		{"k7/8/8/8/8/8/8/K7 w - - 0 1", 3, 3, 0, 0},                                 // K
+		{"k7/7R/8/8/8/8/8/K7 w - - 0 1", 3 + 7 + 7, 3 + 7 + 5 /* -2 for k */, 0, 5}, // K+R
+		{"k7/7R/8/8/8/8/8/K7 b - - 0 1", 1 /* -2 due to R */, 1, 0, 0},              // K with limited mobility
+		{"k7/p6R/8/8/8/8/8/K7 b - - 0 1", 1 + 2, 1 + 1, 0, 1},                       // K+P
+		{"k7/1p5R/8/8/8/8/8/K7 b - - 0 1", 2 + 2, 2 + 2, 0, 1},                      // K+P w/ block
+		{"k7/pp5R/8/8/8/8/8/K7 b - - 0 1", 2 + 2 + 1, 2 + 2 + 1, 1, 2},              // K+2P
 		{"k7/7R/1R6/8/8/8/8/K7 b - - 0 1", 0, 0, 0, 0},                              // stalemate
 	}
 

cmd/bernstein/bernstein/search.go

@@ -238,13 +238,13 @@ func Table1(move board.Move) board.MovePriority {
 		case board.FileB:
 			return 3
 		case board.FileC:
-			return 5
+			return 6 // favor C over F
 		case board.FileD:
 			return 7
 		case board.FileE:
 			return 8
 		case board.FileF:
-			return 6
+			return 5
 		case board.FileG:
 			return 4
 		case board.FileH:

cmd/bernstein/bernstein/search_test.go

@@ -21,6 +21,7 @@ func TestFindPlausibleMoves(t *testing.T) {
 		// 2023 game2
 		{"rnbqk1nr/ppp2ppp/3p4/2b1p3/1PP1P3/P4N2/3P1PPP/RNBQKB1R b KQkq - 0 5", 7, "Bc5-d4 Bc5-b6 Bc8-g4 Ng8-h6 Ng8-f6 Bc8-e6 Nb8-c6"}, // move 5: search did not pick B
 		{"rn1q1rk1/ppp2ppp/3p1n2/8/1PP1p1b1/PQ3N2/4BPPP/RNB2RK1 b - - 1 12", 7, "e4*f3 Bg4*f3 Nb8-c6 Nb8-a6 Nb8-d7 c7-c5 d6-d5"},       // move 12: no capture
+		{"rnbqkbnr/pppp1ppp/8/4p3/8/2N5/PPPPPPPP/R1BQKBNR w KQkq e6 0 2", 7, "Ng1-f3 Ng1-h3 e2-e4 e2-e3 d2-d4 d2-d3 f2-f3"},            // quirk that 4ply search picks "f3"
 	}
 
 	for _, tt := range tests {

cmd/bernstein/main.go

@@ -12,6 +12,7 @@ import (
 	"github.com/herohde/morlock/pkg/search"
 	"github.com/seekerror/logw"
 	"os"
+	"time"
 )
 
 var (
@@ -55,7 +56,7 @@ func main() {
 	in := engine.ReadStdinLines(ctx)
 	switch <-in {
 	case uci.ProtocolName:
-		driver, out := uci.NewDriver(ctx, e, in)
+		driver, out := uci.NewDriver(ctx, e, in, uci.UseBook(bernstein.NewBook(), time.Now().UnixNano()))
 		go engine.WriteStdoutLines(ctx, out)
 
 		<-driver.Closed()

pkg/board/piece.go

@@ -19,6 +19,7 @@ const (
 )
 
 var (
+	AllPieces                 = []Piece{King, Queen, Rook, Knight, Bishop, Pawn}
 	KingQueen                 = []Piece{King, Queen}
 	KingQueenRookKnightBishop = []Piece{King, Queen, Rook, Knight, Bishop}
 	QueenRookBishop           = []Piece{Queen, Rook, Bishop}

pkg/board/position.go

@@ -167,16 +167,32 @@ func (p *Position) IsDefended(c Color, sq Square) bool {
 	return p.IsAttacked(c.Opponent(), sq)
 }
 
+// IsDefendedBy returns true iff the square is defended by pieces of the color.
+func (p *Position) IsDefendedBy(c Color, sq Square, list []Piece) bool {
+	return p.IsAttackedBy(c.Opponent(), sq, list)
+}
+
 // IsAttacked returns true iff the square is attacked by the opposing color. Does not include en passant.
 func (p *Position) IsAttacked(c Color, sq Square) bool {
+	return p.IsAttackedBy(c, sq, AllPieces)
+}
+
+// IsAttackedBy returns true iff the square is attacked by the given pieces of the opposing color. Does not include en passant.
+func (p *Position) IsAttackedBy(c Color, sq Square, list []Piece) bool {
 	opp := c.Opponent()
 
-	for _, piece := range KingQueenRookKnightBishop {
+	for _, piece := range list {
+		if piece == Pawn {
+			if PawnCaptureboard(opp, p.pieces[opp][Pawn])&BitMask(sq) != 0 {
+				return true
+			}
+			continue
+		}
 		if pieces := p.pieces[opp][piece]; pieces != 0 && Attackboard(p.rotated, sq, piece)&pieces != 0 {
 			return true
 		}
 	}
-	return PawnCaptureboard(opp, p.pieces[opp][Pawn])&BitMask(sq) != 0
+	return false
 }
 
 // IsChecked returns true iff the color is in check. Convenient for IsAttacked(King).

pkg/engine/engine.go

@@ -14,7 +14,7 @@ import (
 	"sync"
 )
 
-var version = build.NewVersion(0, 91, 0)
+var version = build.NewVersion(0, 91, 1)
 
 // Options are search creation options.
 type Options struct {