const Attacks = struct {

pub const Attacks = struct {

    fn getBishopAttacks(self: @This(), square: Chess.Square, occupancy: Chess.BoardType) Chess.BoardType {

    pub fn getBishopAttacks(self: @This(), square: Chess.Square, occupancy: Chess.BoardType) Chess.BoardType {

    fn getRookAttacks(self: @This(), square: Chess.Square, occupancy: Chess.BoardType) Chess.BoardType {

    pub fn getRookAttacks(self: @This(), square: Chess.Square, occupancy: Chess.BoardType) Chess.BoardType {

test "Attack Struct" {
    const a = Attacks.init();
    const occupancy = 0;
    var bb: Chess.BitBoard = .{};
    bb.board = a.getBishopAttacks(.d4, occupancy);
    bb.show();
    bb.board = a.getRookAttacks(.d4, occupancy);
    bb.show();
}

        .queen => unreachable,

        .queen => unreachable,

const Attacks = @import("attacks.zig");

const Attacks = @import("attacks.zig").Attacks;

    queen,

};
// 8  ♜ ♞ ♝ ♛ ♚ ♝ ♞ ♜
// 7  ♟︎ ♟︎ ♟︎ ♟︎ ♟︎ ♟︎ ♟︎ ♟︎
// 6  . . . . . . . .
// 5  . . . . . . . .
// 4  . . . . . . . .
// 3  . . . . . . . .
// 2  ♙ ♙ ♙ ♙ ♙ ♙ ♙ ♙
// 1  ♖ ♘ ♗ ♕ ♔ ♗ ♘ ♖
const PE = enum {
    P,
    N,
    B,
    R,
    Q,
    K,
    p,
    n,
    b,
    r,
    q,
    k,
    fn int(self: @This()) u4 {
        return @enumToInt(self);
    }
    fn char(self: @This()) u8 {
        return switch (self) {
            .P => 'P',
            .N => 'N',
            .B => 'B',
            .R => 'R',
            .Q => 'Q',
            .K => 'K',
            .p => 'p',
            .n => 'n',
            .b => 'b',
            .r => 'r',
            .q => 'q',
            .k => 'k',
        };
    }

    }
    pub fn fileBits(fle: u8) BoardType {
        const offset = fle - '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;

    pub fn rankBits(rnk: u6) BoardType {
        var ret: BoardType = 0;
        std.debug.assert(rnk > 0 and rnk <= SIZE);
        var idx: u6 = 0;
        while (idx < SIZE) : (idx += 1) {
            ret += @as(BoardType, 1) << idx + (SIZE - rnk) * SIZE;
        }
        return ret;
    }

    pub fn show(self: @This()) void {

    fn show(self: @This()) void {

const Game = struct {
    bitboards: [12]BitBoard = blk: {
        var bbs: [12]BitBoard = undefined;
        for (bbs) |*bb| {
            bb.* = BitBoard{};
        }
        break :blk bbs;
    },
    attacks: Attacks,
    fn reset(self: *@This()) void {
        for (self.bitboards) |*bb| {
            bb.board = 0;
        }
    }
    fn init(self: *@This()) void {
        // 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()].set(.d1);
        // white king
        self.bitboards[PE.K.int()].set(.e1);
        // 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()].set(.d8);
        // black king
        self.bitboards[PE.k.int()].set(.e8);
    }
    fn show(self: @This()) void {
        std.debug.print("\n", .{});
        var rank: usize = 0;
        while (rank < SIZE) : (rank += 1) {
            var file: usize = 0;
            FILE: while (file < SIZE) : (file += 1) {
                if (file == 0) std.debug.print("{d}| ", .{SIZE - rank});
                const square = @intCast(u6, rank * SIZE + file);
                for (self.bitboards) |bb, idx| {
                    if (bb.board & (@as(BoardType, 1) << square) != 0) {
                        std.debug.print("{c} ", .{@intToEnum(PE, idx).char()});
                        continue :FILE;
                    }
                }
                std.debug.print(". ", .{});
            }
            std.debug.print("\n", .{});
        }
        std.debug.print("{s:>18}\n", .{"---------------"});
        std.debug.print("{s:>18}\n", .{"a b c d e f g h"});
    }
};
test "Game" {
    var game = Game{ .attacks = Attacks.init() };
    game.init();
    game.show();
}