voroskoi/pistike - Change RNEXG5IFDKMHSUR6RMNTI3Y32ORLVMZ6UJYKHLV2XBMT2QONBTVQC

Move search functions to search.zig

Created by voroskoi on January 22, 2023

RNEXG5IFDKMHSUR6RMNTI3Y32ORLVMZ6UJYKHLV2XBMT2QONBTVQC

Dependencies

In channels

main

Change contents

File addition: search.zig (----------)

[4.15]

const std = @import("std");
const Str = []const u8;
const Chess = @import("Chess.zig");
const BoardType = @import("Board.zig").BoardType;
const BitMove = @import("Board.zig").BitMove;
const BitMoveType = @import("Board.zig").BitMoveType;
const GameState = @import("Board.zig").GameState;
const MoveList = @import("Board.zig").MoveList;
const SquareType = @import("Board.zig").SquareType;
const eval = @import("eval.zig");
const nnue = @import("nnue.zig");
var buf: [16]u8 = undefined;
fn searchPosition(gs: *GameState, depth: usize) Str {
    const ALPHA = -5000;
    const BETA = 5000;
    const score = negamax(gs, ALPHA, BETA, depth) catch unreachable;
    std.debug.print("info score cp {d} depth {d}\n", .{ score, depth });
    if (@bitCast(BitMoveType, gs.best_move) != 0) {
        return std.fmt.bufPrint(&buf, "bestmove {s}{s}{s}\n", .{
            @tagName(gs.best_move.source),
            @tagName(gs.best_move.target),
            if (gs.best_move.prom != .none) @tagName(gs.best_move.prom) else "",
        }) catch unreachable;
    } else return "";
}
test "searchPosition" {
    var gs = try GameState.init(null);
    gs.show();
    std.debug.print("{s}", .{searchPosition(&gs, 4)});
}
fn negamax(gs: *GameState, alpha_orig: isize, beta: isize, depth: usize) !isize {
    if (depth == 0) return try quiescenceSearch(gs, alpha_orig, beta);
    var alpha = alpha_orig;
    // TODO
    // nodes += 1;
    const king = switch (gs.side) {
        .white => @intCast(SquareType, @ctz(@bitCast(BoardType, gs.bitboards[@enumToInt(Chess.PE.K)]))),
        .black => @intCast(SquareType, @ctz(@bitCast(BoardType, gs.bitboards[@enumToInt(Chess.PE.k)]))),
    };
    var in_check = gs.isSquareAttacked(king, gs.side.enemy());
    var legal_moves: usize = 0;
    var best_sofar: BitMove = @bitCast(BitMove, @as(BitMoveType, 0));
    var ml = try MoveList.init(0);
    try gs.generateMoves(&ml);
    for (ml.slice()) |move, idx| {
        var bck: GameState = undefined;
        gs.backup(&bck);
        gs.ply += 1;
        if (!gs.makeMove(move, .all)) {
            gs.ply -= 1;
            gs.restore(&bck);
            continue;
        }
        legal_moves += 1;
        const score = -try negamax(gs, -beta, -alpha, depth - 1);
        gs.ply -= 1;
        gs.restore(&bck);
        // fail-hard beta cutoff
        if (score >= beta) {
            // node (move) fails high
            return beta;
        }
        // found a better move
        if (score > alpha) {
            // PV (principal validation) node
            alpha = score;
            // if root move
            if (gs.ply == 0) {
                best_sofar = ml.get(idx);
            }
        }
    }
    // Detect check- and stalemate
    if (legal_moves == 0) {
        if (in_check) {
            // Adding ply helps the engine finding fastest mates.
            return eval.CHECKMATE_SCORE + @intCast(isize, gs.ply);
        } else {
            return eval.STALEMATE_SCORE;
        }
    }
    if (alpha_orig != alpha) {
        // init best move
        gs.best_move = best_sofar;
    }
    // node (move) fails low
    return alpha;
}
// quiescenceSearch helps the engine not thow away its pieces because of
// a temporary seemingly good move. (Horizon effect)
fn quiescenceSearch(gs: *GameState, alpha_orig: isize, beta: isize) !isize {
    var alpha = alpha_orig;
    const evaluation = eval.evaluate(gs);
    // fail-hard beta cutoff
    if (evaluation >= beta) {
        // node (move) fails high
        return beta;
    }
    // found a better move
    if (evaluation > alpha) {
        // PV (principal validation) node
        alpha = evaluation;
    }
    var ml = try MoveList.init(0);
    try gs.generateMoves(&ml);
    for (ml.slice()) |move| {
        var bck: GameState = undefined;
        gs.backup(&bck);
        gs.ply += 1;
        if (!gs.makeMove(move, .captures)) {
            gs.ply -= 1;
            gs.restore(&bck);
            continue;
        }
        const score = -try quiescenceSearch(gs, -beta, -alpha);
        gs.ply -= 1;
        gs.restore(&bck);
        // fail-hard beta cutoff
        if (score >= beta) {
            // node (move) fails high
            return beta;
        }
        // found a better move
        if (score > alpha) {
            // PV (principal validation) node
            alpha = score;
        }
    }
    // node (move) fails low
    return alpha;
}

Insertion in src/main.zig at line 52 [4.50]
[5.167]
[3.3413]
```
    _ = @import("eval.zig");
```
Insertion in src/main.zig at line 54 [4.50]
[3.3442]
[4.3467]
```
    _ = @import("search.zig");
```
Deletion in src/Board.zig at line 7 [6.16071]
B:BD[6.16210] → [7.2866:2900]
B:BD[7.2900] → [3.5820:5854]
```
const eval = @import("eval.zig");
const nnue = @import("nnue.zig");
```
Deletion in src/Board.zig at line 196 [6.16071]
B:BD[8.57] → [8.57:90]
∅:D[8.90] → [6.20470:20471]
B:BD[6.20470] → [6.20470:20471]
```
    var buf: [16]u8 = undefined;
```

Deletion in src/Board.zig at line 270 [6.16071]

B:BD[6.23053] → [9.135:141]

B:BD[9.141] → [8.91:207]

B:BD[8.207] → [2.184:258]

∅:D[2.258] → [10.982:983]

∅:D[8.271] → [10.982:983]

B:BD[9.141] → [10.982:983]

B:BD[10.983] → [2.259:711]

    }
    fn searchPosition(self: *@This(), depth: usize) Str {
        const ALPHA = -5000;
        const BETA = 5000;
        const score = self.negamax(ALPHA, BETA, depth) catch unreachable;
        std.debug.print("info score cp {d} depth {d}\n", .{ score, depth });
        if (@bitCast(BitMoveType, self.best_move) != 0) {
            return std.fmt.bufPrint(&buf, "bestmove {s}{s}{s}\n", .{
                @tagName(self.best_move.source),
                @tagName(self.best_move.target),
                if (self.best_move.prom != .none) @tagName(self.best_move.prom) else "",
            }) catch unreachable;
        } else return "";

Deletion in src/Board.zig at line 271 [6.16071]

B:BD[8.548] → [8.548:549]

B:BD[8.549] → [11.0:162]

∅:D[11.162] → [8.688:721]

B:BD[8.688] → [8.688:721]

B:BD[8.751] → [8.751:792]

B:BD[8.792] → [2.712:1096]

∅:D[2.1096] → [8.837:838]

B:BD[8.837] → [8.837:838]

B:BD[8.838] → [2.1097:1172]

∅:D[2.1172] → [8.838:1210]

B:BD[8.838] → [8.838:1210]

B:BD[8.1210] → [2.1173:1204]

∅:D[2.1204] → [8.1210:1782]

B:BD[8.1210] → [8.1210:1782]

B:BD[8.1782] → [2.1205:1229]


    fn negamax(self: *@This(), alpha_orig: isize, beta: isize, depth: usize) !isize {
        if (depth == 0) return try self.quiescenceSearch(alpha_orig, beta);
        var alpha = alpha_orig;
        // TODO
        // nodes += 1;
        const king = switch (self.side) {
            .white => @intCast(SquareType, @ctz(@bitCast(BoardType, self.bitboards[@enumToInt(Chess.PE.K)]))),
            .black => @intCast(SquareType, @ctz(@bitCast(BoardType, self.bitboards[@enumToInt(Chess.PE.k)]))),
        };
        var in_check = self.isSquareAttacked(king, self.side.enemy());
        var legal_moves: usize = 0;
        var best_sofar: BitMove = @bitCast(BitMove, @as(BitMoveType, 0));
        var ml = try MoveList.init(0);
        try self.generateMoves(&ml);
        for (ml.slice()) |move, idx| {
            var bck: GameState = undefined;
            self.backup(&bck);
            self.ply += 1;
            if (!self.makeMove(move, .all)) {
                self.ply -= 1;
                self.restore(&bck);
                continue;
            }
            legal_moves += 1;
            const score = -try self.negamax(-beta, -alpha, depth - 1);
            self.ply -= 1;
            self.restore(&bck);
            // fail-hard beta cutoff
            if (score >= beta) {
                // node (move) fails high
                return beta;
            }
            // found a better move
            if (score > alpha) {
                // PV (principal validation) node
                alpha = score;
                // if root move
                if (self.ply == 0) {
                    best_sofar = ml.get(idx);
                }
            }
        }

Deletion in src/Board.zig at line 272 [6.16071]

B:BD[2.1230] → [2.1230:1538]

∅:D[2.1538] → [8.1782:1913]

B:BD[8.1782] → [8.1782:1913]

B:BD[8.1913] → [11.163:467]

B:BD[11.467] → [3.5855:5903]

∅:D[3.5903] → [11.511:1629]

B:BD[11.511] → [11.511:1629]

∅:D[11.1629] → [8.1913:1985]

B:BD[8.1913] → [8.1913:1985]

B:BD[7.4150] → [7.4150:4151]

        // Detect check- and stalemate
        if (legal_moves == 0) {
            if (in_check) {
                // Adding ply helps the engine finding fastest mates.
                return eval.CHECKMATE_SCORE + @intCast(isize, self.ply);
            } else {
                return eval.STALEMATE_SCORE;
            }
        }
        if (alpha_orig != alpha) {
            // init best move
            self.best_move = best_sofar;
        }
        // node (move) fails low
        return alpha;
    }
    // quiescenceSearch helps the engine not thow away its pieces because of
    // a temporary seemingly good move.
    fn quiescenceSearch(self: *@This(), alpha_orig: isize, beta: isize) !isize {
        var alpha = alpha_orig;
        const evaluation = nnue.evaluate(self);
        // fail-hard beta cutoff
        if (evaluation >= beta) {
            // node (move) fails high
            return beta;
        }
        // found a better move
        if (evaluation > alpha) {
            // PV (principal validation) node
            alpha = evaluation;
        }
        var ml = try MoveList.init(0);
        try self.generateMoves(&ml);
        for (ml.slice()) |move| {
            var bck: GameState = undefined;
            self.backup(&bck);
            self.ply += 1;
            if (!self.makeMove(move, .captures)) {
                self.ply -= 1;
                self.restore(&bck);
                continue;
            }
            const score = -try self.quiescenceSearch(-beta, -alpha);
            self.ply -= 1;
            self.restore(&bck);
            // fail-hard beta cutoff
            if (score >= beta) {
                // node (move) fails high
                return beta;
            }
            // found a better move
            if (score > alpha) {
                // PV (principal validation) node
                alpha = score;
            }
        }
        // node (move) fails low
        return alpha;
    }

Deletion in src/Board.zig at line 1053 [6.16071]

B:BD[7.4301] → [7.4301:4302]

B:BD[8.2040] → [8.2040:2173]


test "searchPosition" {
    var gs = try GameState.init(null);
    gs.show();
    std.debug.print("{s}", .{gs.searchPosition(4)});
}

Move search functions to search.zig

Dependencies

In channels

Change contents

File addition: search.zig (----------)

Insertion in src/main.zig at line 52 [4.50]

Insertion in src/main.zig at line 54 [4.50]

Deletion in src/Board.zig at line 7 [6.16071]

Deletion in src/Board.zig at line 196 [6.16071]

Deletion in src/Board.zig at line 270 [6.16071]

Deletion in src/Board.zig at line 271 [6.16071]

Deletion in src/Board.zig at line 272 [6.16071]

Deletion in src/Board.zig at line 1053 [6.16071]