voroskoi/pistike - Change QYOCQUIWNSZNLCPDJCKERKC6BXBUNTE6AJCFYL4WDRU32LFX37XQC

Implement FEN parser

Created by voroskoi on January 6, 2023

QYOCQUIWNSZNLCPDJCKERKC6BXBUNTE6AJCFYL4WDRU32LFX37XQC

Dependencies

In channels

main

Change contents

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

[3.4091]

[4.9165]


    fn set(self: *@This(), s: u6) void {
        var ret: BoardType = @bitCast(BoardType, self.*);
        ret |= @as(BoardType, 1) << s;
        self.* = @bitCast(BitBoard, ret);
    }

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

[5.1413]

    occupancies: [@typeInfo(Colors).Enum.fields.len]BitBoard = blk: {
        var bbs: [2]BitBoard = undefined;
        for (std.enums.values(Colors)) |color| {
            bbs[@enumToInt(color)] = BitBoard{};
        }
        break :blk bbs;
    },

Replacement in src/Chess.zig at line 156 [4.7502]
B:BD[2.121] → [2.121:161]
```
    enpassant: []Square = &[_]Square{},
```
[2.121]
[2.161]
```
    enpassant: ?Square = null,
```
Replacement in src/Chess.zig at line 161 [4.7502]
B:BD[5.1509] → [5.1509:1535]
```
            bb.board = 0;
```
[5.1509]
[5.1535]
```
            bb.* = .{};
```

Replacement in src/Chess.zig at line 166 [4.7502]

B:BD[5.1587] → [5.1587:2012]

B:BD[5.2012] → [3.4430:4476]

∅:D[3.4476] → [5.2057:2079]

B:BD[5.2057] → [5.2057:2079]

B:BD[5.2079] → [3.4477:4523]

∅:D[3.4523] → [5.2124:2550]

B:BD[5.2124] → [5.2124:2550]

B:BD[5.2550] → [3.4524:4570]

∅:D[3.4570] → [5.2595:2617]

B:BD[5.2595] → [5.2595:2617]

B:BD[5.2617] → [3.4571:4617]

        // white pawns
        self.bitboards[PE.P.int()].setSlice(&[_]Square{ .a2, .b2, .c2, .d2, .e2, .f2, .g2, .h2 });
        // white knights
        self.bitboards[PE.N.int()].setSlice(&[_]Square{ .b1, .g1 });
        // white bishops
        self.bitboards[PE.B.int()].setSlice(&[_]Square{ .c1, .f1 });
        // white rooks
        self.bitboards[PE.R.int()].setSlice(&[_]Square{ .a1, .h1 });
        // white queen
        self.bitboards[PE.Q.int()].d1 = true;
        // white king
        self.bitboards[PE.K.int()].e1 = true;
        // black pawns
        self.bitboards[PE.p.int()].setSlice(&[_]Square{ .a7, .b7, .c7, .d7, .e7, .f7, .g7, .h7 });
        // black knights
        self.bitboards[PE.n.int()].setSlice(&[_]Square{ .b8, .g8 });
        // black bishops
        self.bitboards[PE.b.int()].setSlice(&[_]Square{ .c8, .f8 });
        // black rooks
        self.bitboards[PE.r.int()].setSlice(&[_]Square{ .a8, .h8 });
        // black queen
        self.bitboards[PE.q.int()].d8 = true;
        // black king
        self.bitboards[PE.k.int()].e8 = true;

[5.1587]

[5.2662]

        self.parseFEN("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1") catch unreachable;

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

[2.450]

[5.3549]

    }
    fn parseFEN(self: *@This(), in: []const u8) !void {
        self.reset();
        // std.debug.print("in: {s}\n", .{in});
        // parse ranks
        var rank: u6 = 0;
        var file: u6 = 0;
        var idx: usize = 0;
        while (idx < in.len) : ({
            idx += 1;
            if (in[idx - 1] != '/') file += 1;
        }) {
            // std.debug.print("{c} {d}\n", .{ in[idx], rank * SIZE + file });
            const ch = in[idx];
            switch (ch) {
                '/' => {
                    rank += 1;
                    file = 0;
                },
                '0'...'9' => {
                    file += try std.fmt.parseUnsigned(u6, in[idx .. idx + 1], 10) - 1;
                },
                65...90 => { // uppercase
                    self.occupancies[@enumToInt(Colors.white)].set(rank * SIZE + file);
                    switch (ch) {
                        'P' => self.bitboards[PE.P.int()].set(rank * SIZE + file),
                        'N' => self.bitboards[PE.N.int()].set(rank * SIZE + file),
                        'B' => self.bitboards[PE.B.int()].set(rank * SIZE + file),
                        'R' => self.bitboards[PE.R.int()].set(rank * SIZE + file),
                        'Q' => self.bitboards[PE.Q.int()].set(rank * SIZE + file),
                        'K' => self.bitboards[PE.K.int()].set(rank * SIZE + file),
                        else => unreachable,
                    }
                },
                97...122 => { // lowercase
                    self.occupancies[@enumToInt(Colors.black)].set(rank * SIZE + file);
                    switch (ch) {
                        'p' => self.bitboards[PE.p.int()].set(rank * SIZE + file),
                        'n' => self.bitboards[PE.n.int()].set(rank * SIZE + file),
                        'b' => self.bitboards[PE.b.int()].set(rank * SIZE + file),
                        'r' => self.bitboards[PE.r.int()].set(rank * SIZE + file),
                        'q' => self.bitboards[PE.q.int()].set(rank * SIZE + file),
                        'k' => self.bitboards[PE.k.int()].set(rank * SIZE + file),
                        else => unreachable,
                    }
                },
                ' ' => break,
                else => unreachable,
            }
        }
        // parse rest
        // std.debug.print("rest: {s}\n", .{in[idx..]});
        var parts = std.mem.tokenize(u8, in[idx..], " ");
        // side
        const side = parts.next().?[0];
        // std.debug.print("side: {c}\n", .{side});
        switch (side) {
            'w' => self.side = .white,
            'b' => self.side = .black,
            else => unreachable,
        }
        // castling
        const castling = parts.next().?;
        // std.debug.print("castling: {s}\n", .{castling});
        for (castling) |ch| {
            switch (ch) {
                'K' => self.castling.WK = true,
                'Q' => self.castling.WQ = true,
                'k' => self.castling.BK = true,
                'q' => self.castling.BQ = true,
                '-' => break,
                else => unreachable,
            }
        }
        // enpassant
        const enpassant = parts.next().?;
        // std.debug.print("enpassant: {s}\n", .{enpassant});
        if (enpassant[0] != '-') {
            const f = enpassant[0] - 'a';
            const r = SIZE - @intCast(u6, try std.fmt.parseUnsigned(u3, enpassant[1..], 10));
            self.enpassant = @intToEnum(Square, r * SIZE + f);
        }
        return;

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

[5.3558]


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";

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

[5.3559]

    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);
}

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

[5.3657]


    game.occupancies[@enumToInt(Colors.white)].show();
    game.occupancies[@enumToInt(Colors.black)].show();