voroskoi/pistike - Change 3H3DSWLBWCE7C43W6LHICCPJ5KQDLASLQPIKJOK2KAE6OFF2L6WAC

Cosmetics

Created by voroskoi on January 17, 2023

3H3DSWLBWCE7C43W6LHICCPJ5KQDLASLQPIKJOK2KAE6OFF2L6WAC

Dependencies

In channels

main

Change contents

Replacement in src/perft.zig at line 9 [2.34]

B:BD[2.176] → [2.176:236]

    pub fn perftDriver(self: *@This(), depth: usize) void {

[2.176]

[2.236]

    pub fn perftDriver(self: *@This(), depth: usize) !void {

Replacement in src/perft.zig at line 16 [2.34]

B:BD[2.349] → [2.349:408]

        var ml = Board.MoveList.init(0) catch unreachable;

[2.349]

[2.408]

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

Deletion in src/perft.zig at line 19 [2.34]
B:BD[2.409] → [2.409:463]
B:BD[2.463] → [2.463:464]
```
        self.gs.generateMoves(&ml) catch unreachable;
```

Replacement in src/perft.zig at line 26 [2.34]

B:BD[2.630] → [2.630:671]

            self.perftDriver(depth - 1);

[2.630]

[2.671]

            try self.perftDriver(depth - 1);

Replacement in src/perft.zig at line 32 [2.34]

B:BD[2.722] → [2.722:889]

    fn perftTest(self: *@This(), depth: usize) void {
        var ml = Board.MoveList.init(0) catch unreachable;
        self.gs.generateMoves(&ml) catch unreachable;

[2.722]

[2.889]

    fn perftTest(self: *@This(), depth: usize) !void {
        var ml = try Board.MoveList.init(0);
        try self.gs.generateMoves(&ml);

Deletion in src/perft.zig at line 40 [2.34]

B:BD[2.1015] → [2.1015:1071]

                std.debug.print("ILLEGAL MOVE\n", .{});

Replacement in src/perft.zig at line 45 [2.34]

B:BD[2.1163] → [2.1163:1204]

            self.perftDriver(depth - 1);

[2.1163]

[2.1204]

            try self.perftDriver(depth - 1);

Replacement in src/perft.zig at line 58 [2.34]

B:BD[2.1421] → [2.1421:1515]

    var gs = Board.GameState.init("8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - -") catch unreachable;

[2.1421]

[2.1515]

    var gs = try Board.GameState.init("8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - -");

Replacement in src/perft.zig at line 60 [2.34]
B:BD[2.1546] → [2.1546:1568]
```
    p.perftDriver(2);
```
[2.1546]
[2.1568]
```
    try p.perftDriver(2);
```

Insertion in src/perft.zig at line 63 [2.34]

[2.1629]


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

Replacement in src/main.zig at line 14 [3.50]
B:BD[2.1867] → [2.1867:1889]
```
    p.perftDriver(4);
```
[2.1867]
[2.1889]
```
    try p.perftDriver(4);
```

Insertion in src/Board.zig at line 726 [5.16071]

[4.2287]

            .captures => {
                if (move.capture) {
                    return self.makeMove(move, .all);
                }
                // the move is not a capture
                return false;
            },

Replacement in src/Board.zig at line 742 [5.16071]

B:BD[4.2569] → [2.4729:4789]

                // handle occupancy arrays TODO: perf test!

[4.2569]

[2.4789]

                // handle occupancy arrays
                // TODO: perf test against full update used below!

Replacement in src/Board.zig at line 762 [5.16071]

B:BD[4.2653] → [4.2653:2951]

                // 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 },
                    };

[4.2653]

[4.2951]

                { // 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 },
                        };

Replacement in src/Board.zig at line 769 [5.16071]

B:BD[4.2952] → [4.2952:3267]

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

[4.2952]

[4.3267]

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

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

B:BD[4.3334] → [4.3334:3700]

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

[4.3334]

[4.3700]

                { // pawn stuff
                    // 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);
                    }

Replacement in src/Board.zig at line 788 [5.16071]

B:BD[4.3701] → [4.3701:3777]

B:BD[4.3777] → [2.5746:6087]

                // handling enpassant
                if (move.enpassant) {
                    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)),

[4.3701]

[2.6087]

                    // handling enpassant
                    if (move.enpassant) {
                        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)),
                        }

Replacement in src/Board.zig at line 797 [5.16071]

∅:D[2.6109] → [4.4088:4106]

B:BD[4.4088] → [4.4088:4106]

B:BD[4.4106] → [2.6110:6184]

                }
                // reset enpassant
                self.enpassant = null;

[2.6109]

[4.4106]

                    // reset enpassant
                    self.enpassant = null;

Replacement in src/Board.zig at line 800 [5.16071]

B:BD[4.4107] → [4.4107:4481]

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

[4.4107]

[4.4481]

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

Replacement in src/Board.zig at line 845 [5.16071]

B:BD[6.2662] → [7.186:187]

B:BD[7.187] → [2.6989:7540]


                    // 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()]);
                        }

[6.2662]

[2.7540]

Replacement in src/Board.zig at line 847 [5.16071]

B:BD[2.7541] → [2.7541:7745]

                        self.occupancies[@enumToInt(Chess.Colors.white)] = @bitCast(BitBoard, white);
                        self.occupancies[@enumToInt(Chess.Colors.black)] = @bitCast(BitBoard, black);

[2.7541]

[2.7745]

                { // 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()]);

Replacement in src/Board.zig at line 857 [5.16071]

B:BD[2.7768] → [2.7768:7842]

                    // make sure the move is valid (king is not in check)

[2.7768]

[7.249]

                    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)

Deletion in src/Board.zig at line 875 [5.16071]

B:BD[7.852] → [2.7926:8011]

∅:D[2.8011] → [7.852:853]

B:BD[7.852] → [7.852:853]

B:BD[7.853] → [7.853:886]

∅:D[7.886] → [6.2662:2680]

B:BD[6.2662] → [6.2662:2680]

∅:D[6.2680] → [4.4499:4577]

B:BD[4.4499] → [4.4499:4577]

B:BD[4.4577] → [7.887:941]


                    // FLIP SIDE
                    self.side = self.side.enemy();
                    return true;
                }
            },
            .captures => {
                if (move.capture) {
                    return self.makeMove(move, .all);

Replacement in src/Board.zig at line 877 [5.16071]

B:BD[4.4643] → [4.4643:4688]

B:BD[4.4688] → [7.942:972]

                // the move is not a capture
                return false;

[4.4643]

[4.4712]

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