voroskoi/pistike - Change JPK7SJDQWLCNDXJQEQQHXBN4Y677BPQ5QBL55GRZ55RSP4GK4L4AC

Collect moves for each state

Created by voroskoi on January 7, 2023

JPK7SJDQWLCNDXJQEQQHXBN4Y677BPQ5QBL55GRZ55RSP4GK4L4AC

Dependencies

In channels

main

Change contents

Insertion in src/Chess.zig at line 2 [3.7502]
[3.7531]
[4.100]
```
const Str = []const u8;
```
Deletion in src/Chess.zig at line 8 [3.7502]
B:BD[3.7552] → [3.7552:7579]
B:BD[3.7579] → [5.890:917]
```
pub const BoardType = u64;
pub const SquareType = u6;
```
Insertion in src/Chess.zig at line 36 [3.7502]
[6.748]
[6.748]
```
    none,
```
Insertion in src/Chess.zig at line 56 [3.7502]
[6.1159]
[6.1159]
```
            .none => unreachable,
```

Replacement in src/Chess.zig at line 62 [3.7502]

B:BD[7.37] → [7.37:93]

    WK: bool,
    WQ: bool,
    BK: bool,
    BQ: bool,

[7.37]

[3.7703]

    WK: bool = false,
    WQ: bool = false,
    BK: bool = false,
    BQ: bool = false,

Insertion in src/Chess.zig at line 68 [3.7502]
[3.7707]
[5.918]
```
pub const SquareType = u6;
```
Insertion in src/Chess.zig at line 94 [3.7502]
[3.8973]
[3.8973]
```
pub const BoardType = u64;
```
Replacement in src/Chess.zig at line 144 [3.7502]
B:BD[6.1213] → [6.1213:1235]
```
const Game = struct {
```
[3.10910]
[6.1235]
```
const GameState = struct {
```

Replacement in src/Chess.zig at line 158 [3.7502]

B:BD[8.471] → [2.76:165]

    castling: Castling = Castling{ .WK = false, .WQ = false, .BK = false, .BQ = false },

[8.471]

[6.1435]

    castling: Castling = .{},
    moves: std.BoundedArray(BitMove, 64) = std.BoundedArray(BitMove, 64).init(0) catch unreachable,

Insertion in src/Chess.zig at line 165 [3.7502]

[6.1545]

        self.castling = .{};
        self.occupancies = [_]BoardType{0} ** 2;
        self.moves.resize(0) catch unreachable;

Replacement in src/Chess.zig at line 170 [3.7502]

B:BD[6.1552] → [6.1552:1587]

B:BD[6.1587] → [8.497:598]

    fn init(self: *@This()) void {
        self.parseFEN("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1") catch unreachable;

[6.1552]

[9.87]

    fn init(FEN: ?Str) !@This() {
        var gs = GameState{ .attacks = Attacks.init() };
        if (FEN != null)
            try gs.parseFEN(FEN.?)
        else
            try gs.parseFEN("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
        return gs;

Insertion in src/Chess.zig at line 209 [3.7502]

[7.450]

[8.599]

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

Replacement in src/Chess.zig at line 373 [3.7502]

B:BD[10.1] → [5.1522:1565]

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

[10.1]

[5.1565]

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

Replacement in src/Chess.zig at line 384 [3.7502]

B:BD[10.507] → [5.1687:1736]

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

[10.507]

[2.385]

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

Replacement in src/Chess.zig at line 386 [3.7502]

B:BD[2.413] → [2.413:504]

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

[2.413]

[2.504]

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

Replacement in src/Chess.zig at line 389 [3.7502]

B:BD[2.523] → [2.523:743]

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

[2.523]

[5.1764]

                .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),
                .none => unreachable,

Replacement in src/Chess.zig at line 398 [3.7502]

B:BD[5.1840] → [5.1840:1900]

    fn pawnMoves(self: @This(), board_in: BoardType) void {

[5.1840]

[5.1900]

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

Insertion in src/Chess.zig at line 402 [3.7502]

[2.788]

[5.2002]


        const promote_options = switch (self.side) {
            .white => [_]PE{ .Q, .R, .B, .N },
            .black => [_]PE{ .q, .r, .b, .n },
        };

Replacement in src/Chess.zig at line 438 [3.7502]

B:BD[5.3558] → [5.3558:3861]

                    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,

[5.3558]

[5.3861]

                    for (promote_options) |prom| {
                        try self.moves.append(BitMove{
                            .source = @intToEnum(Square, source_square),
                            .target = @intToEnum(Square, target_square),
                            .piece = piece,
                            .prom = prom,

Replacement in src/Chess.zig at line 447 [3.7502]

B:BD[5.3936] → [5.3936:4122]

                    std.debug.print("pawn push: {any}->{any}\n", .{
                        @intToEnum(Square, source_square),
                        @intToEnum(Square, target_square),

[5.3936]

[5.4122]

                    try self.moves.append(BitMove{
                        .source = @intToEnum(Square, source_square),
                        .target = @intToEnum(Square, target_square),
                        .piece = piece,

Replacement in src/Chess.zig at line 459 [3.7502]

B:BD[5.4485] → [5.4485:4690]

                        std.debug.print("pawn push double: {any}->{any}\n", .{
                            @intToEnum(Square, source_square),
                            @intToEnum(Square, double_target),

[5.4485]

[5.4690]

                        try self.moves.append(BitMove{
                            .source = @intToEnum(Square, source_square),
                            .target = @intToEnum(Square, double_target),
                            .piece = piece,
                            .double = true,

Replacement in src/Chess.zig at line 477 [3.7502]

B:BD[5.5254] → [5.5254:5564]

                    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,

[5.5254]

[5.5564]

                    for (promote_options) |prom| {
                        try self.moves.append(BitMove{
                            .source = @intToEnum(Square, source_square),
                            .target = @intToEnum(Square, target_square),
                            .piece = piece,
                            .prom = prom,
                            .capture = true,

Replacement in src/Chess.zig at line 487 [3.7502]

B:BD[5.5618] → [5.5618:5808]

                    std.debug.print("pawn attack: {any} -> {any}\n", .{
                        @intToEnum(Square, source_square),
                        @intToEnum(Square, target_square),

[5.5618]

[5.5808]

                    try self.moves.append(BitMove{
                        .source = @intToEnum(Square, source_square),
                        .target = @intToEnum(Square, target_square),
                        .piece = piece,
                        .capture = true,

Replacement in src/Chess.zig at line 506 [3.7502]

B:BD[5.6360] → [5.6360:6562]

                    std.debug.print("pawn enpassant capture: {any}->{any}\n", .{
                        @intToEnum(Square, source_square),
                        @intToEnum(Square, target_enpassant),

[5.6360]

[5.6562]

                    try self.moves.append(BitMove{
                        .source = @intToEnum(Square, source_square),
                        .target = @intToEnum(Square, target_enpassant),
                        .piece = piece,
                        .capture = true,

Replacement in src/Chess.zig at line 520 [3.7502]

B:BD[2.872] → [2.872:1527]

    fn castlingMoves(self: @This()) void {
        const king_side = switch (self.side) {
            .white => [_]Square{ .f1, .g1 },
            .black => [_]Square{ .f8, .g8 },
        };
        const queen_side = switch (self.side) {
            .white => [_]Square{ .d1, .c1, .b1 },
            .black => [_]Square{ .d8, .c8, .b8 },
        };
        const attacked_king = switch (self.side) {
            .white => [_]Square{ .e1, .f1 },
            .black => [_]Square{ .e8, .f8 },
        };
        const attacked_queen = switch (self.side) {
            .white => [_]Square{ .e1, .d1 },
            .black => [_]Square{ .e8, .d8 },
        };

[2.872]

[2.1527]

    fn castlingMoves(self: *@This(), piece: PE) !void {
        { // king-side castling
            const king_side = switch (self.side) {
                .white => [_]Square{ .f1, .g1 },
                .black => [_]Square{ .f8, .g8 },
            };
            const attacked_king = switch (self.side) {
                .white => [_]Square{ .e1, .f1 },
                .black => [_]Square{ .e8, .f8 },
            };

Replacement in src/Chess.zig at line 531 [3.7502]

B:BD[2.1528] → [2.1528:2055]

        // king-side castling
        if ((self.side == .white and self.castling.WK) or
            (self.side == .black and self.castling.BK))
        {
            // make sure king side is emptry
            for (king_side) |square| {
                if (self.occupBoth() & @as(BoardType, 1) << square.int() != 0) return;
            }
            // check that castling squares are not attacked
            for (attacked_king) |square| {
                if (self.isSquareAttacked(square, self.enemy)) return;
            }

[2.1528]

[2.2055]

            if ((self.side == .white and self.castling.WK) or
                (self.side == .black and self.castling.BK))
            {
                const OK = blk: {
                    // make sure king side is emptry
                    for (king_side) |square| {
                        if (self.occupBoth() & @as(BoardType, 1) << square.int() != 0) break :blk false;
                    }

Replacement in src/Chess.zig at line 540 [3.7502]

B:BD[2.2056] → [2.2056:2124]

            std.debug.print("king side castling\n", .{});
        }

[2.2056]

[2.2124]

                    // check that castling squares are not attacked
                    for (attacked_king) |square| {
                        if (self.isSquareAttacked(square, self.enemy)) break :blk false;
                    }

Replacement in src/Chess.zig at line 545 [3.7502]

B:BD[2.2125] → [2.2125:2642]

        // queen-side castling
        if ((self.side == .white and self.castling.WQ) or
            (self.side == .black and self.castling.BQ))
        {
            // make sure queen side is emptry
            for (queen_side) |square| {
                if (self.occupBoth() & @as(BoardType, 1) << square.int() != 0) return;
            }
            // check that castling squares are not attacked
            for (attacked_queen) |square| {
                if (self.isSquareAttacked(square, self.enemy)) return;

[2.2125]

[2.2642]

                    break :blk true;
                };
                if (OK) {
                    try self.moves.append(BitMove{
                        .source = attacked_king[0],
                        .target = king_side[1],
                        .piece = piece,
                    });
                }

Insertion in src/Chess.zig at line 556 [3.7502]
[2.2656]
[2.2656]
```
        }
```

Replacement in src/Chess.zig at line 558 [3.7502]

B:BD[2.2657] → [2.2657:2716]

            std.debug.print("queen side castling\n", .{});

[2.2657]

[2.2716]

        { // queen-side castling
            const queen_side = switch (self.side) {
                .white => [_]Square{ .d1, .c1, .b1 },
                .black => [_]Square{ .d8, .c8, .b8 },
            };
            const attacked_queen = switch (self.side) {
                .white => [_]Square{ .e1, .d1 },
                .black => [_]Square{ .e8, .d8 },
            };
            if ((self.side == .white and self.castling.WQ) or
                (self.side == .black and self.castling.BQ))
            {
                const OK = blk: {
                    // make sure queen side is emptry
                    for (queen_side) |square| {
                        if (self.occupBoth() & @as(BoardType, 1) << square.int() != 0) break :blk false;
                    }
                    // check that castling squares are not attacked
                    for (attacked_queen) |square| {
                        if (self.isSquareAttacked(square, self.enemy)) break :blk false;
                    }
                    break :blk true;
                };
                if (OK) {
                    try self.moves.append(BitMove{
                        .source = attacked_queen[0],
                        .target = queen_side[1],
                        .piece = piece,
                    });
                }
            }

Replacement in src/Chess.zig at line 596 [3.7502]

B:BD[2.2733] → [2.2733:2803]

    fn genMoves(self: @This(), board_in: BoardType, piece: PE) void {

[2.2733]

[2.2803]

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

Replacement in src/Chess.zig at line 620 [3.7502]

B:BD[2.3764] → [2.3764:3803]

                .P, .p => unreachable,

[2.3764]

[2.3803]

                .P, .p, .none => unreachable,

Replacement in src/Chess.zig at line 632 [3.7502]

B:BD[2.4161] → [2.4161:4382]

                    std.debug.print("{any} capture: {any}->{any}\n", .{
                        piece,
                        @intToEnum(Square, source_square),
                        @intToEnum(Square, target_square),

[2.4161]

[2.4382]

                    try self.moves.append(BitMove{
                        .source = @intToEnum(Square, source_square),
                        .target = @intToEnum(Square, target_square),
                        .piece = piece,
                        .capture = true,

Replacement in src/Chess.zig at line 639 [3.7502]

B:BD[2.4431] → [2.4431:4649]

                    std.debug.print("{any} move: {any}->{any}\n", .{
                        piece,
                        @intToEnum(Square, source_square),
                        @intToEnum(Square, target_square),

[2.4431]

[2.4649]

                    try self.moves.append(BitMove{
                        .source = @intToEnum(Square, source_square),
                        .target = @intToEnum(Square, target_square),
                        .piece = piece,

Insertion in src/Chess.zig at line 652 [3.7502]

[2.4843]

[5.6731]

};
pub const BitMoveType = u24;
const BitMove = packed struct(BitMoveType) {
    source: Square,
    target: Square,
    piece: PE,
    prom: PE = .none,
    capture: bool = false,
    double: bool = false,
    enpassant: bool = false,
    castling: bool = false,

Replacement in src/Chess.zig at line 667 [3.7502]

∅:D[9.2944] → [6.3573:3640]

B:BD[6.3573] → [6.3573:3640]

B:BD[6.3640] → [9.2945:3040]

    var game = Game{ .attacks = Attacks.init() };
    game.init();
    try game.parseFEN("r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1");

[9.2944]

[9.3040]

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

Replacement in src/Chess.zig at line 677 [3.7502]

B:BD[10.3154] → [10.3154:3204]

B:BD[10.3204] → [2.4844:4940]

    var game = Game{ .attacks = Attacks.init() };
    try game.parseFEN("r3k2r/p11pqpbp/bn2pnp1/2pPN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R b Kkq c6 0 1");

[10.3154]

[10.3299]

    var gs = try GameState.init("r3k2r/p11pqpbp/bn2pnp1/2pPN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w Kkq c6 0 1");
    try gs.generateMoves();

Replacement in src/Chess.zig at line 681 [3.7502]
B:BD[10.3300] → [10.3300:3317]
```
    game.show();
```
[10.3300]
[10.3317]
```
    gs.show();
}
```

Replacement in src/Chess.zig at line 684 [3.7502]

B:BD[10.3318] → [5.6833:6859]

    game.generateMoves();

[10.3318]

[10.3353]

const Game = struct {
    state: GameState,
    history: std.ArrayList(BitMove),
    fn init(allocator: std.mem.Allocator) @This() {
        var game: Game = undefined;
        game.state = GameState.init(null) catch unreachable;
        game.history = std.ArrayList(BitMove).init(allocator);
        return game;
    }
    fn deinit(self: @This()) void {
        self.history.deinit();
    }
};
test "Game" {
    var game = Game.init(std.testing.allocator);
    defer game.deinit();