voroskoi/pistike - Change BL3ZR4OWJM54HFXUNMUZKB5YQYVBT7ETFIXCOXWL6S5SZFM6IFDQC

Refactoring, simplifying attack table generation

Created by voroskoi on December 20, 2022

BL3ZR4OWJM54HFXUNMUZKB5YQYVBT7ETFIXCOXWL6S5SZFM6IFDQC

Dependencies

In channels

main

Change contents

Insertion in src/main.zig at line 2 [5.50]
[5.79]
[5.79]
```
const Chess = @import("Chess.zig");
```

Replacement in src/main.zig at line 6 [5.50]

B:BD[5.102] → [5.102:149]

    var bit_board: BitBoard = .{ .board = 0 };

[5.102]

[5.149]

    var bit_board: Chess.BitBoard = .{ .board = 0 };

Deletion in src/main.zig at line 9 [5.50]

B:BD[5.173] → [6.0:48]

∅:D[6.48] → [5.173:613]

B:BD[5.173] → [5.173:613]

B:BD[5.613] → [2.0:328]

∅:D[2.328] → [5.613:619]

B:BD[5.613] → [5.613:619]

B:BD[5.619] → [2.329:626]

∅:D[2.626] → [5.619:840]

B:BD[5.619] → [5.619:840]

B:BD[5.840] → [6.49:187]

∅:D[6.187] → [5.840:1424]

B:BD[5.840] → [5.840:1424]

B:BD[5.1424] → [6.188:224]

∅:D[6.224] → [5.1424:1651]

B:BD[5.1424] → [5.1424:1651]


const Colors = enum {
    white,
    black,
};
const Square = enum(BoardType) {
    // zig fmt: off
    a8, b8, c8, d8, e8, f8, g8, h8,
    a7, b7, c7, d7, e7, f7, g7, h7,
    a6, b6, c6, d6, e6, f6, g6, h6,
    a5, b5, c5, d5, e5, f5, g5, h5,
    a4, b4, c4, d4, e4, f4, g4, h4,
    a3, b3, c3, d3, e3, f3, g3, h3,
    a2, b2, c2, d2, e2, f2, g2, h2,
    a1, b1, c1, d1, e1, f1, g1, h1,
    // zig fmt: on
    fn int(self: @This()) u6 {
        return @intCast(u6, @enumToInt(self));
    }
    fn fileBits(file: u8) BoardType {
        const offset = file - 'a';
        std.debug.assert(offset < SIZE);
        var ret: BoardType = 0;
        var idx: u6 = 0;
        while (idx < SIZE) : (idx += 1) {
            ret += @as(BoardType, 1) << idx * SIZE + @intCast(u3, offset);
        }
        return ret;
    }
    fn rankBits(rank: u6) BoardType {
        var ret: BoardType = 0;
        std.debug.assert(rank > 0 and rank <= SIZE);
        var idx: u6 = 0;
        while (idx < SIZE) : (idx += 1) {
            ret += @as(BoardType, 1) << idx + (SIZE - rank) * SIZE;
        }
        return ret;
    }
};
const SIZE = 8;
const BoardType = u64;
const BitBoard = packed struct(BoardType) {
    board: BoardType = 0,
    fn set(self: *@This(), square: Square) void {
        self.board |= @as(BoardType, 1) << square.int();
    }
    fn setSlice(self: *@This(), squares: []Square) void {
        for (squares) |square| {
            self.set(square);
        }
    }
    fn isSet(self: @This(), square: Square) bool {
        return (self.board & @as(BoardType, 1) << square.int() != 0);
    }
    fn unSet(self: *@This(), square: Square) void {
        self.board &= @as(BoardType, 0) << square.int();
    }
    fn flip(self: *@This(), square: Square) void {
        self.board ^= @as(BoardType, 1) << square.int();
    }
    // pop removes the bit if set
    fn pop(self: *@This(), square: Square) void {
        if (self.isSet(square))
            self.board ^= @as(BoardType, 1) << square.int();
    }
    fn show(self: @This()) void {
        std.debug.print("\n", .{});
        var rank: usize = 0;
        while (rank < SIZE) : (rank += 1) {
            var file: usize = 0;
            while (file < SIZE) : (file += 1) {
                if (file == 0) std.debug.print("{d}| ", .{SIZE - rank});

Replacement in src/main.zig at line 10 [5.50]

B:BD[5.1652] → [5.1652:3467]

                const square = @intCast(u6, rank * SIZE + file);
                const mask: usize = if (self.board & (@as(BoardType, 1) << square) != 0) 1 else 0;
                std.debug.print("{d} ", .{mask});
            }
            std.debug.print("\n", .{});
        }
        std.debug.print("{s:>18}\n", .{"---------------"});
        std.debug.print("{s:>18}\n", .{"a b c d e f g h"});
        std.debug.print("\nBitBoard: {d}\n", .{self.board});
    }
};
test "BitBoard" {
    { // set, unSet
        var bb: BitBoard = .{};
        try std.testing.expectEqual(@as(BoardType, 0), bb.board);
        bb.set(.a8);
        try std.testing.expectEqual(@as(BoardType, 1), bb.board);
        bb.unSet(.a8);
        bb.set(.h1);
        const exp = @as(BoardType, 1) << @as(u6, 63);
        try std.testing.expectEqual(exp, bb.board);
    }
    { // flip
        var bb: BitBoard = .{};
        bb.set(.e4);
        try std.testing.expect(bb.isSet(.e4));
        bb.set(.f1);
        try std.testing.expect(bb.isSet(.f1));
        bb.flip(.e4);
        bb.flip(.f1);
        try std.testing.expectEqual(@as(BoardType, 0), bb.board);
        bb.flip(.f1); // sets f1 again
        try std.testing.expectEqual(
            @as(BoardType, @as(BoardType, 1) << @enumToInt(Square.f1)),
            bb.board,
        );
    }
    { // pop
        var bb: BitBoard = .{};
        bb.set(.e4);
        bb.set(.f1);
        bb.pop(.e4);
        bb.pop(.f1);
        bb.set(.g3);
        try std.testing.expectEqual(
            @as(BoardType, @as(BoardType, 1) << @enumToInt(Square.g3)),
            bb.board,
        );
        bb.pop(.e4); // does nothing
        try std.testing.expectEqual(
            @as(BoardType, @as(BoardType, 1) << @enumToInt(Square.g3)),
            bb.board,
        );
    }

[5.1652]

[5.3467]

test "All" {
    _ = @import("Chess.zig");
    _ = @import("attacks.zig");

Deletion in src/main.zig at line 14 [5.50]

B:BD[5.3469] → [6.225:226]

B:BD[6.226] → [2.627:729]

∅:D[2.729] → [6.327:405]

B:BD[6.327] → [6.327:405]

B:BD[6.602] → [6.602:603]

B:BD[6.800] → [6.800:1076]

B:BD[6.1076] → [2.730:877]

∅:D[2.877] → [6.1209:1252]

B:BD[6.1209] → [6.1209:1252]

B:BD[6.1252] → [2.878:1025]

∅:D[2.1025] → [6.1385:1475]

B:BD[6.1385] → [6.1385:1475]

B:BD[6.1475] → [2.1026:1173]

∅:D[2.1173] → [6.1608:1650]

B:BD[6.1608] → [6.1608:1650]

B:BD[6.1650] → [2.1174:1321]

∅:D[2.1321] → [6.1783:1852]

B:BD[6.1783] → [6.1783:1852]

B:BD[6.1852] → [2.1322:1376]

∅:D[2.1376] → [6.1904:3505]

B:BD[6.1904] → [6.1904:3505]

B:BD[6.3505] → [7.0:1228]

∅:D[7.1228] → [6.3505:3511]

B:BD[6.3505] → [6.3505:3511]

B:BD[6.3511] → [7.1229:1246]

∅:D[7.1246] → [6.3511:3513]

B:BD[6.3511] → [6.3511:3513]

B:BD[6.3513] → [7.1247:2170]

B:BD[7.2170] → [3.0:1489]

∅:D[3.1489] → [7.2170:2187]

B:BD[7.2170] → [7.2170:2187]

B:BD[7.2187] → [3.1490:2003]

∅:D[3.2003] → [7.2187:2189]

B:BD[7.2187] → [7.2187:2189]

B:BD[7.2189] → [4.0:1278]


fn genPawnAttacks() [@typeInfo(Colors).Enum.fields.len][@typeInfo(Square).Enum.fields.len]BoardType {
    var ret: [2][64]BoardType = [_][64]BoardType{[_]BoardType{0} ** 64} ** 2;
    var bb: BitBoard = .{};
    for (std.enums.values(Colors)) |color| {
        for (std.enums.values(Square)) |square| {
            bb.board = 0;
            bb.set(square);
            switch (color) {
                .white => {
                    // towards lower file
                    if (bb.board & Square.fileBits('a') == 0)
                        ret[@enumToInt(color)][@enumToInt(square)] |= bb.board >> 9;
                    // towards higher file
                    if (bb.board & Square.fileBits('h') == 0)
                        ret[@enumToInt(color)][@enumToInt(square)] |= bb.board >> 7;
                },
                .black => {
                    // towards higher file
                    if (bb.board & Square.fileBits('h') == 0)
                        ret[@enumToInt(color)][@enumToInt(square)] |= bb.board << 9;
                    // towards lower file
                    if (bb.board & Square.fileBits('a') == 0)
                        ret[@enumToInt(color)][@enumToInt(square)] |= bb.board << 7;
                },
            }
        }
    }
    return ret;
}
test "PawnAttacks" {
    const pa = genPawnAttacks();
    { // White
        {
            var bb: BitBoard = .{};
            bb.set(.c5);
            bb.set(.e5);
            try std.testing.expectEqual(
                bb.board,
                pa[@enumToInt(Colors.white)][@enumToInt(Square.d4)],
            );
        }
        {
            // no left attack
            var bb: BitBoard = .{};
            bb.set(.b5);
            try std.testing.expectEqual(
                bb.board,
                pa[@enumToInt(Colors.white)][@enumToInt(Square.a4)],
            );
        }
        {
            // no right attack
            var bb: BitBoard = .{};
            bb.set(.g5);
            try std.testing.expectEqual(
                bb.board,
                pa[@enumToInt(Colors.white)][@enumToInt(Square.h4)],
            );
        }
    }
    { // Black
        {
            var bb: BitBoard = .{};
            bb.set(.c3);
            bb.set(.e3);
            try std.testing.expectEqual(
                bb.board,
                pa[@enumToInt(Colors.black)][@enumToInt(Square.d4)],
            );
        }
        {
            // no left attack
            var bb: BitBoard = .{};
            bb.set(.b3);
            try std.testing.expectEqual(
                bb.board,
                pa[@enumToInt(Colors.black)][@enumToInt(Square.a4)],
            );
        }
        {
            // no right attack
            var bb: BitBoard = .{};
            bb.set(.g3);
            try std.testing.expectEqual(
                bb.board,
                pa[@enumToInt(Colors.black)][@enumToInt(Square.h4)],
            );
        }
    }
}
fn genKnightAttacks() [@typeInfo(Square).Enum.fields.len]BoardType {
    var ret: [64]BoardType = [_]BoardType{0} ** 64;
    var bb: BitBoard = .{};
    for (std.enums.values(Square)) |square| {
        bb.board = 0;
        bb.set(square);
        // upward
        if (bb.board & Square.fileBits('a') == 0)
            ret[@enumToInt(square)] |= bb.board >> 17;
        if (bb.board & Square.fileBits('h') == 0)
            ret[@enumToInt(square)] |= bb.board >> 15;
        if (bb.board & (Square.fileBits('a') | Square.fileBits('b')) == 0)
            ret[@enumToInt(square)] |= bb.board >> 10;
        if (bb.board & (Square.fileBits('h') | Square.fileBits('g')) == 0)
            ret[@enumToInt(square)] |= bb.board >> 6;
        // downward
        if (bb.board & Square.fileBits('h') == 0)
            ret[@enumToInt(square)] |= bb.board << 17;
        if (bb.board & Square.fileBits('a') == 0)
            ret[@enumToInt(square)] |= bb.board << 15;
        if (bb.board & (Square.fileBits('h') | Square.fileBits('g')) == 0)
            ret[@enumToInt(square)] |= bb.board << 10;
        if (bb.board & (Square.fileBits('a') | Square.fileBits('b')) == 0)
            ret[@enumToInt(square)] |= bb.board << 6;
    }
    return ret;
}
test "KnightAttacks" {
    const ka = genKnightAttacks();
    { // full move
        var bb: BitBoard = .{};
        bb.set(.c7);
        bb.set(.e7);
        bb.set(.b6);
        bb.set(.f6);
        bb.set(.c3);
        bb.set(.e3);
        bb.set(.b4);
        bb.set(.f4);
        try std.testing.expectEqual(
            bb.board,
            ka[@enumToInt(Square.d5)],
        );
    }
    { // only 6 move
        var bb: BitBoard = .{};
        bb.set(.f7);
        bb.set(.h7);
        bb.set(.e6);
        bb.set(.e4);
        bb.set(.f3);
        bb.set(.h3);
        try std.testing.expectEqual(
            bb.board,
            ka[@enumToInt(Square.g5)],
        );
    }
    { // only 4 move
        var bb: BitBoard = .{};
        bb.set(.b7);
        bb.set(.c6);
        bb.set(.c4);
        bb.set(.b3);
        try std.testing.expectEqual(
            bb.board,
            ka[@enumToInt(Square.a5)],
        );
    }
}
fn genKingAttacks() [@typeInfo(Square).Enum.fields.len]BoardType {
    var ret: [64]BoardType = [_]BoardType{0} ** 64;
    var bb: BitBoard = .{};
    for (std.enums.values(Square)) |square| {
        bb.board = 0;
        bb.set(square);
        ret[@enumToInt(square)] |= bb.board >> 8;
        if (bb.board & Square.fileBits('h') == 0)
            ret[@enumToInt(square)] |= bb.board >> 7;
        if (bb.board & Square.fileBits('a') == 0)
            ret[@enumToInt(square)] |= (bb.board >> 9 | bb.board >> 1);
        ret[@enumToInt(square)] |= bb.board << 8;
        if (bb.board & Square.fileBits('a') == 0)
            ret[@enumToInt(square)] |= bb.board << 7;
        if (bb.board & Square.fileBits('h') == 0)
            ret[@enumToInt(square)] |= (bb.board << 9 | bb.board << 1);
    }
    return ret;
}
test "KingAttacks" {
    const ka = genKingAttacks();
    { // full move
        var bb: BitBoard = .{};
        bb.set(.c5);
        bb.set(.d5);
        bb.set(.e5);
        bb.set(.c3);
        bb.set(.d3);
        bb.set(.e3);
        bb.set(.c4);
        bb.set(.e4);
        try std.testing.expectEqual(
            bb.board,
            ka[@enumToInt(Square.d4)],
        );
    }
    { // sides - 5 moves
        var bb: BitBoard = .{};
        bb.set(.a5);
        bb.set(.a3);
        bb.set(.b5);
        bb.set(.b4);
        bb.set(.b3);
        try std.testing.expectEqual(
            bb.board,
            ka[@enumToInt(Square.a4)],
        );
    }
    { // sides - 5 moves
        var bb: BitBoard = .{};
        bb.set(.c8);
        bb.set(.e8);
        bb.set(.c7);
        bb.set(.d7);
        bb.set(.e7);
        try std.testing.expectEqual(
            bb.board,
            ka[@enumToInt(Square.d8)],
        );
    }
    { // corner - 3 moves
        var bb: BitBoard = .{};
        bb.set(.g1);
        bb.set(.g2);
        bb.set(.h2);
        try std.testing.expectEqual(
            bb.board,
            ka[@enumToInt(Square.h1)],
        );
    }
}
fn genBishopAttacks() [@typeInfo(Square).Enum.fields.len]BoardType {
    const moves = [_][2]i2{
        .{ -1, -1 },
        .{ -1, 1 },
        .{ 1, -1 },
        .{ 1, 1 },
    };
    var ret: [64]BoardType = [_]BoardType{0} ** 64;
    for (std.enums.values(Square)) |square| {
        const rank = @intCast(isize, SIZE - square.int() / SIZE);
        const file = @intCast(isize, square.int() % SIZE);
        var attacks: BoardType = 0;
        var step: i5 = 1;
        while (step < SIZE - 1) : (step += 1) {
            for (moves) |m| {
                const dr = rank + m[0] * step;
                const df = file + m[1] * step;
                if (dr < 2 or dr > 7) continue;
                if (df < 1 or df > 7) continue;
                const s = @intCast(u6, (SIZE - dr) * SIZE + df);
                attacks |= @intCast(BoardType, @as(BoardType, 1) << s);
            }
        }
        ret[@enumToInt(square)] = attacks;
    }
    return ret;
}
test "BishopAttacks" {
    const ba = genBishopAttacks();
    {
        var bb: BitBoard = .{};
        var set = [_]Square{ .b2, .c3, .d4, .e5, .f6, .g7 };
        bb.setSlice(&set);
        try std.testing.expectEqual(
            bb.board,
            ba[@enumToInt(Square.a1)],
        );
    }
}

File addition: attacks.zig (----------)

[5.15]

const std = @import("std");
const Chess = @import("Chess.zig");
fn genPawnAttacks() [@typeInfo(Chess.Colors).Enum.fields.len][@typeInfo(Chess.Square).Enum.fields.len]Chess.BoardType {
    var ret: [2][64]Chess.BoardType = [_][64]Chess.BoardType{[_]Chess.BoardType{0} ** 64} ** 2;
    for (std.enums.values(Chess.Colors)) |color| {
        for (std.enums.values(Chess.Square)) |square| {
            ret[@enumToInt(color)][@enumToInt(square)] = genSteps(square, .pawn, color);
        }
    }
    return ret;
}
test "PawnAttacks" {
    var bb: Chess.BitBoard = .{};
    const pa = genPawnAttacks();
    { // White
        {
            bb.board = 0;
            bb.setSlice(&[2]Chess.Square{ .c5, .e5 });
            try std.testing.expectEqual(
                bb.board,
                pa[@enumToInt(Chess.Colors.white)][@enumToInt(Chess.Square.d4)],
            );
        }
        {
            // no left attack
            bb.board = 0;
            bb.set(.b5);
            try std.testing.expectEqual(
                bb.board,
                pa[@enumToInt(Chess.Colors.white)][@enumToInt(Chess.Square.a4)],
            );
        }
        {
            // no right attack
            bb.board = 0;
            bb.set(.g5);
            try std.testing.expectEqual(
                bb.board,
                pa[@enumToInt(Chess.Colors.white)][@enumToInt(Chess.Square.h4)],
            );
        }
    }
    { // Black
        {
            bb.board = 0;
            bb.setSlice(&[2]Chess.Square{ .c3, .e3 });
            try std.testing.expectEqual(
                bb.board,
                pa[@enumToInt(Chess.Colors.black)][@enumToInt(Chess.Square.d4)],
            );
        }
        {
            // no left attack
            bb.board = 0;
            bb.set(.b3);
            try std.testing.expectEqual(
                bb.board,
                pa[@enumToInt(Chess.Colors.black)][@enumToInt(Chess.Square.a4)],
            );
        }
        {
            // no right attack
            bb.board = 0;
            bb.set(.g3);
            try std.testing.expectEqual(
                bb.board,
                pa[@enumToInt(Chess.Colors.black)][@enumToInt(Chess.Square.h4)],
            );
        }
    }
}
fn genKnightAttacks() [@typeInfo(Chess.Square).Enum.fields.len]Chess.BoardType {
    var ret: [64]Chess.BoardType = [_]Chess.BoardType{0} ** 64;
    for (std.enums.values(Chess.Square)) |square| {
        ret[@enumToInt(square)] = genSteps(square, .knight, .white);
    }
    return ret;
}
test "KnightAttacks" {
    var bb: Chess.BitBoard = .{};
    const ka = genKnightAttacks();
    { // full move
        bb.board = 0;
        bb.setSlice(&[8]Chess.Square{ .c7, .e7, .b6, .f6, .c3, .e3, .b4, .f4 });
        try std.testing.expectEqual(
            bb.board,
            ka[@enumToInt(Chess.Square.d5)],
        );
    }
    { // only 6 move
        bb.board = 0;
        bb.setSlice(&[6]Chess.Square{ .f7, .h7, .e6, .e4, .f3, .h3 });
        try std.testing.expectEqual(
            bb.board,
            ka[@enumToInt(Chess.Square.g5)],
        );
    }
    { // only 4 move
        bb.board = 0;
        bb.setSlice(&[4]Chess.Square{ .b7, .c6, .c4, .b3 });
        try std.testing.expectEqual(
            bb.board,
            ka[@enumToInt(Chess.Square.a5)],
        );
    }
}
fn genKingAttacks() [@typeInfo(Chess.Square).Enum.fields.len]Chess.BoardType {
    var ret: [64]Chess.BoardType = [_]Chess.BoardType{0} ** 64;
    for (std.enums.values(Chess.Square)) |square| {
        ret[@enumToInt(square)] = genSteps(square, .king, .white);
    }
    return ret;
}
test "KingAttacks" {
    var bb: Chess.BitBoard = .{};
    const ka = genKingAttacks();
    { // full move
        bb.board = 0;
        bb.setSlice(&[8]Chess.Square{ .c5, .d5, .e5, .c3, .d3, .e3, .c4, .e4 });
        try std.testing.expectEqual(
            bb.board,
            ka[@enumToInt(Chess.Square.d4)],
        );
    }
    { // sides - 5 moves
        bb.board = 0;
        bb.setSlice(&[5]Chess.Square{ .a5, .a3, .b5, .b4, .b3 });
        try std.testing.expectEqual(
            bb.board,
            ka[@enumToInt(Chess.Square.a4)],
        );
    }
    { // sides - 5 moves
        bb.board = 0;
        bb.setSlice(&[5]Chess.Square{ .c8, .e8, .c7, .d7, .e7 });
        try std.testing.expectEqual(
            bb.board,
            ka[@enumToInt(Chess.Square.d8)],
        );
    }
    { // corner - 3 moves
        bb.board = 0;
        bb.setSlice(&[3]Chess.Square{ .g1, .g2, .h2 });
        try std.testing.expectEqual(
            bb.board,
            ka[@enumToInt(Chess.Square.h1)],
        );
    }
}
fn genBishopAttacks() [@typeInfo(Chess.Square).Enum.fields.len]Chess.BoardType {
    var ret: [64]Chess.BoardType = [_]Chess.BoardType{0} ** 64;
    for (std.enums.values(Chess.Square)) |square| {
        ret[@enumToInt(square)] = genSteps(square, .bishop, .white);
    }
    return ret;
}
test "BishopAttacks" {
    const ba = genBishopAttacks();
    {
        var bb: Chess.BitBoard = .{};
        var set = [_]Chess.Square{ .b2, .c3, .d4, .e5, .f6, .g7 };
        bb.setSlice(&set);
        try std.testing.expectEqual(
            bb.board,
            ba[@enumToInt(Chess.Square.a1)],
        );
    }
}
fn genSteps(square: Chess.Square, piece: Chess.Figures, color: Chess.Colors) Chess.BoardType {
    const rank = @intCast(isize, square.rank());
    const file = @intCast(isize, square.file());
    const rider = switch (piece) {
        .pawn => false,
        .knight => false,
        .bishop => true,
        .king => false,
    };
    // TODO: I repeat some moves here to make zig happy, but ugly.
    const moves = switch (piece) {
        .pawn => switch (color) {
            .white => [_][2]i3{ .{ -1, -1 }, .{ -1, 1 }, .{ -1, -1 }, .{ -1, 1 }, .{ -1, -1 }, .{ -1, 1 }, .{ -1, -1 }, .{ -1, 1 } },
            .black => [_][2]i3{ .{ 1, -1 }, .{ 1, 1 }, .{ 1, -1 }, .{ 1, 1 }, .{ 1, -1 }, .{ 1, 1 }, .{ 1, -1 }, .{ 1, 1 } },
        },
        .knight => [_][2]i3{ .{ -2, -1 }, .{ -2, 1 }, .{ 2, -1 }, .{ 2, 1 }, .{ -1, -2 }, .{ 1, 2 }, .{ -1, 2 }, .{ 1, -2 } },
        .bishop => [_][2]i3{ .{ -1, -1 }, .{ -1, 1 }, .{ 1, -1 }, .{ 1, 1 }, .{ -1, -1 }, .{ -1, 1 }, .{ 1, -1 }, .{ 1, 1 } },
        .king => [_][2]i3{
            .{ -1, -1 },
            .{ -1, 1 },
            .{ 1, -1 },
            .{ 1, 1 },
            .{ -1, 0 },
            .{ 0, 1 },
            .{ 1, 0 },
            .{ 0, -1 },
        },
    };
    var attacks: Chess.BoardType = 0;
    var step: i5 = 1;
    while (step < Chess.SIZE - 1) : (step += 1) {
        for (moves) |m| {
            const dr = rank + m[0] * step;
            const df = file + m[1] * step;
            switch (rider) {
                true => {
                    if (dr < 1 or dr > 6) continue;
                    if (df < 1 or df > 6) continue;
                },
                false => {
                    if (dr < 0 or dr > 7) continue;
                    if (df < 0 or df > 7) continue;
                },
            }
            const s = @intCast(u6, dr * Chess.SIZE + df);
            attacks |= @intCast(Chess.BoardType, @as(Chess.BoardType, 1) << s);
        }
        if (!rider) break;
    }
    return attacks;
}

File addition: Chess.zig (----------)