voroskoi/pistike - Change X3FYJUNL5ORLRC7TW3C5OMNZOX4JEWL73RXOQZLRKLAUBVNARIMAC

Move UCI stuff to uci.zig

Created by voroskoi on January 22, 2023

X3FYJUNL5ORLRC7TW3C5OMNZOX4JEWL73RXOQZLRKLAUBVNARIMAC

Dependencies

In channels

main

Change contents

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

[4.15]

const std = @import("std");
const Str = []const u8;
const SIZE = @import("Board.zig").SIZE;
const BitMove = @import("Board.zig").BitMove;
const GameState = @import("Board.zig").GameState;
const MoveList = @import("Board.zig").MoveList;
const search = @import("search.zig");
pub fn parseGo(gs: *GameState, in: Str) !Str {
    if (std.mem.containsAtLeast(u8, in, 1, "depth")) {
        // go depth <some val>
        const depth = try std.fmt.parseUnsigned(u4, in[9..], 10);
        return search.bestMove(gs, depth);
    }
    // TODO: different time controls...
    return search.bestMove(gs, 6);
}
pub fn parsePosition(gs: *GameState, in: Str) !void {
    var words = std.mem.tokenize(u8, in, " ");
    if (words.next()) |position| {
        if (position[0] != 'p') {
            return error.InvalidPosition;
        }
    } else return error.InvalidPosition;
    if (words.next()) |start| {
        switch (start[0]) {
            's' => {
                // startpos
                try gs.parseFEN("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
            },
            'f' => {
                // fen
                const end = std.mem.indexOf(u8, in, "moves");
                if (end) |e| {
                    try gs.parseFEN(in[13 .. e - 1]);
                    for ([_]u3{ 0, 1, 2, 3, 4, 5 }) |_| {
                        _ = words.next();
                    }
                } else {
                    try gs.parseFEN(in[13..]);
                    return;
                }
            },
            else => return error.InvalidPosition,
        }
    } else return error.InvalidPosition;
    if (words.next()) |moves| {
        if (moves[0] != 'm') return error.InvalidPosition;
        while (words.next()) |move| {
            const m = try parseMove(gs.*, move);
            _ = gs.makeMove(m, .all);
        }
    }
}
fn parseMove(gs: GameState, in: Str) !BitMove {
    var move: BitMove = .{ .source = undefined, .target = undefined, .piece = undefined };
    move.source = @intToEnum(Square, (in[0] - 'a' + (8 - (in[1] - '0')) * SIZE));
    move.target = @intToEnum(Square, (in[2] - 'a' + (8 - (in[3] - '0')) * SIZE));
    var ml = try MoveList.init(0);
    try gs.generateMoves(&ml);
    for (ml.slice()) |ml_move| {
        if (move.source == ml_move.source and move.target == ml_move.target) {
            move = ml_move;
            // if there is a promotion, check if it is the right one
            if (move.prom != .none) {
                switch (move.prom) {
                    .N => if (in[4] != 'N') continue,
                    .n => if (in[4] != 'n') continue,
                    .B => if (in[4] != 'B') continue,
                    .b => if (in[4] != 'b') continue,
                    .R => if (in[4] != 'R') continue,
                    .r => if (in[4] != 'r') continue,
                    .Q => if (in[4] != 'Q') continue,
                    .q => if (in[4] != 'q') continue,
                    else => unreachable,
                }
            }
            return move;
        }
    }
    return error.IllegalMove;
}
const Square = @import("Board.zig").Square;
const Chess = @import("Chess.zig");
test "UCI - parseMove" {
    var gs = try GameState.init("rnbq1k1r/pp1Pbppp/2p5/8/2B5/8/PPP1NnPP/RNBQK2R w KQ - 1 8");
    {
        // gs.show();
        const got = try parseMove(gs, "d7c8B");
        try std.testing.expectEqual(Square.d7, got.source);
        try std.testing.expectEqual(Square.c8, got.target);
        try std.testing.expectEqual(Chess.PE.B, got.prom);
        try std.testing.expectEqual(true, got.capture);
        try std.testing.expectEqual(Chess.PE.P, got.piece);
        // _ = gs.makeMove(got, .all);
        // gs.show();
    }
    {
        // gs.show();
        const got = parseMove(gs, "d7d8");
        try std.testing.expectError(error.IllegalMove, got);
    }
}
test "UCI - parsePosition" {
    var gs = try GameState.init(null);
    {
        try parsePosition(&gs, "position startpos");
        // gs.show();
    }
    {
        try parsePosition(&gs, "position startpos moves e2e4 e7e5");
        // gs.show();
    }
    {
        try parsePosition(&gs, "position fen 8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - -");
        // gs.show();
    }
    {
        try parsePosition(&gs, "position fen 8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - - 0 1 moves g2g4 c7c5");
        // gs.show();
    }
}

Replacement in src/search.zig at line 18 [3.35]

B:BD[3.526] → [3.526:580]

fn searchPosition(gs: *GameState, depth: usize) Str {

[3.526]

[3.580]

pub fn bestMove(gs: *GameState, depth: usize) Str {

Replacement in src/search.zig at line 35 [3.35]
B:BD[3.1112] → [3.1112:1136]
```
test "searchPosition" {
```
[3.1112]
[3.1136]
```
test "bestMove" {
```

Replacement in src/search.zig at line 38 [3.35]

B:BD[3.1190] → [3.1190:1245]

    std.debug.print("{s}", .{searchPosition(&gs, 4)});

[3.1190]

[3.1245]

    std.debug.print("{s}", .{bestMove(&gs, 4)});

Insertion in src/main.zig at line 4 [4.50]
[5.1666]
[4.79]
```
const uci = @import("uci.zig");
```

Replacement in src/main.zig at line 26 [4.50]

B:BD[6.457] → [6.457:502]

                try gs.parsePosition(input);

[6.457]

[6.502]

                try uci.parsePosition(&gs, input);

Replacement in src/main.zig at line 34 [4.50]

B:BD[6.697] → [6.697:759]

                    try gs.parsePosition("position startpos")

[6.697]

[6.759]

                    try uci.parsePosition(&gs, "position startpos")

Replacement in src/main.zig at line 42 [4.50]

B:BD[6.959] → [6.959:1008]

                var res = try gs.parseGo(input);

[6.959]

[6.1008]

                var res = try uci.parseGo(&gs, input);

Insertion in src/main.zig at line 56 [4.50]
[3.4547]
[4.3467]
```
    _ = @import("uci.zig");
```

Deletion in src/Board.zig at line 270 [9.16071]

∅:D[7.711] → [8.542:548]

B:BD[8.542] → [8.542:548]

B:BD[7.1229] → [7.1229:1230]

B:BD[6.1198] → [8.1987:2038]

∅:D[6.1248] → [10.1049:1213]

∅:D[8.2038] → [10.1049:1213]

B:BD[11.1] → [10.1049:1213]

B:BD[10.1213] → [6.1249:1296]

∅:D[6.1296] → [10.1213:1268]

B:BD[10.1213] → [10.1213:1268]

B:BD[10.1268] → [12.54055:54094]

    }
    pub fn parseGo(self: *@This(), in: Str) !Str {
        if (std.mem.containsAtLeast(u8, in, 1, "depth")) {
            // go depth <some val>
            const depth = try std.fmt.parseUnsigned(u4, in[9..], 10);
            return self.searchPosition(depth);
        }
        // TODO: different time controls...
        return self.searchPosition(6);

Deletion in src/Board.zig at line 271 [9.16071]

B:BD[10.1274] → [10.1274:1275]

B:BD[10.1275] → [6.1337:1395]

∅:D[6.1395] → [11.55:288]

B:BD[11.55] → [11.55:288]


    pub fn parsePosition(self: *@This(), in: Str) !void {
        var words = std.mem.tokenize(u8, in, " ");
        if (words.next()) |position| {
            if (position[0] != 'p') {
                return error.InvalidPosition;
            }
        } else return error.InvalidPosition;

Replacement in src/Board.zig at line 272 [9.16071]

B:BD[13.142] → [11.289:1468]

∅:D[11.1468] → [13.202:1461]

B:BD[13.202] → [13.202:1461]

B:BD[13.1461] → [11.1469:1503]

∅:D[13.1482] → [9.23130:23193]

∅:D[11.1503] → [9.23130:23193]

B:BD[9.23130] → [9.23130:23193]

        if (words.next()) |start| {
            switch (start[0]) {
                's' => {
                    // startpos
                    try self.parseFEN("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
                },
                'f' => {
                    // fen
                    const end = std.mem.indexOf(u8, in, "moves");
                    if (end) |e| {
                        try self.parseFEN(in[13 .. e - 1]);
                        for ([_]u3{ 0, 1, 2, 3, 4, 5 }) |_| {
                            _ = words.next();
                        }
                    } else {
                        try self.parseFEN(in[13..]);
                        return;
                    }
                },
                else => return error.InvalidPosition,
            }
        } else return error.InvalidPosition;
        if (words.next()) |moves| {
            if (moves[0] != 'm') return error.InvalidPosition;
            while (words.next()) |move| {
                const m = try self.parseMove(move);
                _ = self.makeMove(m, .all);
            }
        }
    }
    fn parseMove(self: @This(), in: Str) !BitMove {
        var move: BitMove = .{ .source = undefined, .target = undefined, .piece = undefined };
        move.source = @intToEnum(Square, (in[0] - 'a' + (8 - (in[1] - '0')) * SIZE));
        move.target = @intToEnum(Square, (in[2] - 'a' + (8 - (in[3] - '0')) * SIZE));
        var ml = try MoveList.init(0);
        try self.generateMoves(&ml);
        for (ml.slice()) |ml_move| {
            if (move.source == ml_move.source and move.target == ml_move.target) {
                move = ml_move;
                // if there is a promotion, check if it is the right one
                if (move.prom != .none) {
                    switch (move.prom) {
                        .N => if (in[4] != 'N') continue,
                        .n => if (in[4] != 'n') continue,
                        .B => if (in[4] != 'B') continue,
                        .b => if (in[4] != 'b') continue,
                        .R => if (in[4] != 'R') continue,
                        .r => if (in[4] != 'r') continue,
                        .Q => if (in[4] != 'Q') continue,
                        .q => if (in[4] != 'q') continue,
                        else => unreachable,
                    }
                }
                return move;
            }
        }
        return error.IllegalMove;
    }
    fn parseFEN(self: *@This(), in: []const u8) !void {

[13.142]

[9.23193]

    pub fn parseFEN(self: *@This(), in: []const u8) !void {

Deletion in src/Board.zig at line 427 [9.16071]

B:BD[9.29351] → [9.29351:29358]

B:BD[9.29358] → [13.1702:1776]

∅:D[13.1776] → [9.29425:29507]

B:BD[9.29425] → [9.29425:29507]

B:BD[9.29507] → [2.4199:4346]

∅:D[2.4346] → [9.29604:29634]

B:BD[9.29604] → [9.29604:29634]

    }
    fn sideAttacks(self: *const @This(), color: Chess.Colors) BoardType {
        var ret: BoardType = 0;
        for (std.enums.values(Square)) |square| {
            if (isSquareAttacked(self, @enumToInt(square), color)) {
                ret |= @as(BoardType, 1) << @enumToInt(square);
            }
        }
        return ret;

Replacement in src/Board.zig at line 872 [9.16071]

B:BD[9.41005] → [9.41005:41106]

    var bb = BitBoard{};
    const got = game.sideAttacks(.white);
    bb = @bitCast(BitBoard, got);

[9.41005]

[9.41106]

    var got: BoardType = 0;
    for (std.enums.values(Square)) |square| {
        if (game.isSquareAttacked(@enumToInt(square), .white)) {
            got |= @as(BoardType, 1) << @enumToInt(square);
        }
    }

Deletion in src/Board.zig at line 909 [9.16071]

B:BD[9.42022] → [14.4744:4746]

B:BD[14.4746] → [13.2133:2254]

B:BD[13.2254] → [11.1504:2083]

}
test "UCI - parseMove" {
    var gs = try GameState.init("rnbq1k1r/pp1Pbppp/2p5/8/2B5/8/PPP1NnPP/RNBQK2R w KQ - 1 8");
    {
        // gs.show();
        const got = try gs.parseMove("d7c8B");
        try std.testing.expectEqual(Square.d7, got.source);
        try std.testing.expectEqual(Square.c8, got.target);
        try std.testing.expectEqual(Chess.PE.B, got.prom);
        try std.testing.expectEqual(true, got.capture);
        try std.testing.expectEqual(Chess.PE.P, got.piece);
        // _ = gs.makeMove(got, .all);
        // gs.show();
    }
    {
        // gs.show();
        const got = gs.parseMove("d7d8");
        try std.testing.expectError(error.IllegalMove, got);
    }

Deletion in src/Board.zig at line 910 [9.16071]

B:BD[11.2085] → [11.2085:2154]

∅:D[11.2154] → [13.2272:2273]

B:BD[13.2272] → [13.2272:2273]

B:BD[13.2273] → [11.2155:2240]

∅:D[11.2240] → [13.2316:2317]

B:BD[13.2316] → [13.2316:2317]

B:BD[13.2317] → [11.2241:2342]

∅:D[11.2342] → [13.2602:2603]

B:BD[13.2602] → [13.2602:2603]

B:BD[13.2603] → [11.2343:2461]

∅:D[11.2461] → [13.2640:2641]

B:BD[13.2640] → [13.2640:2641]

B:BD[13.2641] → [11.2462:2572]

B:BD[11.2572] → [15.4271:4301]


test "UCI - parsePosition" {
    var gs = try GameState.init(null);
    {
        try gs.parsePosition("position startpos");
        // gs.show();
    }
    {
        try gs.parsePosition("position startpos moves e2e4 e7e5");
        // gs.show();
    }
    {
        try gs.parsePosition("position fen 8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - -");
        // gs.show();
    }
    {
        try gs.parsePosition("position fen 8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - - 0 1 moves g2g4 c7c5");
        // gs.show();
    }
}