voroskoi/pistike - Change FOORIA7SEZCLKDBNMV6KEDTQOJJVAH57BQFBRSQMET6FERJPHCVQC

Add perft tests, fix errors. Works, but slow as hell

Created by voroskoi on January 8, 2023

FOORIA7SEZCLKDBNMV6KEDTQOJJVAH57BQFBRSQMET6FERJPHCVQC

Dependencies

In channels

main

Change contents

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

[3.15]

const std = @import("std");
const Board = @import("Board.zig");
pub const Perft = struct {
    nodes: usize = 0,
    gs: Board.GameState,
    pub fn perftDriver(self: *@This(), depth: usize) void {
        if (depth == 0) {
            // count nodes
            self.nodes += 1;
            return;
        }
        var ml = Board.MoveList.init(0) catch unreachable;
        self.gs.generateMoves(&ml) catch unreachable;
        for (ml.slice()) |move| {
            const bk = self.gs.backup();
            if (!self.gs.makeMove(move, .all)) {
                continue;
            }
            self.perftDriver(depth - 1);
            self.gs.restore(bk);
        }
    }
    fn perftTest(self: *@This(), depth: usize) void {
        var ml = Board.MoveList.init(0) catch unreachable;
        self.gs.generateMoves(&ml) catch unreachable;
        for (ml.slice()) |move| {
            const bk = self.gs.backup();
            if (!self.gs.makeMove(move, .all)) {
                std.debug.print("ILLEGAL MOVE\n", .{});
                continue;
            }
            const cummulative_nodes = self.nodes;
            self.perftDriver(depth - 1);
            const old_nodes = self.nodes - cummulative_nodes;
            self.gs.restore(bk);
            move.show();
            std.debug.print("nodes: {d}\n", .{old_nodes});
        }
    }
};
test "Perft" {
    var gs = Board.GameState.init("8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - -") catch unreachable;
    var p = Perft{ .gs = gs };
    p.perftDriver(2);
    try std.testing.expectEqual(@as(usize, 191), p.nodes);
}

Insertion in src/main.zig at line 4 [3.50]

[4.37]

[3.79]

const Board = @import("Board.zig");
const Perft = @import("perft.zig").Perft;

Replacement in src/main.zig at line 9 [3.50]

B:BD[3.102] → [4.38:91]

∅:D[4.91] → [3.149:171]

B:BD[3.149] → [3.149:171]

    var bit_board: Chess.BitBoard = .{ .board = 0 };
    bit_board.show();

[3.102]

[3.171]

    var gs = try Board.GameState.init("8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - -");
    var p = Perft{ .gs = gs };
    var timer = try std.time.Timer.start();
    p.perftDriver(4);
    std.debug.print("Nodes: {d} time: {d}\n", .{ p.nodes, timer.read() / std.time.ns_per_ms });

Insertion in src/Chess.zig at line 8 [4.7502]

[4.7628]


    pub fn enemy(self: @This()) Colors {
        switch (self) {
            .white => return .black,
            .black => return .white,
        }
    }

Replacement in src/Board.zig at line 120 [6.16071]

B:BD[5.541] → [5.541:1066]

    fn show(self: @This()) void {
        std.debug.print("\nsource: {any}\n", .{self.source});
        std.debug.print("target: {any}\n", .{self.target});
        std.debug.print("piece: {any}\n", .{self.piece});
        std.debug.print("promote: {any}\n", .{self.prom});
        std.debug.print("capture: {any}\n", .{self.capture});
        std.debug.print("double: {any}\n", .{self.double});
        std.debug.print("enpassant: {any}\n", .{self.enpassant});
        std.debug.print("castling: {any}\n", .{self.castling});

[5.541]

[5.1066]

    pub fn show(self: @This()) void {
        // std.debug.print("source: {any}\n", .{self.source});
        // std.debug.print("target: {any}\n", .{self.target});
        // std.debug.print("piece: {any}\n", .{self.piece});
        // std.debug.print("promote: {any}\n", .{self.prom});
        // std.debug.print("capture: {any}\n", .{self.capture});
        // std.debug.print("double: {any}\n", .{self.double});
        // std.debug.print("enpassant: {any}\n", .{self.enpassant});
        // std.debug.print("castling: {any}\n", .{self.castling});
        std.debug.print("{s} {s}{s}\t", .{
            @tagName(self.piece),
            @tagName(self.source),
            @tagName(self.target),
        });

Insertion in src/Board.zig at line 174 [6.16071]
[6.19872]
[6.19872]
```
pub const MoveList = std.BoundedArray(BitMove, 64);
```
Deletion in src/Board.zig at line 195 [6.16071]
B:BD[6.20275] → [6.20275:20309]
```
    enemy: Chess.Colors = .black,
```

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

B:BD[6.20370] → [6.20370:20470]

    moves: std.BoundedArray(BitMove, 64) = std.BoundedArray(BitMove, 64).init(0) catch unreachable,

Deletion in src/Board.zig at line 206 [6.16071]
B:BD[6.20656] → [6.20656:20704]
```
        self.moves.resize(0) catch unreachable;
```
Replacement in src/Board.zig at line 217 [6.16071]
B:BD[6.20994] → [6.20994:21033]
```
    fn backup(self: @This()) @This() {
```
[6.20994]
[6.21033]
```
    pub fn backup(self: @This()) @This() {
```

Replacement in src/Board.zig at line 233 [6.16071]

B:BD[6.21413] → [6.21413:21465]

    fn restore(self: *@This(), bck: @This()) void {

[6.21413]

[6.21465]

    pub fn restore(self: *@This(), bck: @This()) void {

Replacement in src/Board.zig at line 250 [6.16071]
B:BD[6.21941] → [6.21941:21975]
```
    fn show(self: @This()) void {
```
[6.21941]
[6.21975]
```
    pub fn show(self: @This()) void {
```

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

B:BD[6.23053] → [6.23053:23130]

        std.debug.print("Possible moves counter: {d}\n", .{self.moves.len});

Deletion in src/Board.zig at line 342 [6.16071]
B:BD[6.25977] → [6.25977:26014]
```
                self.enemy = .black;
```
Deletion in src/Board.zig at line 345 [6.16071]
B:BD[6.26086] → [6.26086:26123]
```
                self.enemy = .white;
```

Replacement in src/Board.zig at line 442 [6.16071]

B:BD[6.29641] → [6.29641:29686]

    fn generateMoves(self: *@This()) !void {

[6.29641]

[6.29686]

    pub fn generateMoves(self: *@This(), ml: *MoveList) !void {

Replacement in src/Board.zig at line 453 [6.16071]

B:BD[6.30051] → [6.30051:30111]

                .P, .p => try self.pawnMoves(board, piece),

[6.30051]

[6.30111]

                .P, .p => try self.pawnMoves(ml, board, piece),

Replacement in src/Board.zig at line 455 [6.16071]

B:BD[6.30139] → [6.30139:30243]

                    try self.castlingMoves(piece);
                    try self.genMoves(board, piece);

[6.30139]

[6.30243]

                    try self.castlingMoves(ml, piece);
                    try self.genMoves(ml, board, piece);

Replacement in src/Board.zig at line 458 [6.16071]

B:BD[6.30262] → [6.30262:30498]

                .N, .n => try self.genMoves(board, piece),
                .B, .b => try self.genMoves(board, piece),
                .R, .r => try self.genMoves(board, piece),
                .Q, .q => try self.genMoves(board, piece),

[6.30262]

[6.30498]

                .N, .n => try self.genMoves(ml, board, piece),
                .B, .b => try self.genMoves(ml, board, piece),
                .R, .r => try self.genMoves(ml, board, piece),
                .Q, .q => try self.genMoves(ml, board, piece),

Replacement in src/Board.zig at line 467 [6.16071]

B:BD[6.30567] → [6.30567:30646]

    fn pawnMoves(self: *@This(), board_in: BoardType, piece: Chess.PE) !void {

[6.30567]

[6.30646]

    fn pawnMoves(self: *@This(), ml: *MoveList, board_in: BoardType, piece: Chess.PE) !void {

Replacement in src/Board.zig at line 509 [6.16071]

B:BD[6.32523] → [6.32523:32578]

                        try self.moves.append(BitMove{

[6.32523]

[6.32578]

                        try ml.append(BitMove{

Replacement in src/Board.zig at line 517 [6.16071]

B:BD[6.32885] → [6.32885:32936]

                    try self.moves.append(BitMove{

[6.32885]

[6.32936]

                    try ml.append(BitMove{

Replacement in src/Board.zig at line 529 [6.16071]

B:BD[6.33477] → [6.33477:33532]

                        try self.moves.append(BitMove{

[6.33477]

[6.33532]

                        try ml.append(BitMove{

Replacement in src/Board.zig at line 542 [6.16071]

B:BD[6.33985] → [7.826:905]

                @bitCast(BoardType, self.occupancies[@enumToInt(self.enemy)]);

[6.33985]

[6.34043]

                @bitCast(BoardType, self.occupancies[@enumToInt(self.side.enemy())]);

Replacement in src/Board.zig at line 548 [6.16071]

B:BD[6.34240] → [6.34240:34295]

                        try self.moves.append(BitMove{

[6.34240]

[6.34295]

                        try ml.append(BitMove{

Replacement in src/Board.zig at line 557 [6.16071]

B:BD[6.34647] → [6.34647:34698]

                    try self.moves.append(BitMove{

[6.34647]

[6.34698]

                    try ml.append(BitMove{

Replacement in src/Board.zig at line 576 [6.16071]

B:BD[6.35483] → [6.35483:35534]

                    try self.moves.append(BitMove{

[6.35483]

[6.35534]

                    try ml.append(BitMove{

Replacement in src/Board.zig at line 591 [6.16071]

B:BD[6.35926] → [6.35926:35988]

    fn castlingMoves(self: *@This(), piece: Chess.PE) !void {

[6.35926]

[6.35988]

    fn castlingMoves(self: *@This(), ml: *MoveList, piece: Chess.PE) !void {

Replacement in src/Board.zig at line 613 [6.16071]

B:BD[6.36870] → [6.36870:36959]

                        if (self.isSquareAttacked(square, self.enemy)) break :blk false;

[6.36870]

[6.36959]

                        if (self.isSquareAttacked(square, self.side.enemy())) break :blk false;

Replacement in src/Board.zig at line 620 [6.16071]

B:BD[6.37065] → [6.37065:37116]

                    try self.moves.append(BitMove{

[6.37065]

[6.37116]

                    try ml.append(BitMove{

Replacement in src/Board.zig at line 651 [6.16071]

B:BD[6.38221] → [6.38221:38310]

                        if (self.isSquareAttacked(square, self.enemy)) break :blk false;

[6.38221]

[6.38310]

                        if (self.isSquareAttacked(square, self.side.enemy())) break :blk false;

Replacement in src/Board.zig at line 658 [6.16071]

B:BD[6.38416] → [6.38416:38467]

                    try self.moves.append(BitMove{

[6.38416]

[6.38467]

                    try ml.append(BitMove{

Replacement in src/Board.zig at line 669 [6.16071]

B:BD[6.38682] → [6.38682:38760]

    fn genMoves(self: *@This(), board_in: BoardType, piece: Chess.PE) !void {

[6.38682]

[6.38760]

    fn genMoves(self: *@This(), ml: *MoveList, board_in: BoardType, piece: Chess.PE) !void {

Replacement in src/Board.zig at line 702 [6.16071]

B:BD[6.39983] → [7.986:1091]

∅:D[7.1091] → [6.40125:40176]

B:BD[6.40125] → [6.40125:40176]

                if (self.occupancies[@enumToInt(self.enemy)].isSet(@intToEnum(Square, target_square))) {
                    try self.moves.append(BitMove{

[6.39983]

[6.40176]

                if (self.occupancies[@enumToInt(self.side.enemy())].isSet(@intToEnum(Square, target_square))) {
                    try ml.append(BitMove{

Replacement in src/Board.zig at line 710 [6.16071]

B:BD[6.40444] → [6.40444:40495]

                    try self.moves.append(BitMove{

[6.40444]

[6.40495]

                    try ml.append(BitMove{

Replacement in src/Board.zig at line 724 [6.16071]

B:BD[5.2196] → [2.0:67]

    fn makeMove(self: *@This(), move: BitMove, flag: Moves) bool {

[5.2196]

[5.2263]

    pub fn makeMove(self: *@This(), move: BitMove, flag: Moves) bool {

Replacement in src/Board.zig at line 734 [6.16071]

B:BD[5.2569] → [7.1092:2043]

                // handle occupancy arrays
                {
                    // remove source target, one of them is no-op
                    self.occupancies[@enumToInt(Chess.Colors.white)].unSet(move.source);
                    self.occupancies[@enumToInt(Chess.Colors.black)].unSet(move.source);
                    // set target for the proper side
                    switch (self.side) {
                        .white => {
                            self.occupancies[@enumToInt(Chess.Colors.white)].set(move.target);
                            self.occupancies[@enumToInt(Chess.Colors.black)].unSet(move.target);
                        },
                        .black => {
                            self.occupancies[@enumToInt(Chess.Colors.black)].set(move.target);
                            self.occupancies[@enumToInt(Chess.Colors.white)].unSet(move.target);
                        },
                    }
                }

[5.2569]

[7.2043]

                // handle occupancy arrays TODO: perf test!
                // {
                //     // remove source target, one of them is no-op
                //     self.occupancies[@enumToInt(Chess.Colors.white)].unSet(move.source);
                //     self.occupancies[@enumToInt(Chess.Colors.black)].unSet(move.source);

Replacement in src/Board.zig at line 740 [6.16071]

∅:D[7.2044] → [5.2569:2652]

B:BD[5.2569] → [5.2569:2652]

                // TODO: reset enpassant
                // self.enpassant = null;

[7.2044]

[5.2652]

                //     // set target for the proper side
                //     switch (self.side) {
                //         .white => {
                //             self.occupancies[@enumToInt(Chess.Colors.white)].set(move.target);
                //             self.occupancies[@enumToInt(Chess.Colors.black)].unSet(move.target);
                //         },
                //         .black => {
                //             self.occupancies[@enumToInt(Chess.Colors.black)].set(move.target);
                //             self.occupancies[@enumToInt(Chess.Colors.white)].unSet(move.target);
                //         },
                //     }
                // }

Replacement in src/Board.zig at line 779 [6.16071]

B:BD[5.3777] → [5.3777:4088]

                    const target = switch (self.side) {
                        .white => @intToEnum(Square, @enumToInt(move.target) + 8),
                        .black => @intToEnum(Square, @enumToInt(move.target) - 8),
                    };
                    self.bitboards[move.piece.int()].pop(target);

[5.3777]

[5.4088]

                    switch (self.side) {
                        .white => self.bitboards[Chess.PE.p.int()]
                            .pop(@intToEnum(Square, @enumToInt(move.target) + 8)),
                        .black => self.bitboards[Chess.PE.P.int()]
                            .pop(@intToEnum(Square, @enumToInt(move.target) - 8)),
                    }

Insertion in src/Board.zig at line 786 [6.16071]

[5.4106]

                // reset enpassant
                self.enpassant = null;

Replacement in src/Board.zig at line 805 [6.16071]

B:BD[8.1687] → [7.2126:2320]

                                self.occupancies[@enumToInt(Chess.Colors.white)].pop(Square.h1);
                                self.occupancies[@enumToInt(Chess.Colors.white)].set(Square.f1);

[8.1687]

                                // self.occupancies[@enumToInt(Chess.Colors.white)].pop(Square.h1);
                                // self.occupancies[@enumToInt(Chess.Colors.white)].set(Square.f1);

Replacement in src/Board.zig at line 811 [6.16071]

B:BD[8.1917] → [7.2321:2515]

                                self.occupancies[@enumToInt(Chess.Colors.white)].pop(Square.a1);
                                self.occupancies[@enumToInt(Chess.Colors.white)].set(Square.d1);

[8.1917]

                                // self.occupancies[@enumToInt(Chess.Colors.white)].pop(Square.a1);
                                // self.occupancies[@enumToInt(Chess.Colors.white)].set(Square.d1);

Replacement in src/Board.zig at line 817 [6.16071]

B:BD[8.2147] → [7.2516:2710]

                                self.occupancies[@enumToInt(Chess.Colors.black)].pop(Square.h1);
                                self.occupancies[@enumToInt(Chess.Colors.black)].set(Square.f1);

[8.2147]

                                // self.occupancies[@enumToInt(Chess.Colors.black)].pop(Square.h1);
                                // self.occupancies[@enumToInt(Chess.Colors.black)].set(Square.f1);

Replacement in src/Board.zig at line 823 [6.16071]

B:BD[8.2377] → [7.2711:2905]

                                self.occupancies[@enumToInt(Chess.Colors.black)].pop(Square.a8);
                                self.occupancies[@enumToInt(Chess.Colors.black)].set(Square.d8);

[8.2377]

                                // self.occupancies[@enumToInt(Chess.Colors.black)].pop(Square.a8);
                                // self.occupancies[@enumToInt(Chess.Colors.black)].set(Square.d8);

Replacement in src/Board.zig at line 834 [6.16071]

B:BD[2.187] → [2.187:249]

                    // make sure the move is valid (no check)

[2.187]

[2.249]

                    // update occupancy boards
                    {
                        var white: BoardType = 0;
                        var black: BoardType = 0;
                        for ([_]Chess.PE{ .P, .N, .B, .R, .Q, .K }) |piece| {
                            white |= @bitCast(BoardType, self.bitboards[piece.int()]);
                        }
                        for ([_]Chess.PE{ .p, .n, .b, .r, .q, .k }) |piece| {
                            black |= @bitCast(BoardType, self.bitboards[piece.int()]);
                        }
                        self.occupancies[@enumToInt(Chess.Colors.white)] = @bitCast(BitBoard, white);
                        self.occupancies[@enumToInt(Chess.Colors.black)] = @bitCast(BitBoard, black);
                    }
                    // make sure the move is valid (king is not in check)

Replacement in src/Board.zig at line 858 [6.16071]

B:BD[2.673] → [2.673:747]

                    if (self.isSquareAttacked(king_square, self.enemy)) {

[2.673]

[2.747]


                    if (self.isSquareAttacked(king_square, self.side.enemy())) {

Insertion in src/Board.zig at line 863 [6.16071]

[2.852]


                    // FLIP SIDE
                    self.side = self.side.enemy();

Replacement in src/Board.zig at line 896 [6.16071]

B:BD[6.41360] → [6.41360:41388]

    try gs.generateMoves();

[6.41360]

[6.41388]

    var ml = try MoveList.init(0);
    try gs.generateMoves(&ml);

Replacement in src/Board.zig at line 899 [6.16071]

B:BD[6.41389] → [6.41389:41452]

    try std.testing.expectEqual(@as(usize, 49), gs.moves.len);

[6.41389]

[6.41452]

    try std.testing.expectEqual(@as(usize, 49), ml.len);

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

B:BD[5.4746] → [5.4746:5083]

B:BD[5.5083] → [2.973:1014]

∅:D[2.1014] → [5.5120:5143]

B:BD[5.5120] → [5.5120:5143]

∅:D[7.2982] → [5.5143:5188]

B:BD[5.5143] → [5.5143:5188]

∅:D[5.5188] → [6.42022:42024]

B:BD[6.42022] → [6.42022:42024]


test "makeMove" {
    const test_pos = "r3k2r/pPppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq c6 0 1";
    var gs = try GameState.init(test_pos);
    try gs.generateMoves();
    for (gs.moves.slice()) |move| {
        if (move.castling) {
            gs.show();
            move.show();
            const bk = gs.backup();
            _ = gs.makeMove(move, .all);
            gs.show();
            gs.restore(bk);
        }
    }
}