voroskoi/pistike - Change 7SQSGQOZRCHN3GGWPNFI36K2R7YZMOPXZP3FP4PYDDOZML5YIYOQC

use pawnMove() as a separate function, bugfixes

Created by voroskoi on January 7, 2023

7SQSGQOZRCHN3GGWPNFI36K2R7YZMOPXZP3FP4PYDDOZML5YIYOQC

Dependencies

In channels

main

Change contents

Replacement in src/attacks.zig at line 42 [5.204]

B:BD[4.3794] → [4.3794:3884]

            const occupancy_idx = @as(Chess.BoardType, 1) << @intCast(u6, relevant_bits);

[4.3794]

[4.3884]

            const occupancy_idx = @as(Chess.BoardType, 1) << @intCast(Chess.SquareType, relevant_bits);

Replacement in src/attacks.zig at line 52 [5.204]

B:BD[4.4348] → [4.4348:4440]

                            @intCast(u6, @as(u7, 64) - bishop_relevant_bits[square.int()]);

[4.4348]

[4.4440]

                            @intCast(Chess.SquareType, @as(u7, 64) - bishop_relevant_bits[square.int()]);

Replacement in src/attacks.zig at line 62 [5.204]

B:BD[4.4946] → [4.4946:5036]

                            @intCast(u6, @as(u7, 64) - rook_relevant_bits[square.int()]);

[4.4946]

[4.5036]

                            @intCast(Chess.SquareType, @as(u7, 64) - rook_relevant_bits[square.int()]);

Replacement in src/attacks.zig at line 79 [5.204]

∅:D[2.181] → [4.5577:5667]

B:BD[4.5577] → [4.5577:5667]

        mut_occupancy >>= @intCast(u6, @as(u7, 64) - bishop_relevant_bits[square.int()]);

[2.181]

[4.5667]

        mut_occupancy >>= @intCast(Chess.SquareType, @as(u7, 64) - bishop_relevant_bits[square.int()]);

Replacement in src/attacks.zig at line 90 [5.204]

∅:D[2.286] → [4.6017:6105]

B:BD[4.6017] → [4.6017:6105]

        mut_occupancy >>= @intCast(u6, @as(u7, 64) - rook_relevant_bits[square.int()]);

[2.286]

[4.6105]

        mut_occupancy >>= @intCast(Chess.SquareType, @as(u7, 64) - rook_relevant_bits[square.int()]);

Replacement in src/attacks.zig at line 376 [5.204]

B:BD[5.7262] → [5.7262:7320]

            const s = @intCast(u6, dr * Chess.SIZE + df);

[5.7262]

[5.7320]

            const s = @intCast(Chess.SquareType, dr * Chess.SIZE + df);

Replacement in src/attacks.zig at line 419 [5.204]

B:BD[6.977] → [6.977:1035]

            const s = @intCast(u6, dr * Chess.SIZE + df);

[6.977]

[7.1486]

            const s = @intCast(Chess.SquareType, dr * Chess.SIZE + df);

Replacement in src/attacks.zig at line 475 [5.204]
B:BD[8.215] → [8.215:238]
```
    var count: u6 = 0;
```
[8.215]
[8.238]
```
    var count: Chess.SquareType = 0;
```

Replacement in src/attacks.zig at line 477 [5.204]

B:BD[8.288] → [7.2509:2560]

        const square = @intCast(u6, @ctz(attack));

[8.288]

[8.331]

        const square = @intCast(Chess.SquareType, @ctz(attack));

Replacement in src/attacks.zig at line 594 [5.204]

B:BD[8.3932] → [8.3932:4032]

            var magic_index: usize = @intCast(usize, tmp2 >> @intCast(u6, @as(u7, 64) - relevant));

[8.3932]

[8.4032]

            var magic_index: usize = @intCast(usize, tmp2 >> @intCast(Chess.SquareType, @as(u7, 64) - relevant));

Insertion in src/Chess.zig at line 7 [5.7502]
[5.7579]
[5.7579]
```
pub const SquareType = u6;
```
Replacement in src/Chess.zig at line 66 [5.7502]
B:BD[5.7707] → [5.7707:7744]
```
pub const Square = enum(BoardType) {
```
[5.7707]
[5.7744]
```
pub const Square = enum(SquareType) {
```

Replacement in src/Chess.zig at line 78 [5.7502]

B:BD[5.8072] → [5.8072:8154]

    pub fn int(self: @This()) u6 {
        return @intCast(u6, @enumToInt(self));

[5.8072]

[5.8154]

    pub fn int(self: @This()) SquareType {
        return @intCast(SquareType, @enumToInt(self));

Replacement in src/Chess.zig at line 103 [5.7502]

B:BD[9.1] → [9.1:42]

    fn set(self: *@This(), s: u6) void {

[9.1]

[9.42]

    fn set(self: *@This(), s: SquareType) void {

Replacement in src/Chess.zig at line 127 [5.7502]

B:BD[5.10288] → [5.10288:10353]

                const square = @intCast(u6, rank * SIZE + file);

[5.10288]

[7.4238]

                const square = @intCast(SquareType, rank * SIZE + file);

Replacement in src/Chess.zig at line 176 [5.7502]

B:BD[10.2973] → [10.2973:3038]

                const square = @intCast(u6, rank * SIZE + file);

[10.2973]

[10.3038]

                const square = @intCast(SquareType, rank * SIZE + file);

Replacement in src/Chess.zig at line 202 [5.7502]

B:BD[9.757] → [9.757:809]

        var rank: u6 = 0;
        var file: u6 = 0;

[9.757]

[9.809]

        var rank: SquareType = 0;
        var file: SquareType = 0;

Replacement in src/Chess.zig at line 217 [5.7502]

B:BD[9.1226] → [9.1226:1313]

                    file += try std.fmt.parseUnsigned(u6, in[idx .. idx + 1], 10) - 1;

[9.1226]

[9.1313]

                    file += try std.fmt.parseUnsigned(SquareType, in[idx .. idx + 1], 10) - 1;

Replacement in src/Chess.zig at line 280 [5.7502]

B:BD[9.3976] → [9.3976:4070]

            const r = SIZE - @intCast(u6, try std.fmt.parseUnsigned(u3, enpassant[1..], 10));

[9.3976]

[9.4070]

            const r = SIZE - @intCast(SquareType, try std.fmt.parseUnsigned(u3, enpassant[1..], 10));

Replacement in src/Chess.zig at line 351 [5.7502]

B:BD[3.1] → [3.1:200]

    fn generateMoves(self: @This(), color: Colors) void {
        var source_square: BoardType = undefined;
        var target_square: BoardType = undefined;
        const pieces = switch (color) {

[3.1]

[3.200]

    fn generateMoves(self: @This()) void {
        const pieces = switch (self.side) {

Replacement in src/Chess.zig at line 358 [5.7502]

B:BD[3.355] → [3.355:429]

            var board = @bitCast(BoardType, self.bitboards[piece.int()]);

[3.355]

[3.429]

            const board = @bitCast(BoardType, self.bitboards[piece.int()]);

Replacement in src/Chess.zig at line 362 [5.7502]

B:BD[3.507] → [3.507:785]

                .P, .p => {
                    while (board != 0) {
                        const s = @intCast(u6, @ctz(board));
                        source_square = @as(BoardType, 1) << s;
                        std.debug.print("pawn: {any}\n", .{@intToEnum(Square, s)});

[3.507]

[3.785]

                .P, .p => self.pawnMoves(board),
                else => {},
            }
        }
        // generate move for rest of pieces
    }
    fn pawnMoves(self: @This(), board_in: BoardType) void {
        var source_square: SquareType = undefined;
        var target_square: SquareType = undefined;
        var board = board_in;
        while (board != 0) {
            source_square = @intCast(SquareType, @ctz(board));
            // std.debug.print("pawn: {any}\n", .{@intToEnum(Square, source_square)});
            // early exit on underflow/overflow
            switch (self.side) {
                .white => if (@subWithOverflow(SquareType, source_square, 8, &target_square)) continue,
                .black => if (@addWithOverflow(SquareType, source_square, 8, &target_square)) continue,
            }

Replacement in src/Chess.zig at line 385 [5.7502]

B:BD[3.786] → [3.786:1184]

                        // early exit on underflow/overflow
                        switch (piece) {
                            .P => if (@subWithOverflow(BoardType, source_square, 8, &target_square)) continue,
                            .p => if (@addWithOverflow(BoardType, source_square, 8, &target_square)) continue,
                            else => unreachable,
                        }

[3.786]

[3.1184]

            const promote_condition = switch (self.side) {
                .white => source_square >= @enumToInt(Square.a7) and
                    source_square <= @enumToInt(Square.h7),
                .black => source_square >= @enumToInt(Square.a2) and
                    source_square <= @enumToInt(Square.h2),
            };

Replacement in src/Chess.zig at line 392 [5.7502]

B:BD[3.1185] → [3.1185:2417]

                        // generate quiet pawn moves
                        if (self.occupBoth() & target_square == 0) {
                            const promote_condition = switch (piece) {
                                .P => source_square >= @enumToInt(Square.a7) and
                                    source_square <= @enumToInt(Square.h7),
                                .p => source_square >= @enumToInt(Square.a2) and
                                    source_square <= @enumToInt(Square.h2),
                                else => unreachable,
                            };
                            const double_step_condition = switch (piece) {
                                .P => source_square >= @enumToInt(Square.a2) and
                                    source_square <= @enumToInt(Square.h2) and
                                    self.occupBoth() & (target_square - 8) == 0,
                                .p => source_square >= @enumToInt(Square.a7) and
                                    source_square <= @enumToInt(Square.h7) and
                                    self.occupBoth() & (target_square + 8) == 0,
                                else => unreachable,
                            };

[3.1185]

[3.2417]

            // generate quiet moves
            if (self.occupBoth() & (@as(BoardType, 1) << target_square) == 0) {
                const double_step_condition = switch (self.side) {
                    .white => source_square >= @enumToInt(Square.a2) and
                        source_square <= @enumToInt(Square.h2) and
                        self.occupBoth() & (@as(BoardType, 1) << (target_square - 8)) == 0,
                    .black => source_square >= @enumToInt(Square.a7) and
                        source_square <= @enumToInt(Square.h7) and
                        self.occupBoth() & (@as(BoardType, 1) << (target_square + 8)) == 0,
                };
                if (promote_condition) {
                    for ([_]u8{ 'q', 'r', 'b', 'n' }) |prom| {
                        std.debug.print("pawn promotions {any}->{any}{c}\n", .{
                            @intToEnum(Square, source_square),
                            @intToEnum(Square, target_square),
                            prom,
                        });
                    }
                } else {
                    std.debug.print("pawn push: {any}->{any}\n", .{
                        @intToEnum(Square, source_square),
                        @intToEnum(Square, target_square),
                    });

Replacement in src/Chess.zig at line 417 [5.7502]

B:BD[3.2418] → [3.2418:2624]

                            if (promote_condition) {
                                // TODO: add move to move list
                            } else {
                                // TODO: single step

[3.2418]

[3.2624]

                    // TODO: check: if single step is no-go, double can not work
                    if (double_step_condition) {
                        const double_target = switch (self.side) {
                            .white => target_square - 8,
                            .black => target_square + 8,
                        };
                        std.debug.print("pawn push double: {any}->{any}\n", .{
                            @intToEnum(Square, source_square),
                            @intToEnum(Square, double_target),
                        });
                    }
                }
            }

Replacement in src/Chess.zig at line 431 [5.7502]

B:BD[3.2625] → [3.2625:2883]

                                // TODO: double step
                                // FIXME: if single step is no-go, double can not work
                                if (double_step_condition) {}
                            }
                        }

[3.2625]

[3.2883]

            // generate attacks
            const other = switch (self.side) {
                .white => Colors.black,
                .black => Colors.white,
            };
            var attacks =
                self.attacks.pawn_attacks[@enumToInt(self.side)][source_square] &
                self.occupancies[@enumToInt(other)];
            while (attacks != 0) {
                target_square = @intCast(SquareType, @ctz(attacks));

Replacement in src/Chess.zig at line 442 [5.7502]

B:BD[3.2884] → [3.2884:2985]

                        // pop least significant bit
                        board ^= source_square;

[3.2884]

[3.2985]

                if (promote_condition) {
                    for ([_]u8{ 'q', 'r', 'b', 'n' }) |prom| {
                        std.debug.print("pawn promotion attacks {any}->{any}{c}\n", .{
                            @intToEnum(Square, source_square),
                            @intToEnum(Square, target_square),
                            prom,
                        });

Replacement in src/Chess.zig at line 450 [5.7502]

B:BD[3.3007] → [3.3007:3054]

                },
                else => {},

[3.3007]

[3.3054]

                } else {
                    std.debug.print("pawn attack: {any} -> {any}\n", .{
                        @intToEnum(Square, source_square),
                        @intToEnum(Square, target_square),
                    });
                }
                // pop processed attack bit
                attacks ^= @as(BoardType, 1) << target_square;

Deletion in src/Chess.zig at line 460 [5.7502]
B:BD[3.3068] → [3.3068:3078]
```
        }
```

Replacement in src/Chess.zig at line 461 [5.7502]

B:BD[3.3079] → [3.3079:3129]

∅:D[11.2917] → [10.3555:3558]

∅:D[3.3129] → [10.3555:3558]

B:BD[10.3555] → [10.3555:3558]

        // generate move for rest of pieces
    }
};

[3.3079]

[9.4161]

            // generate enpassant captures
            if (self.enpassant != null) {
                const enpassant_attacks = self.attacks.pawn_attacks[@enumToInt(self.side)][source_square] &
                    @as(BoardType, 1) << self.enpassant.?.int();

Replacement in src/Chess.zig at line 466 [5.7502]

B:BD[9.4162] → [9.4162:4612]

test "parseFEN" {
    const empty_board = "8/8/8/8/8/8/8/8 w - -";
    const start_position = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
    const tricky_position = "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1";
    const killer_position = "rnbqkb1r/pp1p1pPp/8/2p1pP2/1P1P4/3P3P/P1P1P3/RNBQKBNR w KQkq e6 0 1";
    const cmk_position = "r2q1rk1/ppp2ppp/2n1bn2/2b1p3/3pP3/3P1NPP/PPP1NPB1/R1BQ1RK1 b - - 0 9";

[9.4162]

[10.3558]

                if (enpassant_attacks != 0) {
                    const target_enpassant: SquareType = @intCast(u6, @ctz(enpassant_attacks));
                    std.debug.print("pawn enpassant capture: {any}->{any}\n", .{
                        @intToEnum(Square, source_square),
                        @intToEnum(Square, target_enpassant),
                    });
                }
            }

Replacement in src/Chess.zig at line 475 [5.7502]

B:BD[10.3559] → [9.4613:4857]

    var game = Game{ .attacks = Attacks.init() };
    try game.parseFEN(empty_board);
    try game.parseFEN(start_position);
    try game.parseFEN(tricky_position);
    try game.parseFEN(killer_position);
    try game.parseFEN(cmk_position);
}

[10.3559]

[9.4857]

            // pop processed board bit
            board ^= @as(BoardType, 1) << source_square;
        }
    }
};

Replacement in src/Chess.zig at line 495 [5.7502]

B:BD[3.3204] → [3.3204:3299]

    try game.parseFEN("r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1");

[3.3204]

[3.3299]

    try game.parseFEN("r3k2r/p11pqpbp/bn2pnp1/2pPN3/1p2P3/2N2Q1p/PPPBBPpP/R3K2R b KQkq c6 0 1");

Replacement in src/Chess.zig at line 499 [5.7502]
B:BD[3.3318] → [3.3318:3353]
```
    game.generateMoves(game.side);
```
[3.3318]
[3.3353]
```
    game.generateMoves();
```