voroskoi/pistike - Change GZPVUGLJGD3VGLIK7JDABQ24E5SWN5CYRDGI6PIAFZ2BIMRDMANQC

Refactoring: Move blocker attacks to attacks.zig

Created by voroskoi on January 3, 2023

GZPVUGLJGD3VGLIK7JDABQ24E5SWN5CYRDGI6PIAFZ2BIMRDMANQC

Dependencies

In channels

main

Change contents

Insertion in src/attacks.zig at line 272 [3.204]

[3.7438]

    }
    return attacks;
}
fn attackWithBlocker(blocks: Chess.BoardType, square: Chess.Square, piece: Chess.Pieces) Chess.BoardType {
    const rank = @intCast(isize, square.rank());
    const file = @intCast(isize, square.file());
    const moves = switch (piece) {
        .bishop => [_][2]i3{
            .{ -1, -1 },
            .{ -1, 1 },
            .{ 1, -1 },
            .{ 1, 1 },
        },
        .rook => [_][2]i3{
            .{ -1, 0 },
            .{ 1, 0 },
            .{ 0, -1 },
            .{ 0, 1 },
        },
        else => unreachable,
    };
    var attacks: Chess.BoardType = 0;
    for (moves) |m| {
        var step: i5 = 1;
        while (step < Chess.SIZE) : (step += 1) {
            const dr = rank + m[0] * step;
            const df = file + m[1] * step;
            if (m[0] > 0 and dr > 7) break;
            if (m[0] < 0 and dr < 0) break;
            if (m[1] > 0 and df > 7) break;
            if (m[1] < 0 and df < 0) break;
            const s = @intCast(u6, dr * Chess.SIZE + df);
            const mask = @intCast(Chess.BoardType, @as(Chess.BoardType, 1) << s);
            attacks |= mask;
            // stop when we hit a blocker
            if (mask & blocks != 0) break;
        }

Insertion in src/attacks.zig at line 322 [3.204]

[4.2]


test "attackWithBlocker" {
    var bb: Chess.BitBoard = .{};
    { // bishop d4
        bb.board = 0;
        bb.setSlice(&[_]Chess.Square{ .c3, .b6, .f2 });
        const got = attackWithBlocker(bb.board, .d4, .bishop);
        bb.board = 0;
        bb.setSlice(&[_]Chess.Square{ .c3, .f2, .e3, .c5, .b6, .e5, .f6, .g7, .h8 });

Insertion in src/attacks.zig at line 335 [3.204]

[4.3]

        try std.testing.expectEqual(bb.board, got);
    }
    { // rook d4
        bb.board = 0;
        bb.setSlice(&[_]Chess.Square{ .b4, .d3, .d5 });
        const got = attackWithBlocker(bb.board, .d4, .rook);
        bb.board = 0;
        bb.setSlice(&[_]Chess.Square{ .c4, .b4, .d3, .d5, .e4, .f4, .g4, .h4 });
        try std.testing.expectEqual(bb.board, got);
    }
    { // rook h8
        bb.board = 0;
        bb.setSlice(&[_]Chess.Square{.b8});
        const got = attackWithBlocker(bb.board, .h8, .rook);
        bb.board = 0;
        bb.setSlice(&[_]Chess.Square{ .b8, .c8, .d8, .e8, .f8, .g8, .h7, .h6, .h5, .h4, .h3, .h2, .h1 });
        try std.testing.expectEqual(bb.board, got);
    }
}

Deletion in src/Chess.zig at line 123 [3.7502]

B:BD[3.10763] → [3.10763:10769]

B:BD[3.10769] → [5.0:1]

B:BD[5.1] → [6.126:208]

∅:D[6.208] → [5.84:685]

B:BD[5.84] → [5.84:685]

B:BD[5.685] → [4.5623:5671]

∅:D[4.5671] → [5.737:1191]

B:BD[5.737] → [5.737:1191]

B:BD[5.1191] → [4.5672:5718]

∅:D[4.5718] → [5.1191:1292]

B:BD[5.1191] → [5.1191:1292]

    }
    pub fn riderBlocker(self: @This(), square: Square, piece: Pieces) BoardType {
        const rank = @intCast(isize, square.rank());
        const file = @intCast(isize, square.file());
        const moves = switch (piece) {
            .bishop => [_][2]i3{
                .{ -1, -1 },
                .{ -1, 1 },
                .{ 1, -1 },
                .{ 1, 1 },
            },
            .rook => [_][2]i3{
                .{ -1, 0 },
                .{ 1, 0 },
                .{ 0, -1 },
                .{ 0, 1 },
            },
            else => unreachable,
        };
        var blockers: BoardType = 0;
        for (moves) |m| {
            var step: i5 = 1;
            while (step < SIZE) : (step += 1) {
                const dr = rank + m[0] * step;
                const df = file + m[1] * step;
                if (m[0] > 0 and dr > 7) break;
                if (m[0] < 0 and dr < 0) break;
                if (m[1] > 0 and df > 7) break;
                if (m[1] < 0 and df < 0) break;
                const s = @intCast(u6, dr * SIZE + df);
                const mask = @intCast(BoardType, @as(BoardType, 1) << s);
                blockers |= mask;
                // stop when we hit a blocker
                if (mask & self.board != 0) break;
            }
        }
        return blockers;

Deletion in src/Chess.zig at line 180 [3.7502]

B:BD[5.1307] → [5.1307:1359]

B:BD[5.1359] → [2.3209:3228]

∅:D[2.3228] → [5.1375:1662]

B:BD[5.1375] → [5.1375:1662]

B:BD[5.1662] → [2.3229:3246]

∅:D[2.3246] → [5.1676:1949]

B:BD[5.1676] → [5.1676:1949]

B:BD[6.1071] → [6.1071:1078]

B:BD[6.1078] → [2.3247:3264]

∅:D[2.3264] → [4.5719:5829]

B:BD[6.1092] → [4.5719:5829]

∅:D[4.5829] → [6.1142:1143]

B:BD[6.1142] → [6.1142:1143]

B:BD[6.1143] → [4.5830:5952]

∅:D[4.5952] → [6.1593:1594]

B:BD[6.1593] → [6.1593:1594]

B:BD[6.1594] → [4.5953:6005]

∅:D[4.6005] → [6.1666:1672]

B:BD[6.1666] → [6.1666:1672]

∅:D[6.1672] → [7.998:1000]

B:BD[7.998] → [7.998:1000]


test "riderBlocker" {
    var bb: BitBoard = .{};
    { // bishop d4
        bb.board = 0;
        bb.setSlice(&[_]Square{ .c3, .b6, .f2 });
        const got = bb.riderBlocker(.d4, .bishop);
        bb.board = 0;
        bb.setSlice(&[_]Square{ .c3, .f2, .e3, .c5, .b6, .e5, .f6, .g7, .h8 });
        try std.testing.expectEqual(bb.board, got);
    }
    { // rook d4
        bb.board = 0;
        bb.setSlice(&[_]Square{ .b4, .d3, .d5 });
        const got = bb.riderBlocker(.d4, .rook);
        bb.board = 0;
        bb.setSlice(&[_]Square{ .c4, .b4, .d3, .d5, .e4, .f4, .g4, .h4 });
        try std.testing.expectEqual(bb.board, got);
    }
    { // rook h8
        bb.board = 0;
        bb.setSlice(&[_]Square{.b8});
        const got = bb.riderBlocker(.h8, .rook);
        bb.board = 0;
        bb.setSlice(&[_]Square{ .b8, .c8, .d8, .e8, .f8, .g8, .h7, .h6, .h5, .h4, .h3, .h2, .h1 });
        try std.testing.expectEqual(bb.board, got);
    }
}