voroskoi/pistike - Change CWEVCXXC3D5NLLIFIYEWTXHPLX4EU5XH3YUUTMV7GYBLSQXT5VPQC

Remove int() methods

Created by voroskoi on January 19, 2023

CWEVCXXC3D5NLLIFIYEWTXHPLX4EU5XH3YUUTMV7GYBLSQXT5VPQC

Dependencies

In channels

main

Change contents

Insertion in src/attacks.zig at line 35 [5.204]

[3.3024]

[4.3478]

            const square_int = @enumToInt(square);

Replacement in src/attacks.zig at line 37 [5.204]

B:BD[4.3527] → [4.3527:3633]

                .bishop => bishop_masks[square.int()],
                .rook => rook_masks[square.int()],

[4.3527]

[4.3633]

                .bishop => bishop_masks[square_int],
                .rook => rook_masks[square_int],

Replacement in src/attacks.zig at line 52 [5.204]

B:BD[4.4127] → [2.0:96]

                        const res = @mulWithOverflow(occupancy, bishop_magic[square.int()])[0];

[4.4127]

[4.4297]

                        const res = @mulWithOverflow(occupancy, bishop_magic[square_int])[0];

Replacement in src/attacks.zig at line 54 [5.204]

B:BD[4.4348] → [3.3301:3407]

                            @intCast(Board.SquareType, @as(u7, 64) - bishop_relevant_bits[square.int()]);

[4.4348]

[4.4440]

                            @intCast(Board.SquareType, @as(u7, 64) - bishop_relevant_bits[square_int]);

Replacement in src/attacks.zig at line 56 [5.204]

B:BD[4.4441] → [4.4441:4509]

                        bishop_attacks[square.int()][magic_index] =

[4.4441]

[4.4509]

                        bishop_attacks[square_int][magic_index] =

Replacement in src/attacks.zig at line 61 [5.204]

B:BD[4.4727] → [2.97:191]

                        const res = @mulWithOverflow(occupancy, rook_magic[square.int()])[0];

[4.4727]

[4.4895]

                        const res = @mulWithOverflow(occupancy, rook_magic[@enumToInt(square)])[0];

Replacement in src/attacks.zig at line 63 [5.204]

B:BD[4.4946] → [3.3577:3681]

                            @intCast(Board.SquareType, @as(u7, 64) - rook_relevant_bits[square.int()]);

[4.4946]

[4.5036]

                            @intCast(Board.SquareType, @as(u7, 64) - rook_relevant_bits[square_int]);

Replacement in src/attacks.zig at line 65 [5.204]

B:BD[4.5037] → [4.5037:5103]

                        rook_attacks[square.int()][magic_index] =

[4.5037]

[4.5103]

                        rook_attacks[square_int][magic_index] =

Replacement in src/attacks.zig at line 74 [5.204]

B:BD[4.5289] → [6.0:112]

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

[4.5289]

[4.5396]

    pub fn getBishopAttacks(self: @This(), square: Board.SquareType, occupancy: Board.BoardType) *Board.BoardType {

Replacement in src/attacks.zig at line 78 [5.204]

B:BD[4.5471] → [4.5471:5524]

B:BD[4.5524] → [2.192:280]

        mut_occupancy &= bishop_masks[square.int()];
        mut_occupancy = @mulWithOverflow(mut_occupancy, bishop_magic[square.int()])[0];

[4.5471]

[2.280]

        mut_occupancy &= bishop_masks[square];
        mut_occupancy = @mulWithOverflow(mut_occupancy, bishop_magic[square])[0];

Replacement in src/attacks.zig at line 81 [5.204]

B:BD[2.347] → [2.347:396]

            bishop_relevant_bits[square.int()]);

[2.347]

[4.5667]

            bishop_relevant_bits[square]);

Replacement in src/attacks.zig at line 83 [5.204]

B:BD[4.5668] → [6.113:174]

        return &bishop_attacks[square.int()][mut_occupancy];

[4.5668]

[4.5728]

        return &bishop_attacks[square][mut_occupancy];

Replacement in src/attacks.zig at line 86 [5.204]

B:BD[4.5735] → [6.175:285]

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

[4.5735]

[4.5840]

    pub fn getRookAttacks(self: @This(), square: Board.SquareType, occupancy: Board.BoardType) *Board.BoardType {

Replacement in src/attacks.zig at line 90 [5.204]

B:BD[4.5915] → [4.5915:5966]

B:BD[4.5966] → [2.397:483]

        mut_occupancy &= rook_masks[square.int()];
        mut_occupancy = @mulWithOverflow(mut_occupancy, rook_magic[square.int()])[0];

[4.5915]

[2.483]

        mut_occupancy &= rook_masks[square];
        mut_occupancy = @mulWithOverflow(mut_occupancy, rook_magic[square])[0];

Replacement in src/attacks.zig at line 93 [5.204]

B:BD[2.550] → [2.550:597]

            rook_relevant_bits[square.int()]);

[2.550]

[4.6105]

            rook_relevant_bits[square]);

Replacement in src/attacks.zig at line 95 [5.204]

B:BD[4.6106] → [6.286:345]

        return &rook_attacks[square.int()][mut_occupancy];

[4.6106]

[7.287]

        return &rook_attacks[square][mut_occupancy];

Replacement in src/attacks.zig at line 98 [5.204]

B:BD[7.294] → [3.4436:4546]

    pub fn getQueenAttacks(self: @This(), square: Board.Square, occupancy: Board.BoardType) Board.BoardType {

[7.294]

[2.598]

    pub fn getQueenAttacks(self: @This(), square: Board.SquareType, occupancy: Board.BoardType) Board.BoardType {

Replacement in src/attacks.zig at line 110 [5.204]

B:BD[7.667] → [3.4650:4733]

    const got = attack.getQueenAttacks(.d4, @bitCast(Board.BoardType, occupancy));

[7.667]

[7.750]

    const got = attack.getQueenAttacks(
        @enumToInt(Board.Square.d4),
        @bitCast(Board.BoardType, occupancy),
    );

Replacement in src/attacks.zig at line 626 [5.204]

B:BD[8.5303] → [8.5303:5360]

            genRelevantOccupancy(.bishop)[square.int()],

[8.5303]

[8.5360]

            genRelevantOccupancy(.bishop)[@enumToInt(square)],

Replacement in src/attacks.zig at line 643 [5.204]

B:BD[8.5455] → [8.5455:5510]

            genRelevantOccupancy(.rook)[square.int()],

[8.5455]

[8.5510]

            genRelevantOccupancy(.rook)[@enumToInt(square)],

Deletion in src/Chess.zig at line 40 [5.7502]
∅:D[9.36] → [10.748:749]
B:BD[10.748] → [10.748:749]
B:BD[10.749] → [3.15792:15827]
∅:D[3.15827] → [10.780:819]
B:BD[10.780] → [10.780:819]
```
    pub fn int(self: @This()) u4 {
        return @enumToInt(self);
    }
```

Deletion in src/Board.zig at line 25 [3.16071]

B:BD[3.16676] → [3.16676:16781]

    pub fn int(self: @This()) SquareType {
        return @intCast(SquareType, @enumToInt(self));
    }

Replacement in src/Board.zig at line 26 [3.16071]

B:BD[3.16817] → [3.16817:16865]

        return @intCast(u3, self.int() / SIZE);

[3.16817]

[3.16865]

        return @intCast(u3, @enumToInt(self) / SIZE);

Replacement in src/Board.zig at line 30 [3.16071]

B:BD[3.16908] → [3.16908:16956]

        return @intCast(u3, self.int() % SIZE);

[3.16908]

[3.16956]

        return @intCast(u3, @enumToInt(self) % SIZE);

Replacement in src/Board.zig at line 56 [3.16071]

B:BD[3.18416] → [3.18416:18470]

            ret |= @as(BoardType, 1) << square.int();

[3.18416]

[3.18470]

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

Replacement in src/Board.zig at line 242 [3.16071]
B:BD[3.21762] → [3.21762:21806]
```
    fn occupBoth(self: @This()) BoardType {
```
[3.21762]
[11.489]
```
    pub fn occupBoth(self: @This()) BoardType {
```

Replacement in src/Board.zig at line 432 [3.16071]

B:BD[3.24102] → [12.1149:1611]

                        '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),

[3.24102]

[3.24636]

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

Replacement in src/Board.zig at line 445 [3.16071]

B:BD[3.24938] → [12.1688:2150]

                        '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),

[3.24938]

[3.25472]

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

Replacement in src/Board.zig at line 505 [3.16071]

B:BD[3.27091] → [13.1611:1701]

    fn isSquareAttacked(self: *const @This(), square: Square, color: Chess.Colors) bool {

[3.27091]

[3.27174]

    pub fn isSquareAttacked(self: *const @This(), square: SquareType, color: Chess.Colors) bool {

Replacement in src/Board.zig at line 509 [3.16071]

B:BD[3.27266] → [3.27266:27464]

                const pa = self.attacks.pawn_attacks[@enumToInt(Chess.Colors.black)][square.int()];
                if (pa & @bitCast(BoardType, self.bitboards[Chess.PE.P.int()]) != 0) return true;

[3.27266]

[3.27464]

                const pa = self.attacks.pawn_attacks[@enumToInt(Chess.Colors.black)][square];
                if (pa & @bitCast(BoardType, self.bitboards[@enumToInt(Chess.PE.P)]) != 0) return true;

Replacement in src/Board.zig at line 513 [3.16071]

B:BD[3.27503] → [3.27503:27701]

                const pa = self.attacks.pawn_attacks[@enumToInt(Chess.Colors.white)][square.int()];
                if (pa & @bitCast(BoardType, self.bitboards[Chess.PE.p.int()]) != 0) return true;

[3.27503]

[3.27701]

                const pa = self.attacks.pawn_attacks[@enumToInt(Chess.Colors.white)][square];
                if (pa & @bitCast(BoardType, self.bitboards[@enumToInt(Chess.PE.p)]) != 0) return true;

Replacement in src/Board.zig at line 519 [3.16071]

B:BD[3.27757] → [3.27757:27819]

        const na = self.attacks.knight_attacks[square.int()];

[3.27757]

[3.27819]

        const na = self.attacks.knight_attacks[square];

Replacement in src/Board.zig at line 521 [3.16071]

B:BD[3.27856] → [3.27856:27968]

            .white => self.bitboards[Chess.PE.N.int()],
            .black => self.bitboards[Chess.PE.n.int()],

[3.27856]

[3.27968]

            .white => self.bitboards[@enumToInt(Chess.PE.N)],
            .black => self.bitboards[@enumToInt(Chess.PE.n)],

Replacement in src/Board.zig at line 527 [3.16071]

B:BD[3.28069] → [3.28069:28129]

        const ka = self.attacks.king_attacks[square.int()];

[3.28069]

[3.28129]

        const ka = self.attacks.king_attacks[square];

Replacement in src/Board.zig at line 529 [3.16071]

B:BD[3.28166] → [3.28166:28278]

            .white => self.bitboards[Chess.PE.K.int()],
            .black => self.bitboards[Chess.PE.k.int()],

[3.28166]

[3.28278]

            .white => self.bitboards[@enumToInt(Chess.PE.K)],
            .black => self.bitboards[@enumToInt(Chess.PE.k)],

Replacement in src/Board.zig at line 537 [3.16071]

B:BD[3.28494] → [3.28494:28606]

            .white => self.bitboards[Chess.PE.B.int()],
            .black => self.bitboards[Chess.PE.b.int()],

[3.28494]

[3.28606]

            .white => self.bitboards[@enumToInt(Chess.PE.B)],
            .black => self.bitboards[@enumToInt(Chess.PE.b)],

Replacement in src/Board.zig at line 545 [3.16071]

B:BD[3.28818] → [3.28818:28930]

            .white => self.bitboards[Chess.PE.R.int()],
            .black => self.bitboards[Chess.PE.r.int()],

[3.28818]

[3.28930]

            .white => self.bitboards[@enumToInt(Chess.PE.R)],
            .black => self.bitboards[@enumToInt(Chess.PE.r)],

Replacement in src/Board.zig at line 552 [3.16071]

B:BD[3.29144] → [3.29144:29256]

            .white => self.bitboards[Chess.PE.Q.int()],
            .black => self.bitboards[Chess.PE.q.int()],

[3.29144]

[3.29256]

            .white => self.bitboards[@enumToInt(Chess.PE.Q)],
            .black => self.bitboards[@enumToInt(Chess.PE.q)],

Replacement in src/Board.zig at line 563 [3.16071]

B:BD[3.29507] → [3.29507:29604]

            if (isSquareAttacked(self, square, color)) ret |= @as(BoardType, 1) << square.int();

[3.29507]

[3.29604]

            if (isSquareAttacked(self, @enumToInt(square), color)) {
                ret |= @as(BoardType, 1) << @enumToInt(square);
            }

Replacement in src/Board.zig at line 577 [3.16071]

B:BD[3.29897] → [3.29897:29973]

            const board = @bitCast(BoardType, self.bitboards[piece.int()]);

[3.29897]

[3.29973]

            const board = @bitCast(BoardType, self.bitboards[@enumToInt(piece)]);

Replacement in src/Board.zig at line 705 [3.16071]

B:BD[3.35275] → [3.35275:35340]

                    @as(BoardType, 1) << self.enpassant.?.int();

[3.35275]

[3.35340]

                    @as(BoardType, 1) << @enumToInt(self.enpassant.?);

Replacement in src/Board.zig at line 741 [3.16071]

B:BD[3.36623] → [3.36623:36728]

                        if (self.occupBoth() & @as(BoardType, 1) << square.int() != 0) break :blk false;

[3.36623]

[3.36728]

                        if (self.occupBoth() & @as(BoardType, 1) << @enumToInt(square) != 0) break :blk false;

Replacement in src/Board.zig at line 746 [3.16071]

B:BD[3.36870] → [14.4081:4177]

                        if (self.isSquareAttacked(square, self.side.enemy())) break :blk false;

[3.36870]

[3.36959]

                        if (self.isSquareAttacked(@enumToInt(square), self.side.enemy())) break :blk false;

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

B:BD[3.37973] → [3.37973:38078]

                        if (self.occupBoth() & @as(BoardType, 1) << square.int() != 0) break :blk false;

[3.37973]

[3.38078]

                        if (self.occupBoth() & @as(BoardType, 1) << @enumToInt(square) != 0) break :blk false;

Replacement in src/Board.zig at line 784 [3.16071]

B:BD[3.38221] → [14.4222:4318]

                        if (self.isSquareAttacked(square, self.side.enemy())) break :blk false;

[3.38221]

[3.38310]

                        if (self.isSquareAttacked(@enumToInt(square), self.side.enemy())) break :blk false;

Replacement in src/Board.zig at line 814 [3.16071]

B:BD[3.39217] → [3.39217:39367]

B:BD[3.39367] → [6.652:673]

∅:D[6.673] → [3.39386:39534]

B:BD[3.39386] → [3.39386:39534]

B:BD[3.39534] → [6.674:695]

∅:D[6.695] → [3.39553:39721]

B:BD[3.39553] → [3.39553:39721]

                .B, .b => self.attacks.getBishopAttacks(
                    @intToEnum(Square, source_square),
                    self.occupBoth(),
                ).*,
                .R, .r => self.attacks.getRookAttacks(
                    @intToEnum(Square, source_square),
                    self.occupBoth(),
                ).*,
                .Q, .q => self.attacks.getQueenAttacks(
                    @intToEnum(Square, source_square),
                    self.occupBoth(),
                ),

[3.39217]

[3.39721]

                .B, .b => self.attacks.getBishopAttacks(source_square, self.occupBoth()).*,
                .R, .r => self.attacks.getRookAttacks(source_square, self.occupBoth()).*,
                .Q, .q => self.attacks.getQueenAttacks(source_square, self.occupBoth()),

Replacement in src/Board.zig at line 863 [3.16071]

B:BD[12.2434] → [12.2434:2568]

                self.bitboards[move.piece.int()].pop(move.source);
                self.bitboards[move.piece.int()].set(move.target);

[12.2434]

[12.2568]

                self.bitboards[@enumToInt(move.piece)].pop(move.source);
                self.bitboards[@enumToInt(move.piece)].set(move.target);

Replacement in src/Board.zig at line 895 [3.16071]

B:BD[15.1633] → [15.1633:1793]

                            if (self.bitboards[piece.int()].isSet(move.target)) {
                                self.bitboards[piece.int()].pop(move.target);

[15.1633]

[15.1793]

                            if (self.bitboards[@enumToInt(piece)].isSet(move.target)) {
                                self.bitboards[@enumToInt(piece)].pop(move.target);

Replacement in src/Board.zig at line 907 [3.16071]

B:BD[15.2057] → [15.2057:2132]

                        self.bitboards[move.piece.int()].pop(move.target);

[15.2057]

[15.2132]

                        self.bitboards[@enumToInt(move.piece)].pop(move.target);

Replacement in src/Board.zig at line 909 [3.16071]

B:BD[15.2193] → [15.2193:2267]

                        self.bitboards[move.prom.int()].set(move.target);

[15.2193]

[15.2267]

                        self.bitboards[@enumToInt(move.prom)].set(move.target);

Replacement in src/Board.zig at line 915 [3.16071]

B:BD[15.2419] → [15.2419:2490]

                            .white => self.bitboards[Chess.PE.p.int()]

[15.2419]

[15.2490]

                            .white => self.bitboards[@enumToInt(Chess.PE.p)]

Replacement in src/Board.zig at line 917 [3.16071]

B:BD[15.2577] → [15.2577:2648]

                            .black => self.bitboards[Chess.PE.P.int()]

[15.2577]

[15.2648]

                            .black => self.bitboards[@enumToInt(Chess.PE.P)]

Replacement in src/Board.zig at line 939 [3.16071]

B:BD[16.1525] → [16.1525:1687]

                                self.bitboards[Chess.PE.R.int()].pop(Square.h1);
                                self.bitboards[Chess.PE.R.int()].set(Square.f1);

[16.1525]

[14.6185]

                                self.bitboards[@enumToInt(Chess.PE.R)].pop(Square.h1);
                                self.bitboards[@enumToInt(Chess.PE.R)].set(Square.f1);

Replacement in src/Board.zig at line 945 [3.16071]

B:BD[16.1755] → [16.1755:1917]

                                self.bitboards[Chess.PE.R.int()].pop(Square.a1);
                                self.bitboards[Chess.PE.R.int()].set(Square.d1);

[16.1755]

[14.6386]

                                self.bitboards[@enumToInt(Chess.PE.R)].pop(Square.a1);
                                self.bitboards[@enumToInt(Chess.PE.R)].set(Square.d1);

Replacement in src/Board.zig at line 951 [3.16071]

B:BD[16.1985] → [16.1985:2147]

                                self.bitboards[Chess.PE.r.int()].pop(Square.h8);
                                self.bitboards[Chess.PE.r.int()].set(Square.f8);

[16.1985]

[14.6587]

                                self.bitboards[@enumToInt(Chess.PE.r)].pop(Square.h8);
                                self.bitboards[@enumToInt(Chess.PE.r)].set(Square.f8);

Replacement in src/Board.zig at line 957 [3.16071]

B:BD[16.2215] → [16.2215:2377]

                                self.bitboards[Chess.PE.r.int()].pop(Square.a8);
                                self.bitboards[Chess.PE.r.int()].set(Square.d8);

[16.2215]

[14.6788]

                                self.bitboards[@enumToInt(Chess.PE.r)].pop(Square.a8);
                                self.bitboards[@enumToInt(Chess.PE.r)].set(Square.d8);

Replacement in src/Board.zig at line 975 [3.16071]

B:BD[15.3500] → [15.3500:3583]

                        white |= @bitCast(BoardType, self.bitboards[piece.int()]);

[15.3500]

[15.3583]

                        white |= @bitCast(BoardType, self.bitboards[@enumToInt(piece)]);

Replacement in src/Board.zig at line 978 [3.16071]

B:BD[15.3679] → [15.3679:3762]

                        black |= @bitCast(BoardType, self.bitboards[piece.int()]);

[15.3679]

[14.7745]

                        black |= @bitCast(BoardType, self.bitboards[@enumToInt(piece)]);

Replacement in src/Board.zig at line 988 [3.16071]

B:BD[17.369] → [17.369:452]

                            @bitCast(BoardType, self.bitboards[Chess.PE.K.int()]),

[17.369]

[17.452]

                            @bitCast(BoardType, self.bitboards[@enumToInt(Chess.PE.K)]),

Replacement in src/Board.zig at line 991 [3.16071]

B:BD[17.539] → [17.539:622]

                            @bitCast(BoardType, self.bitboards[Chess.PE.k.int()]),

[17.539]

[17.622]

                            @bitCast(BoardType, self.bitboards[@enumToInt(Chess.PE.k)]),

Replacement in src/Board.zig at line 995 [3.16071]

B:BD[14.7844] → [14.7844:7925]

                    if (self.isSquareAttacked(king_square, self.side.enemy())) {

[14.7844]

[17.747]

                    if (self.isSquareAttacked(@enumToInt(king_square), self.side.enemy())) {

Replacement in src/Board.zig at line 1036 [3.16071]

B:BD[3.41668] → [3.41668:41714]

    gs.bitboards[Chess.PE.P.int()].b8 = true;

[3.41668]

[3.41714]

    gs.bitboards[@enumToInt(Chess.PE.P)].b8 = true;

Replacement in src/Board.zig at line 1043 [3.16071]

B:BD[3.41810] → [3.41810:41885]

    try std.testing.expectEqual(false, gs.bitboards[Chess.PE.P.int()].h8);

[3.41810]

[3.41885]

    try std.testing.expectEqual(false, gs.bitboards[@enumToInt(Chess.PE.P)].h8);