voroskoi/pistike - Change FRUDIRWXGFOZERET3DNUNAZ5HSA3G32JZX6WMIXNGZOACTTCRIQAC

Use PriorityQueue as a MoveList, start scoring moves

Created by voroskoi on January 22, 2023

FRUDIRWXGFOZERET3DNUNAZ5HSA3G32JZX6WMIXNGZOACTTCRIQAC

Dependencies

In channels

main

Change contents

Replacement in src/uci.zig at line 68 [4.32]

B:BD[4.2206] → [4.2206:2241]

    var ml = try MoveList.init(0);

[4.2206]

[4.2241]

    var ml = MoveList.init(gs.allocator, {});
    defer ml.deinit();

Replacement in src/uci.zig at line 72 [4.32]

B:BD[4.2273] → [4.2273:2413]

    for (ml.slice()) |ml_move| {
        if (move.source == ml_move.source and move.target == ml_move.target) {
            move = ml_move;

[4.2273]

[4.2413]

    while (ml.removeOrNull()) |mp| {
        if (move.source == mp.move.source and move.target == mp.move.target) {
            move = mp.move;

Replacement in src/uci.zig at line 102 [4.32]

B:BD[4.3245] → [4.3245:3339]

    var gs = try GameState.init("rnbq1k1r/pp1Pbppp/2p5/8/2B5/8/PPP1NnPP/RNBQK2R w KQ - 1 8");

[4.3245]

[4.3339]

    var gs = try GameState.init(
        std.testing.allocator,
        "rnbq1k1r/pp1Pbppp/2p5/8/2B5/8/PPP1NnPP/RNBQK2R w KQ - 1 8",
    );

Replacement in src/uci.zig at line 131 [4.32]

B:BD[4.3953] → [4.3953:3992]

    var gs = try GameState.init(null);

[4.3953]

[4.3992]

    var gs = try GameState.init(std.testing.allocator, null);

Deletion in src/search.zig at line 34 [5.35]
B:BD[5.1109] → [5.1109:1112]
B:BD[5.1112] → [4.4502:4520]
∅:D[4.4520] → [5.1136:1190]
B:BD[5.1136] → [5.1136:1190]
B:BD[5.1190] → [4.4521:4570]
```
}
test "bestMove" {
    var gs = try GameState.init(null);
    gs.show();
    std.debug.print("{s}", .{bestMove(&gs, 4)});
```

Replacement in src/search.zig at line 54 [5.35]

B:BD[5.1885] → [5.1885:1920]

    var ml = try MoveList.init(0);

[5.1885]

[5.1920]

    var ml = MoveList.init(gs.allocator, {});
    defer ml.deinit();

Replacement in src/search.zig at line 58 [5.35]
B:BD[5.1952] → [5.1952:1987]
```
    for (ml.slice()) |move, idx| {
```
[5.1952]
[5.1987]
```
    while (ml.removeOrNull()) |mp| {
```

Replacement in src/search.zig at line 63 [5.35]

B:BD[5.2074] → [5.2074:2114]

        if (!gs.makeMove(move, .all)) {

[5.2074]

[5.2114]

        if (!gs.makeMove(mp.move, .all)) {

Replacement in src/search.zig at line 89 [5.35]

B:BD[5.2673] → [5.2673:2715]

                best_sofar = ml.get(idx);

[5.2673]

[5.2715]

                best_sofar = mp.move;

Replacement in src/search.zig at line 120 [5.35]

B:BD[3.149] → [3.149:191]

    const evaluation = nnue.evaluate(gs);

[3.149]

[5.3464]

    const evaluation = eval.evaluate(gs);

Replacement in src/search.zig at line 134 [5.35]

B:BD[5.3720] → [5.3720:3755]

    var ml = try MoveList.init(0);

[5.3720]

[5.3755]

    var ml = MoveList.init(gs.allocator, {});
    defer ml.deinit();

Replacement in src/search.zig at line 138 [5.35]
B:BD[5.3787] → [5.3787:3817]
```
    for (ml.slice()) |move| {
```
[5.3787]
[5.3817]
```
    while (ml.removeOrNull()) |mp| {
```

Replacement in src/search.zig at line 143 [5.35]

B:BD[5.3904] → [5.3904:3949]

        if (!gs.makeMove(move, .captures)) {

[5.3904]

[5.3949]

        if (!gs.makeMove(mp.move, .captures)) {

Insertion in src/search.zig at line 170 [5.35]

[5.4485]


test "bestMove" {
    var gs = try GameState.init(std.testing.allocator, null);
    gs.show();
    std.debug.print("{s}", .{bestMove(&gs, 4)});
}

Replacement in src/nnue.zig at line 104 [6.33]

B:BD[2.118] → [2.118:166]

        var gs = try Board.GameState.init(fen);

[2.118]

[2.166]

        var gs = try Board.GameState.init(std.testing.allocator, fen);

Replacement in src/nnue.zig at line 109 [6.33]

B:BD[2.359] → [2.359:407]

        var gs = try Board.GameState.init(fen);

[2.359]

[2.407]

        var gs = try Board.GameState.init(std.testing.allocator, fen);

Replacement in src/nnue.zig at line 114 [6.33]

B:BD[2.573] → [2.573:621]

        var gs = try Board.GameState.init(fen);

[2.573]

[2.621]

        var gs = try Board.GameState.init(std.testing.allocator, fen);

Replacement in src/nnue.zig at line 119 [6.33]

B:BD[2.814] → [2.814:862]

        var gs = try Board.GameState.init(fen);

[2.814]

[2.862]

        var gs = try Board.GameState.init(std.testing.allocator, fen);

Replacement in src/main.zig at line 7 [7.50]
B:BD[7.80] → [3.372:391]
```
var debug = false;
```
[7.80]
[3.391]
```
var debug = true;
```

Insertion in src/main.zig at line 10 [7.50]

[7.102]

[3.393]

    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();

Replacement in src/main.zig at line 14 [7.50]

B:BD[3.410] → [3.410:525]

        var gs = try Board.GameState.init("r2q1rk1/ppp2ppp/2n1bn2/2b1p3/3pP3/3P1NPP/PPP1NPB1/R1BQ1RK1 b - - 0 9");

[3.410]

[3.525]

        var gs = try Board.GameState.init(
            arena.allocator(),
            "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq -",
        );

Replacement in src/main.zig at line 19 [7.50]

B:BD[3.544] → [3.544:634]

        std.debug.print("{s}\n", .{search.bestMove(&gs, 3)});
    } else try handleUCI();

[3.544]

[8.754]


        var moves = Board.MoveList.init(arena.allocator(), {});
        defer moves.deinit();
        try gs.generateMoves(&moves);
        while (moves.removeOrNull()) |mp| {
            mp.move.show();
            std.debug.print("{d}\n", .{mp.score});
        }
    } else try handleUCI(arena.allocator());

Replacement in src/main.zig at line 31 [7.50]

B:BD[9.1822] → [8.757:825]

fn handleUCI() !void {
    var gs = try Board.GameState.init(null);

[9.1822]

[9.1889]

fn handleUCI(allocator: std.mem.Allocator) !void {
    var gs = try Board.GameState.init(allocator, null);

Replacement in src/eval.zig at line 143 [10.33]

B:BD[6.4960] → [6.4960:5063]

        var gs = try Board.GameState.init("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNB1KBNR w KQkq - 0 1");

[6.4960]

[6.5063]

        var gs = try Board.GameState.init(
            std.testing.allocator,
            "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNB1KBNR w KQkq - 0 1",
        );

Replacement in src/eval.zig at line 152 [10.33]

B:BD[6.5194] → [6.5194:5297]

        var gs = try Board.GameState.init("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNB1KBNR b KQkq - 0 1");

[6.5194]

[6.5297]

        var gs = try Board.GameState.init(
            std.testing.allocator,
            "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNB1KBNR b KQkq - 0 1",
        );

Replacement in src/eval.zig at line 161 [10.33]

B:BD[6.5397] → [6.5397:5502]

        var gs = try Board.GameState.init("rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR w KQkq - 0 1");

[6.5397]

[6.5502]

        var gs = try Board.GameState.init(
            std.testing.allocator,
            "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR w KQkq - 0 1",
        );

Replacement in src/eval.zig at line 170 [10.33]

B:BD[6.5612] → [6.5612:5721]

        var gs = try Board.GameState.init("rnbqkbnr/pppp1ppp/8/4p3/4P3/5N2/PPPP1PPP/RNBQKB1R w KQkq - 0 1");

[6.5612]

[6.5721]

        var gs = try Board.GameState.init(
            std.testing.allocator,
            "rnbqkbnr/pppp1ppp/8/4p3/4P3/5N2/PPPP1PPP/RNBQKB1R w KQkq - 0 1",
        );

Deletion in src/Chess.zig at line 59 [13.7502]

∅:D[11.4940] → [12.3299:3300]

∅:D[14.6832] → [12.3299:3300]

∅:D[15.7214] → [12.3299:3300]

B:BD[12.3299] → [12.3299:3300]

B:BD[12.3318] → [15.7233:7255]

B:BD[15.7255] → [16.15828:15899]

∅:D[16.15899] → [15.7314:7403]

B:BD[15.7314] → [15.7314:7403]

B:BD[15.7403] → [16.15900:15967]

B:BD[16.15967] → [16.15967:16036]

∅:D[16.16036] → [15.7527:7720]

B:BD[15.7527] → [15.7527:7720]

∅:D[14.6859] → [12.3353:3355]

∅:D[15.7720] → [12.3353:3355]

B:BD[12.3353] → [12.3353:3355]


const Game = struct {
    state: Board.GameState,
    history: std.ArrayList(Board.BitMove),
    fn init(allocator: std.mem.Allocator) @This() {
        var game: Game = undefined;
        game.state = Board.GameState.init(null) catch unreachable;
        game.history = std.ArrayList(Board.BitMove).init(allocator);
        return game;
    }
    fn deinit(self: @This()) void {
        self.history.deinit();
    }
};
test "Game" {
    var game = Game.init(std.testing.allocator);
    defer game.deinit();
}

Replacement in src/Board.zig at line 60 [16.16071]

B:BD[17.142] → [17.142:188]

    fn isSet(self: @This(), s: Square) bool {

[17.142]

[17.188]

    pub fn isSet(self: @This(), s: Square) bool {

Insertion in src/Board.zig at line 103 [16.16071]

[17.535]

};
const MovePrio = struct {
    move: BitMove,
    score: isize,
    fn moreThan(context: void, a: @This(), b: @This()) std.math.Order {
        _ = context;
        if (a.score == b.score)
            return .eq
        else if (a.score > b.score)
            return .lt
        else
            return .gt;
    }

Insertion in src/Board.zig at line 119 [16.16071]

[17.538]


pub const MoveList = std.PriorityQueue(MovePrio, void, MovePrio.moreThan);

Deletion in src/Board.zig at line 188 [16.16071]
B:BD[9.2856] → [8.857:910]
∅:D[8.910] → [16.19872:19873]
∅:D[9.2908] → [16.19872:19873]
B:BD[16.19872] → [16.19872:19873]
```
pub const MoveList = std.BoundedArray(BitMove, 128);
```
Insertion in src/Board.zig at line 210 [16.16071]
[18.56]
[18.56]
```
    allocator: std.mem.Allocator,
```

Replacement in src/Board.zig at line 222 [16.16071]

B:BD[16.20711] → [16.20711:20749]

B:BD[16.20749] → [16.20749:20806]

    pub fn init(FEN: ?Str) !@This() {
        var gs = GameState{ .attacks = Attacks.init() };

[16.20711]

[16.20806]

    pub fn init(allocator: std.mem.Allocator, FEN: ?Str) !@This() {
        var gs = GameState{ .allocator = allocator, .attacks = Attacks.init() };

Replacement in src/Board.zig at line 517 [16.16071]

B:BD[16.32523] → [9.3640:3687]

                        try ml.append(BitMove{

[16.32523]

[16.32578]

                        const move = BitMove{

Replacement in src/Board.zig at line 522 [16.16071]

B:BD[16.32810] → [16.32810:32838]

});

[16.32810]

[16.32838]

                        };
                        try ml.add(MovePrio{ .move = move, .score = self.scoreMove(move) });

Replacement in src/Board.zig at line 526 [16.16071]

B:BD[16.32885] → [9.3688:3731]

∅:D[9.3731] → [16.32936:33138]

B:BD[16.32936] → [16.32936:33138]

                    try ml.append(BitMove{
                        .source = @intToEnum(Square, source_square),
                        .target = @intToEnum(Square, target_square),
                        .piece = piece,
                    });

[16.32885]

[16.33138]

                    {
                        const move = BitMove{
                            .source = @intToEnum(Square, source_square),
                            .target = @intToEnum(Square, target_square),
                            .piece = piece,
                        };
                        try ml.add(.{ .move = move, .score = self.scoreMove(move) });
                    }

Deletion in src/Board.zig at line 535 [16.16071]

B:BD[16.33139] → [16.33139:33220]

                    // TODO: check: if single step is no-go, double can not work

Replacement in src/Board.zig at line 540 [16.16071]

B:BD[16.33477] → [9.3732:3779]

                        try ml.append(BitMove{

[16.33477]

[16.33532]

                        const move = BitMove{

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

B:BD[16.33766] → [16.33766:33794]

});

[16.33766]

[16.33794]

                        };
                        try ml.add(.{ .move = move, .score = self.scoreMove(move) });

Replacement in src/Board.zig at line 560 [16.16071]

B:BD[16.34240] → [9.3867:3914]

                        try ml.append(BitMove{

[16.34240]

[16.34295]

                        const move = BitMove{

Replacement in src/Board.zig at line 566 [16.16071]

B:BD[16.34572] → [16.34572:34600]

});

[16.34572]

[16.34600]

                        };
                        try ml.add(.{ .move = move, .score = self.scoreMove(move) });

Replacement in src/Board.zig at line 570 [16.16071]

B:BD[16.34647] → [9.3915:3958]

                    try ml.append(BitMove{

[16.34647]

[16.34698]

                    const move = BitMove{

Replacement in src/Board.zig at line 575 [16.16071]

B:BD[16.34917] → [16.34917:34941]

});

[16.34917]

[16.34941]

                    };
                    try ml.add(.{ .move = move, .score = self.scoreMove(move) });

Replacement in src/Board.zig at line 590 [16.16071]

B:BD[16.35483] → [9.3959:4002]

                    try ml.append(BitMove{

[16.35483]

[16.35534]

                    const move = BitMove{

Replacement in src/Board.zig at line 596 [16.16071]

∅:D[17.2194] → [16.35756:35780]

B:BD[16.35756] → [16.35756:35780]

});

[17.2194]

[16.35780]

                    };
                    try ml.add(.{ .move = move, .score = self.scoreMove(move) });

Replacement in src/Board.zig at line 635 [16.16071]

B:BD[16.37065] → [9.4178:4221]

                    try ml.append(BitMove{

[16.37065]

[16.37116]

                    const move = BitMove{

Replacement in src/Board.zig at line 640 [16.16071]

∅:D[19.1318] → [16.37256:37280]

B:BD[16.37256] → [16.37256:37280]

});

[19.1318]

[16.37280]

                    };
                    try ml.add(.{ .move = move, .score = self.scoreMove(move) });

Replacement in src/Board.zig at line 674 [16.16071]

B:BD[16.38416] → [9.4319:4362]

                    try ml.append(BitMove{

[16.38416]

[16.38467]

                    const move = BitMove{

Replacement in src/Board.zig at line 679 [16.16071]

∅:D[19.1361] → [16.38609:38633]

B:BD[16.38609] → [16.38609:38633]

});

[19.1361]

[16.38633]

                    };
                    try ml.add(.{ .move = move, .score = self.scoreMove(move) });

Replacement in src/Board.zig at line 711 [16.16071]

B:BD[9.4569] → [9.4569:4612]

                    try ml.append(BitMove{

[9.4569]

[16.40176]

                    const move = BitMove{

Replacement in src/Board.zig at line 716 [16.16071]

B:BD[16.40395] → [16.40395:40419]

});

[16.40395]

[16.40419]

                    };
                    try ml.add(.{ .move = move, .score = self.scoreMove(move) });

Replacement in src/Board.zig at line 719 [16.16071]

B:BD[16.40444] → [9.4613:4656]

                    try ml.append(BitMove{

[16.40444]

[16.40495]

                    const move = BitMove{

Replacement in src/Board.zig at line 723 [16.16071]

B:BD[16.40673] → [16.40673:40697]

});

[16.40673]

[16.40697]

                    };
                    try ml.add(.{ .move = move, .score = self.scoreMove(move) });

Insertion in src/Board.zig at line 892 [16.16071]

[17.4727]

        }
    }
    pub fn scoreMove(gs: @This(), move: BitMove) isize {
        if (move.capture) {
            var target_piece = Chess.PE.P; // this could be p as well
            const pieces = switch (gs.side) {
                .white => &[_]Chess.PE{ .P, .N, .B, .R, .Q, .K },
                .black => &[_]Chess.PE{ .p, .n, .b, .r, .q, .k },
            };
            for (pieces) |piece| {
                if (gs.bitboards[@enumToInt(piece)].isSet(move.target)) {
                    target_piece = piece;
                    break;
                }
            }
            return MVV_LVA[@enumToInt(move.piece)][@enumToInt(target_piece)];

Insertion in src/Board.zig at line 911 [16.16071]
[17.4737]
[17.4737]
```
        return 0;
```

Insertion in src/Board.zig at line 914 [16.16071]

[17.4743]

[16.40867]


    // most valuable victim & less valuable attacker
    //    (Victims) Pawn Knight Bishop   Rook  Queen   King
    //  (Attackers)
    //        Pawn   105    205    305    405    505    605
    //      Knight   104    204    304    404    504    604
    //      Bishop   103    203    303    403    503    603
    //        Rook   102    202    302    402    502    602
    //       Queen   101    201    301    401    501    601
    //        King   100    200    300    400    500    600
    // MVV LVA [attacker][victim]
    const MVV_LVA: [12][12]u10 = .{
        .{ 105, 205, 305, 405, 505, 605, 105, 205, 305, 405, 505, 605 },
        .{ 104, 204, 304, 404, 504, 604, 104, 204, 304, 404, 504, 604 },
        .{ 103, 203, 303, 403, 503, 603, 103, 203, 303, 403, 503, 603 },
        .{ 102, 202, 302, 402, 502, 602, 102, 202, 302, 402, 502, 602 },
        .{ 101, 201, 301, 401, 501, 601, 101, 201, 301, 401, 501, 601 },
        .{ 100, 200, 300, 400, 500, 600, 100, 200, 300, 400, 500, 600 },
        .{ 105, 205, 305, 405, 505, 605, 105, 205, 305, 405, 505, 605 },
        .{ 104, 204, 304, 404, 504, 604, 104, 204, 304, 404, 504, 604 },
        .{ 103, 203, 303, 403, 503, 603, 103, 203, 303, 403, 503, 603 },
        .{ 102, 202, 302, 402, 502, 602, 102, 202, 302, 402, 502, 602 },
        .{ 101, 201, 301, 401, 501, 601, 101, 201, 301, 401, 501, 601 },
        .{ 100, 200, 300, 400, 500, 600, 100, 200, 300, 400, 500, 600 },
    };

Replacement in src/Board.zig at line 944 [16.16071]

B:BD[16.40897] → [16.40897:41004]

    var game = try GameState.init("r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1");

[16.40897]

[16.41004]

    var game = try GameState.init(
        std.testing.allocator,
        "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1",
    );

Replacement in src/Board.zig at line 961 [16.16071]

B:BD[16.41309] → [16.41309:41359]

    var gs = try GameState.init(tricky_position);

[16.41309]

[16.41359]

    var gs = try GameState.init(std.testing.allocator, tricky_position);

Replacement in src/Board.zig at line 963 [16.16071]

B:BD[16.41360] → [9.8012:8047]

    var ml = try MoveList.init(0);

[16.41360]

[9.8047]

    var ml = MoveList.init(gs.allocator, {});
    defer ml.deinit();

Replacement in src/Board.zig at line 972 [16.16071]

B:BD[16.41584] → [16.41584:41634]

    var gs = try GameState.init(tricky_position);

[16.41584]

[16.41634]

    var gs = try GameState.init(std.testing.allocator, tricky_position);