voroskoi/pistike - Change 2CU67A3QXXPH722WBAL74O6P2N2RRXFBQVPT3A5QAXTUCQ3UUU5AC

Start working on makeMove()

Created by voroskoi on January 7, 2023

2CU67A3QXXPH722WBAL74O6P2N2RRXFBQVPT3A5QAXTUCQ3UUU5AC

Dependencies

In channels

main

Change contents

Replacement in src/Chess.zig at line 38 [4.7502]
B:BD[3.820] → [3.820:852]
```
    fn char(self: @This()) u8 {
```
[3.820]
[3.852]
```
    pub fn char(self: @This()) u8 {
```

Replacement in src/Board.zig at line 50 [2.16071]

B:BD[2.18073] → [2.18073:18122]

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

[2.18073]

[2.18122]

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

Replacement in src/Board.zig at line 52 [2.16071]

B:BD[2.18180] → [2.18180:18219]

        ret |= @as(BoardType, 1) << s;

[2.18180]

[2.18219]

        ret |= @as(BoardType, 1) << @enumToInt(s);

Insertion in src/Board.zig at line 62 [2.16071]

[2.18522]

    }
    fn isSet(self: @This(), s: Square) bool {
        var ret = @bitCast(BoardType, self);
        return (ret & @as(BoardType, 1) << @enumToInt(s) != 0);

Insertion in src/Board.zig at line 69 [2.16071]

[2.18529]

    fn pop(self: *@This(), s: Square) void {
        var ret = @bitCast(BoardType, self.*);
        ret ^= @as(BoardType, 1) << @enumToInt(s);
        self.* = @bitCast(BitBoard, ret);
    }

Insertion in src/Board.zig at line 98 [2.16071]
[2.19467]
[2.19467]
```
const Moves = enum {
    all,
    captures,
};
```

Insertion in src/Board.zig at line 113 [2.16071]

[2.19744]


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

Insertion in src/Board.zig at line 256 [2.16071]

[2.24068]

                    const square = @intToEnum(Square, rank * SIZE + file);

Replacement in src/Board.zig at line 258 [2.16071]

B:BD[2.24102] → [2.24102:24636]

                        'P' => self.bitboards[Chess.PE.P.int()].set(rank * SIZE + file),
                        'N' => self.bitboards[Chess.PE.N.int()].set(rank * SIZE + file),
                        'B' => self.bitboards[Chess.PE.B.int()].set(rank * SIZE + file),
                        'R' => self.bitboards[Chess.PE.R.int()].set(rank * SIZE + file),
                        'Q' => self.bitboards[Chess.PE.Q.int()].set(rank * SIZE + file),
                        'K' => self.bitboards[Chess.PE.K.int()].set(rank * SIZE + file),

[2.24102]

[2.24636]

                        'P' => self.bitboards[Chess.PE.P.int()].set(square),
                        'N' => self.bitboards[Chess.PE.N.int()].set(square),
                        'B' => self.bitboards[Chess.PE.B.int()].set(square),
                        'R' => self.bitboards[Chess.PE.R.int()].set(square),
                        'Q' => self.bitboards[Chess.PE.Q.int()].set(square),
                        'K' => self.bitboards[Chess.PE.K.int()].set(square),

Insertion in src/Board.zig at line 270 [2.16071]

[2.24904]

                    const square = @intToEnum(Square, rank * SIZE + file);

Replacement in src/Board.zig at line 272 [2.16071]

B:BD[2.24938] → [2.24938:25472]

                        'p' => self.bitboards[Chess.PE.p.int()].set(rank * SIZE + file),
                        'n' => self.bitboards[Chess.PE.n.int()].set(rank * SIZE + file),
                        'b' => self.bitboards[Chess.PE.b.int()].set(rank * SIZE + file),
                        'r' => self.bitboards[Chess.PE.r.int()].set(rank * SIZE + file),
                        'q' => self.bitboards[Chess.PE.q.int()].set(rank * SIZE + file),
                        'k' => self.bitboards[Chess.PE.k.int()].set(rank * SIZE + file),

[2.24938]

[2.25472]

                        'p' => self.bitboards[Chess.PE.p.int()].set(square),
                        'n' => self.bitboards[Chess.PE.n.int()].set(square),
                        'b' => self.bitboards[Chess.PE.b.int()].set(square),
                        'r' => self.bitboards[Chess.PE.r.int()].set(square),
                        'q' => self.bitboards[Chess.PE.q.int()].set(square),
                        'k' => self.bitboards[Chess.PE.k.int()].set(square),

Insertion in src/Board.zig at line 537 [2.16071]

[2.35756]

                        .enpassant = true,

Insertion in src/Board.zig at line 679 [2.16071]

[2.40867]


    fn makeMove(self: *@This(), move: BitMove, flag: Moves) void {
        switch (flag) {
            .all => {
                // preserve board state
                // const bckup = self.backup(); FIXME
                // move piece
                self.bitboards[move.piece.int()].pop(move.source);
                self.bitboards[move.piece.int()].set(move.target);
                // TODO: reset enpassant
                // self.enpassant = null;
                // handling captures
                if (move.capture) {
                    const pieces = switch (self.side) {
                        .white => [_]Chess.PE{ .p, .n, .b, .r, .q, .k },
                        .black => [_]Chess.PE{ .P, .N, .B, .R, .Q, .K },
                    };
                    // loop over enemy bitboards, when target occupancy found pop it
                    for (pieces) |piece| {
                        if (self.bitboards[piece.int()].isSet(move.target)) {
                            self.bitboards[piece.int()].pop(move.target);
                            break;
                        }
                    }
                }
                // handling promotions
                if (move.prom != .none) {
                    // erase pawn from target square (already moved)
                    self.bitboards[move.piece.int()].pop(move.target);
                    // add promoted item to target peace
                    self.bitboards[move.prom.int()].set(move.target);
                }
                // handling enpassant
                if (move.enpassant) {
                    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);
                }
                // handle double pawn step
                if (move.double) {
                    const enpassant = switch (self.side) {
                        .white => @intToEnum(Square, @enumToInt(move.target) + 8),
                        .black => @intToEnum(Square, @enumToInt(move.target) - 8),
                    };
                    self.enpassant = enpassant;
                }
            },
            .captures => {
                if (move.capture) {
                    self.makeMove(move, .all);
                }
                // the move is not a capture
                return;
            },
        }
    }

Insertion in src/Board.zig at line 782 [2.16071]

[2.42022]

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