removed all c code

.gitea/workflows/nix-check.yaml

@@ -0,0 +1,13 @@
+name: Verify build
+run-name: ${{ gitea.actor }} is building
+on: [push]
+
+jobs:
+  verify_build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: cachix/install-nix-action@v30
+        with:
+          nix_path: nixpkgs=channel:nixos-25.05
+      - run: nix-build

.gitignore

@@ -1 +1,4 @@
 /a.out
+/.zig-cache/
+/zig-out/
+/result

README.md

@@ -1,3 +1,6 @@
 # RatChess
 
-A chess engine made for fun
+A chess engine made for fun
+
+## Branch
+Port to zig for fun and to learn zig

build.zig

@@ -0,0 +1,29 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const exe_mod = b.createModule(.{
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const exe = b.addExecutable(.{ .name = "RatChess", .root_module = exe_mod });
+    b.installArtifact(exe);
+
+    const run_cmd = b.addRunArtifact(exe);
+    run_cmd.step.dependOn(b.getInstallStep());
+
+    if (b.args) |args| run_cmd.addArgs(args);
+
+    const run_step = b.step("run", "Run the app");
+    run_step.dependOn(&run_cmd.step);
+
+    const exe_unit_tests = b.addTest(.{ .root_module = exe_mod });
+    const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
+
+    const test_step = b.step("test", "Run unit tests");
+    test_step.dependOn(&run_exe_unit_tests.step);
+}

build.zig.zon

@@ -0,0 +1,86 @@
+.{
+    // This is the default name used by packages depending on this one. For
+    // example, when a user runs `zig fetch --save <url>`, this field is used
+    // as the key in the `dependencies` table. Although the user can choose a
+    // different name, most users will stick with this provided value.
+    //
+    // It is redundant to include "zig" in this name because it is already
+    // within the Zig package namespace.
+    .name = .RatChess,
+
+    // This is a [Semantic Version](https://semver.org/).
+    // In a future version of Zig it will be used for package deduplication.
+    .version = "0.0.0",
+
+    // Together with name, this represents a globally unique package
+    // identifier. This field is generated by the Zig toolchain when the
+    // package is first created, and then *never changes*. This allows
+    // unambiguous detection of one package being an updated version of
+    // another.
+    //
+    // When forking a Zig project, this id should be regenerated (delete the
+    // field and run `zig build`) if the upstream project is still maintained.
+    // Otherwise, the fork is *hostile*, attempting to take control over the
+    // original project's identity. Thus it is recommended to leave the comment
+    // on the following line intact, so that it shows up in code reviews that
+    // modify the field.
+    .fingerprint = 0xad90dd593d9885b0, // Changing this has security and trust implications.
+
+    // Tracks the earliest Zig version that the package considers to be a
+    // supported use case.
+    .minimum_zig_version = "0.14.1",
+
+    // This field is optional.
+    // Each dependency must either provide a `url` and `hash`, or a `path`.
+    // `zig build --fetch` can be used to fetch all dependencies of a package, recursively.
+    // Once all dependencies are fetched, `zig build` no longer requires
+    // internet connectivity.
+    .dependencies = .{
+        // See `zig fetch --save <url>` for a command-line interface for adding dependencies.
+        //.example = .{
+        //    // When updating this field to a new URL, be sure to delete the corresponding
+        //    // `hash`, otherwise you are communicating that you expect to find the old hash at
+        //    // the new URL. If the contents of a URL change this will result in a hash mismatch
+        //    // which will prevent zig from using it.
+        //    .url = "https://example.com/foo.tar.gz",
+        //
+        //    // This is computed from the file contents of the directory of files that is
+        //    // obtained after fetching `url` and applying the inclusion rules given by
+        //    // `paths`.
+        //    //
+        //    // This field is the source of truth; packages do not come from a `url`; they
+        //    // come from a `hash`. `url` is just one of many possible mirrors for how to
+        //    // obtain a package matching this `hash`.
+        //    //
+        //    // Uses the [multihash](https://multiformats.io/multihash/) format.
+        //    .hash = "...",
+        //
+        //    // When this is provided, the package is found in a directory relative to the
+        //    // build root. In this case the package's hash is irrelevant and therefore not
+        //    // computed. This field and `url` are mutually exclusive.
+        //    .path = "foo",
+        //
+        //    // When this is set to `true`, a package is declared to be lazily
+        //    // fetched. This makes the dependency only get fetched if it is
+        //    // actually used.
+        //    .lazy = false,
+        //},
+    },
+
+    // Specifies the set of files and directories that are included in this package.
+    // Only files and directories listed here are included in the `hash` that
+    // is computed for this package. Only files listed here will remain on disk
+    // when using the zig package manager. As a rule of thumb, one should list
+    // files required for compilation plus any license(s).
+    // Paths are relative to the build root. Use the empty string (`""`) to refer to
+    // the build root itself.
+    // A directory listed here means that all files within, recursively, are included.
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "src",
+        // For example...
+        //"LICENSE",
+        //"README.md",
+    },
+}

default.nix

@@ -0,0 +1,33 @@
+# default.nix
+{ pkgs ? import <nixpkgs> {} }:
+
+pkgs.stdenv.mkDerivation {
+  pname = "RatChess";
+  version = "0.0.1";
+
+  src = ./.;
+
+  nativeBuildInputs = with pkgs; [
+    zig
+    zls
+  ];
+
+  buildInputs = with pkgs; [
+  ];
+
+  buildPhase = ''
+    echo "Building project..."
+    ${pkgs.zig}/bin/zig build --global-cache-dir ./cache  --release=fast
+  '';
+
+  installPhase = ''
+    mkdir $out
+    cp -r zig-out/* $out/
+  '';
+
+  checkPhase = ''
+    echo "Testing project..."
+    ${pkgs.zig}/bin/zig build test --global-cache-dir ./cache
+  '';
+  doCheck = true;
+}

headers/eval.h

@@ -1,5 +0,0 @@
-#ifndef EVAL_H
-#define EVAL_H
-move *findBest(move* move, size_t size, game* g);
-void makeMove(game *g, move* m);
-#endif

headers/help.h

@@ -1,11 +0,0 @@
-#ifndef HELP_H
-#define HELP_H
-#include "types.h"
-
-long long fullSet(sets *s);
-long long fullSetBoth(game *g);
-void print_bitboard(long long bitboard);
-long long *findSet(game *g, long long bit);
-long long *charToSet(game *g, char c);
-
-#endif

headers/moves.h

@@ -1,10 +0,0 @@
-#ifndef MOVES_H
-#define MOVES_H
-#include "types.h"
-int pawnMove(game *g, move *moves);
-int knightMove(game *g, move* moves);
-int rookMove(game *g, move *moves);
-int bishopMove(game *g, move *moves);
-int kingMove(game *g, move *moves);
-int queenMove(game *g, move *moves);
-#endif

headers/types.h

@@ -1,26 +0,0 @@
-#ifndef TYPES_H
-#define TYPES_H
-#include <stdbool.h>
-
-typedef struct {
-  long long pawns;
-  long long knights;
-  long long bishops;
-  long long rooks;
-  long long queen;
-  long long king;
-} sets;
-
-typedef struct {
-  sets white;
-  sets black;
-  bool whiteToMove;
-} game;
-
-typedef struct {
-  int From;
-  int To;
-  char Promo;
-} move;
-
-#endif

shell.nix

@@ -1,11 +1,9 @@
 {pkgs ? import <nixpkgs> {}}:
 with pkgs;
   mkShell rec {
-    packages = [gdb clang-tools uchess cutechess];
+    packages = [gdb zls uchess cutechess stockfish];
     nativeBuildInputs = [
-      pkg-config
-      gcc
-      gnumake
+      zig
     ];
     buildInputs = [
     ];

src/eval.c

@@ -1,109 +0,0 @@
-#include "types.h"
-#include "help.h"
-#include "moves.h"
-#include <stddef.h>
-#include <ctype.h>
-#include <stdio.h>
-
-#define PAWN_VALUE 100
-#define KNIGHT_VALUE 320
-#define BISHOP_VALUE 330
-#define ROOK_VALUE 500
-#define QUEEN_VALUE 900
-#define KING_VALUE 20000
-#define INF 9000000
-#define MAX_DEPTH 3
-
-int evaluateBoard(game *game);
-void makeMove(game *g, move* m);
-int negamax(game *g, int depth, int alpha, int beta, int color);
-
-move *findBest(move* moves, size_t size, game* g){
-  int bestScore = -INF;
-  move *bestMove = NULL;
-  int color = g->whiteToMove ? 1 : -1;
-
-  for (int i = 0; i < size; i++) {
-    game gg = *g;
-    makeMove(&gg, &moves[i]);
-    int score = -negamax(&gg, MAX_DEPTH, -INF, INF, -color);
-    if (score > bestScore || bestScore == -INF) {
-      bestScore = score;
-      bestMove = &moves[i];
-      printf("info score cp %d\n", g->whiteToMove ? bestScore : -bestScore);
-    }
-  }
-  return bestMove;
-}
-
-int evaluateBoard(game *game) {
-    int score = 0;
-    score += __builtin_popcountll(game->white.pawns) * PAWN_VALUE;
-    score += __builtin_popcountll(game->white.knights) * KNIGHT_VALUE;
-    score += __builtin_popcountll(game->white.bishops) * BISHOP_VALUE;
-    score += __builtin_popcountll(game->white.rooks) * ROOK_VALUE;
-    score += __builtin_popcountll(game->white.queen) * QUEEN_VALUE;
-    score += __builtin_popcountll(game->white.king) * KING_VALUE;
-
-    score -= __builtin_popcountll(game->black.pawns) * PAWN_VALUE;
-    score -= __builtin_popcountll(game->black.knights) * KNIGHT_VALUE;
-    score -= __builtin_popcountll(game->black.bishops) * BISHOP_VALUE;
-    score -= __builtin_popcountll(game->black.rooks) * ROOK_VALUE;
-    score -= __builtin_popcountll(game->black.queen) * QUEEN_VALUE;
-    score -= __builtin_popcountll(game->black.king) * KING_VALUE;
-
-    return score;
-}
-
-void makeMove(game *g, move* m) {
-  long long from_bit = 1LL << m->From;
-  long long to_bit = 1LL << m->To;
-
-  long long *set = findSet(g, from_bit);
-  if (!set)
-    return;
-  *set &= ~from_bit;
-
-  long long *captured = findSet(g, to_bit);
-  if (captured) *captured &= ~to_bit;
-
-  if (m->Promo) {
-    char promoChar = g->whiteToMove ? toupper(m->Promo) : m->Promo;
-    long long *newSet = charToSet(g, promoChar);
-    if (newSet)
-      *newSet |= to_bit;
-  } else {
-    *set |= to_bit;
-  }
-
-  g->whiteToMove = !g->whiteToMove;
-}
-
-int negamax(game *g, int depth, int alpha, int beta, int color) {
-  if (depth == 0)
-    return color * evaluateBoard(g);
-
-  move moves[1500];
-  int cnt = pawnMove(g, moves);
-  cnt += knightMove(g, moves + cnt);
-  cnt += rookMove(g, moves + cnt);
-  cnt += bishopMove(g, moves + cnt);
-  cnt += kingMove(g, moves + cnt);
-  cnt += queenMove(g, moves + cnt);
-
-  if (cnt == 0)
-    return 0;
-
-  int bestValue = -INF;
-  for (int i = 0; i < cnt; i++) {
-    game gg = *g;
-    makeMove(&gg, &moves[i]);
-
-    int value = -negamax(&gg, depth - 1, -beta, -alpha, -color);
-
-    if (value > bestValue) bestValue = value;
-    if (value > alpha) alpha = value;
-    if (alpha >= beta) break;
-  }
-  return bestValue;
-}

src/help.c

@@ -1,87 +0,0 @@
-#include <stdio.h>
-#include "types.h"
-
-long long fullSet(sets *s) {
-  return s->bishops | s->king | s->knights | s->pawns | s->queen | s->rooks;
-}
-
-long long fullSetBoth(game *g) {
-  return fullSet(&g->white) ^ fullSet(&g->black);
-}
-
-void print_bitboard(long long bitboard) {
-  for (int i = 63; i >= 0; i--) {
-    // Check if the i-th bit is set
-    if ((bitboard >> i) & 1) {
-      printf("1 ");
-    } else {
-      printf("0 ");
-    }
-    // Print a newline every 8 bits (for rows)
-    if (i % 8 == 0) {
-      printf("\n");
-    }
-  }
-  printf("\n");
-}
-
-long long *findSet(game *g, long long bit) {
-  if (g->white.pawns & bit) {
-    return &g->white.pawns;
-  } else if (g->white.knights & bit) {
-    return &g->white.knights;
-  } else if (g->white.bishops & bit) {
-    return &g->white.bishops;
-  } else if (g->white.rooks & bit) {
-    return &g->white.rooks;
-  } else if (g->white.queen & bit) {
-    return &g->white.queen;
-  } else if (g->white.king & bit) {
-    return &g->white.king;
-  } else if (g->black.pawns & bit) {
-    return &g->black.pawns;
-  } else if (g->black.knights & bit) {
-    return &g->black.knights;
-  } else if (g->black.bishops & bit) {
-    return &g->black.bishops;
-  } else if (g->black.rooks & bit) {
-    return &g->black.rooks;
-  } else if (g->black.queen & bit) {
-    return &g->black.queen;
-  } else if (g->black.king & bit) {
-    return &g->black.king;
-  } else {
-    return NULL;
-  }
-}
-
-long long *charToSet(game *g, char c) {
-  switch (c) {
-  case 'P':
-    return &g->white.pawns;
-  case 'N':
-    return &g->white.knights;
-  case 'B':
-    return &g->white.bishops;
-  case 'R':
-    return &g->white.rooks;
-  case 'Q':
-    return &g->white.queen;
-  case 'K':
-    return &g->white.king;
-  case 'p':
-    return &g->black.pawns;
-  case 'n':
-    return &g->black.knights;
-  case 'b':
-    return &g->black.bishops;
-  case 'r':
-    return &g->black.rooks;
-  case 'q':
-    return &g->black.queen;
-  case 'k':
-    return &g->black.king;
-  default:
-    return NULL;
-  }
-}

src/main.c

@@ -1,140 +0,0 @@
-#include <assert.h>
-#include <ctype.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-#include "moves.h"
-#include "types.h"
-#include "help.h"
-#include "eval.h"
-
-#define BUFF_SIZE 4096
-
-game *fenGame(char *str);
-void playMoves(game *g, char *moves);
-long long *findSet(game *g, long long bit);
-long long *charToSet(game *g, char c);
-
-int main() {
-  setbuf(stdin, NULL);
-  setbuf(stdout, NULL);
-  game *g = NULL;
-
-  char line[BUFF_SIZE];
-  char *lineRest, *token;
-  char ltz[] = "abcdefgh";
-  int cnt = 0;
-  while (1) {
-    if(!fgets(line, sizeof(line), stdin))
-      return 0;
-    size_t len = strlen(line);
-    if (len - 1)
-      line[len - 1] = '\0';
-    token = strtok_r(line, " ", &lineRest);
-    if (!strcmp("uci", token)) {
-      printf("id name RatChess 0.0\n");
-      printf("id author rat<3\n");
-      printf("uciok\n");
-    } else if (!strcmp("quit", token)) {
-      return 0;
-    } else if (!strcmp("setoption", token)) {
-    } else if (!strcmp("position", token)) {
-      token = strtok_r(lineRest, " ", &lineRest);
-      if (!strcmp("fen", token)) {
-        g = fenGame(lineRest + 1);
-        for (int i = 0; i < 6; i++)
-          token = strtok_r(lineRest, " ", &lineRest);
-      } else {
-        g = fenGame("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
-      }
-      playMoves(g, lineRest);
-    } else if (!strcmp("ucinewgame", token)) {
-    } else if (!strcmp("isready", token)) {
-      printf("readyok\n");
-    } else if (!strcmp("go", token)) {
-      static move mov[1500];//big dumb buffer
-      size_t cnt = 0;
-      cnt += pawnMove(g,mov);
-      cnt += knightMove(g,(mov+cnt));
-      cnt += rookMove(g,(mov+cnt));
-      cnt += bishopMove(g,(mov+cnt));
-      cnt += kingMove(g,(mov+cnt));
-      cnt += queenMove(g,(mov+cnt));
-      move *m = findBest(mov,cnt,g);
-      if(m == NULL){
-	printf("bestmove 0000\n");
-	continue;
-      }
-
-      char *end = "";
-      int yTo, xTo, yFrom, xFrom;
-      xTo = m->To % 8;
-      yTo = m->To / 8 + 1;
-      xFrom = m->From % 8;
-      yFrom = m->From / 8 + 1;
-
-      long long bit = 1LL << m->From;
-      if (m->Promo) {
-	end = "q\n";
-      } else {
-        end = "\n";
-      }
-      printf("bestmove %c%d%c%d%s", ltz[xFrom], yFrom, ltz[xTo], yTo, end);
-    }
-  }
-}
-
-game *fenGame(char *str) {
-  int rank = 7;
-  int file = 0;
-  size_t pos = 0;
-  game *g;
-  g = malloc(sizeof(game));
-  memset(g, 0, sizeof(game));
-
-  while (str[pos] != '\0' && str[pos] != ' ') {
-    char current_char = *str;
-
-    if (isdigit(*str)) {
-      int empty_squares = *str - '0';
-      file += empty_squares;
-      str++;
-      continue;
-    }
-
-    if (current_char == '/') {
-      rank--;
-      file = 0;
-      str++;
-      continue;
-    }
-
-    long long bit = 1LL << (rank * 8 + file);
-    long long *set = charToSet(g, *str);
-    if (set)
-      *set |= bit;
-    file++;
-    str++;
-  }
-  str++;
-  g->whiteToMove = (*str == 'w') ? true : false;
-  return g;
-}
-
-void playMoves(game *g, char *moves) {
-  char *moveStr;
-  moveStr = strtok_r(moves, " ", &moves);
-  moveStr = strtok_r(moves, " ", &moves);
-  while (moveStr) {
-    move m;
-    m.From = (moveStr[0]-'a') + (moveStr[1]-'1')*8;
-    m.To = (moveStr[2]-'a') + (moveStr[3]-'1')*8;
-    m.Promo = (strlen(moveStr) == 5) ? moveStr[4] : 0;
-    makeMove(g, &m);
-    moveStr = strtok_r(moves, " ", &moves);
-  }
-}
-

src/main.zig

@@ -0,0 +1,152 @@
+const std = @import("std");
+const mov = @import("move.zig");
+const types = @import("types.zig");
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const alloc = gpa.allocator();
+    const stdin = std.io.getStdIn();
+    var reader = stdin.reader();
+
+    var game: *types.game = uciPos("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1", alloc);
+    defer alloc.destroy(game);
+    while (true) {
+        const line = try reader.readUntilDelimiterAlloc(alloc, '\n', std.math.maxInt(usize));
+        defer alloc.free(line);
+        switch (uci(line, game, alloc)) {
+            .text => |value| {
+                try std.io.getStdOut().writer().print("{s}", .{value});
+            },
+            .move => |value| {
+                try std.io.getStdOut().writer().print("bestmove {s}\n", .{value});
+                alloc.free(value);
+            },
+            .game => |value| {
+                alloc.destroy(game);
+                game = value;
+            },
+            .exit => {
+                break;
+            },
+            .pass => {
+                try std.io.getStdOut().writer().print("info bad input\n", .{});
+            },
+        }
+    }
+}
+
+fn uci(str: []const u8, game: *types.game, alloc: std.mem.Allocator) types.uciRet {
+    const pos = std.mem.indexOfAny(u8, str, " \t\n\r") orelse str.len;
+    const tok = str[0..pos];
+    if (std.mem.eql(u8, tok, "uci")) return .{ .text = "id name RatChess 0.1\nid author rat<3\nuciok\n" };
+    if (std.mem.eql(u8, tok, "isready")) return .{ .text = "readyok\n" };
+    if (std.mem.eql(u8, tok, "go")) return .{ .move = uciGo(game, alloc) };
+    if (std.mem.eql(u8, tok, "position")) return .{ .game = uciPos(str[(pos + 1)..], alloc) };
+    if (std.mem.eql(u8, tok, "exit")) return .{ .exit = {} };
+    return .{ .pass = {} };
+}
+
+fn uciPos(str: []const u8, alloc: std.mem.Allocator) *types.game {
+    const pos = std.mem.indexOfAny(u8, str, " \t\n\r") orelse str.len;
+    const tok = str[0..pos];
+    if (std.mem.eql(u8, tok, "fen")) return fenGame(str[pos..], alloc);
+    if (std.mem.eql(u8, tok, "startpos")) {
+        var game = fenGame("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1", alloc);
+        game = mov.playMoves(game, str[(pos)..]);
+        return game;
+    }
+    return fenGame("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1", alloc); //this should be an error
+}
+
+fn fenGame(str: []const u8, alloc: std.mem.Allocator) *types.game {
+    var pos: u8 = 63;
+    var space: u8 = 0;
+    var g = alloc.create(types.game) catch unreachable;
+    g.* = std.mem.zeroes(types.game);
+    for (str) |chr| {
+        if (chr == ' ') {
+            space += 1;
+            continue;
+        }
+        if (space == 1) {
+            if (chr == 'b') g.whiteToMove = false;
+            if (chr == 'w') g.whiteToMove = true;
+            //continue;
+            break;
+        }
+
+        if (std.ascii.isDigit(chr)) {
+            pos += @truncate(chr - '0');
+            continue;
+        }
+        if (chr == '/') continue;
+        const set: *u64 = mov.charToSet(g, chr);
+        const bit: u64 = @as(u64, 1) << @truncate(pos);
+        set.* |= bit;
+        pos -= 1;
+    }
+    return g;
+}
+
+fn uciGo(game: *types.game, alloc: std.mem.Allocator) []u8 {
+    var moves = std.ArrayList(types.move).init(alloc);
+    defer moves.deinit();
+    const str = alloc.alloc(u8, 5) catch unreachable;
+    mov.knightMove(game, &moves);
+    if (moves.capacity == 0) {
+        @memcpy(str.ptr, "0000");
+        return str;
+    }
+    mov.moveTypeToStr(moves.items[0], str);
+    return str;
+}
+
+test "uci uci" {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const alloc = gpa.allocator();
+    const game = uciPos("fen rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1", alloc);
+    defer alloc.destroy(game);
+
+    const out = uci("uci", game, alloc);
+    try std.testing.expect(out == .text);
+}
+
+test "uci ready" {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const alloc = gpa.allocator();
+    const game = uciPos("fen rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1", alloc);
+    defer alloc.destroy(game);
+
+    const out = uci("isready", game, alloc);
+    try std.testing.expect(out == .text);
+}
+
+test "uci go" {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const alloc = gpa.allocator();
+    const game = uciPos("fen rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1", alloc);
+    defer alloc.destroy(game);
+
+    const out = uci("go", game, alloc);
+    try std.testing.expect(out == .move);
+    alloc.free(out.move);
+}
+
+test "uci position" {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const alloc = gpa.allocator();
+    const game = uciPos("fen rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1", alloc);
+    defer alloc.destroy(game);
+
+    const out = uci("position startpos", game, alloc);
+    defer alloc.destroy(out.game);
+    try std.testing.expect(out == .game);
+    try std.testing.expect(out.game.whiteToMove == true);
+    try std.testing.expect(out.game.white.king != 0);
+    try std.testing.expect(out.game.black.king != 0);
+}

src/move.zig

@@ -0,0 +1,191 @@
+const std = @import("std");
+const types = @import("types.zig");
+
+pub fn moveTypeToStr(move: types.move, buf: []u8) void {
+    const xTo = @mod(move.To, 8);
+    const yTo = @divTrunc(move.To, 8);
+    const xFrom = @mod(move.From, 8);
+    const yFrom = @divTrunc(move.From, 8);
+
+    buf[0] = @intCast(xFrom + 'a');
+    buf[1] = @intCast(yFrom + '0' + 1);
+    buf[2] = @intCast(xTo + 'a');
+    buf[3] = @intCast(yTo + '0' + 1);
+    buf[4] = move.Promo;
+}
+
+pub fn playMoves(game: *types.game, str: []const u8) *types.game {
+    if (str.len < 4) return game;
+    var splitItr = std.mem.splitSequence(u8, str, " ");
+    while (splitItr.next()) |moveString| {
+        if (moveString.len < 4 or moveString[0] > 'h')
+            continue;
+        var move: types.move = .{ .To = 0, .From = 0, .Promo = 0 };
+        if (moveString.len < 4) continue;
+        move.From = (moveString[0] - 'a') + (moveString[1] - '1') * 8;
+        move.To = (moveString[2] - 'a') + (moveString[3] - '1') * 8;
+        move.Promo = if (moveString.len == 5) moveString[4] else 0;
+        makeMove(@ptrCast(game), @ptrCast(&move));
+    }
+    return game;
+}
+
+fn fullSet(set: *types.set) u64 {
+    return set.bishops | set.king | set.knights | set.pawns | set.queen | set.rooks;
+}
+
+fn findSet(game: *types.game, bit: u64) ?*u64 {
+    if (game.white.pawns & bit != 0) {
+        return &game.white.pawns;
+    } else if (game.white.knights & bit != 0) {
+        return &game.white.knights;
+    } else if (game.white.bishops & bit != 0) {
+        return &game.white.bishops;
+    } else if (game.white.rooks & bit != 0) {
+        return &game.white.rooks;
+    } else if (game.white.queen & bit != 0) {
+        return &game.white.queen;
+    } else if (game.white.king & bit != 0) {
+        return &game.white.king;
+    } else if (game.black.pawns & bit != 0) {
+        return &game.black.pawns;
+    } else if (game.black.knights & bit != 0) {
+        return &game.black.knights;
+    } else if (game.black.bishops & bit != 0) {
+        return &game.black.bishops;
+    } else if (game.black.rooks & bit != 0) {
+        return &game.black.rooks;
+    } else if (game.black.queen & bit != 0) {
+        return &game.black.queen;
+    } else if (game.black.king & bit != 0) {
+        return &game.black.king;
+    } else {
+        return null;
+    }
+}
+
+fn makeMove(game: *types.game, move: *types.move) void {
+    const from = @as(u64, 1) << @truncate(move.From);
+    const to = @as(u64, 1) << @truncate(move.To);
+    const set = findSet(game, from);
+    if (set == null)
+        return;
+    set.?.* &= ~from;
+
+    const cap = findSet(game, to);
+    if (cap != null)
+        cap.?.* &= ~to;
+
+    if (move.Promo != 0) {
+        charToSet(game, move.Promo).* |= to;
+    } else {
+        set.?.* |= to;
+    }
+
+    game.whiteToMove = !game.whiteToMove;
+}
+
+pub fn charToSet(g: *types.game, chr: u8) *u64 {
+    return switch (chr) {
+        'P' => &g.white.pawns,
+        'N' => &g.white.knights,
+        'B' => &g.white.bishops,
+        'R' => &g.white.rooks,
+        'Q' => &g.white.queen,
+        'K' => &g.white.king,
+        'p' => &g.black.pawns,
+        'n' => &g.black.knights,
+        'b' => &g.black.bishops,
+        'r' => &g.black.rooks,
+        'q' => &g.black.queen,
+        'k' => &g.black.king,
+        else => {
+            std.log.err("you should not be here ${c}$", .{chr});
+            unreachable;
+        },
+    };
+}
+
+// pub fn pawnMove(arr: std.ArrayList(c.move)) void {
+//     const move = c.move{ .From = 8, .To = 16, .Promo = 0 };
+// }
+
+pub fn sqrScan(rook: u64, hit: u64, flip: bool) u64 {
+    const vecLut: [64]u64 = undefined; //todo comptime init
+
+    var center = rook;
+    var hits = hit;
+    if (flip) {
+        center = @bitReverse(rook);
+        hits = @bitReverse(hit);
+    }
+
+    const vec = vecLut[@ctz(center)];
+
+    var attackedBits = hits & vec;
+    const n = @popCount(attackedBits);
+    var min: u64 = vec;
+    for (0..n) |_| {
+        const pos = @ctz(attackedBits);
+        const bit = @as(u64, 1) << pos;
+        attackedBits = attackedBits & ~bit;
+        if (bit - 1 < min) min = bit - 1;
+    }
+
+    return min;
+}
+
+pub fn knightMove(g: *types.game, arr: *std.ArrayList(types.move)) void {
+    const moveLut: [64]u64 = comptime blk: {
+        var value: [64]u64 = undefined;
+        for (0..64) |i| {
+            value[i] = knightCalc(@truncate(i));
+        }
+        break :blk value;
+    };
+    const set = if (g.whiteToMove) &g.white.knights else &g.black.knights;
+    const fset: u64 = if (g.whiteToMove) @as(u64, fullSet(@ptrCast(&g.white))) else @as(u64, fullSet(@ptrCast(&g.black)));
+    var val = set.*; //local copy
+    const n = @popCount(val);
+    for (0..n) |_| {
+        const pos = @ctz(val);
+        const moves = moveLut[pos] & ~fset;
+        val = val ^ (@as(u64, 1) << @truncate(pos));
+        bitboardToMoves(pos, moves, arr);
+    }
+}
+
+fn knightCalc(index: u8) u64 {
+    var moves: u64 = 0;
+    const offsets = [_]i8{ 17, -17, 15, -15, 10, -10, 6, -6 };
+    var cnt: u8 = undefined;
+    for (offsets) |off| {
+        if (off > 0) {
+            cnt = index + @abs(off);
+        } else if (index > @abs(off)) { //Icky bad that zig makes me do
+            cnt = index - @abs(off);
+        }
+        const fromFile: i32 = index % 8;
+        const toFile: i32 = cnt % 8;
+        const fromRank: i32 = index / 8;
+        const toRank: i32 = cnt / 8;
+
+        const fileDiff = @abs(fromFile - toFile);
+        const rankDiff = @abs(fromRank - toRank);
+        if (!((fileDiff == 1 and rankDiff == 2) or
+            (fileDiff == 2 and rankDiff == 1)) or cnt > 63)
+            continue;
+        moves = moves | @as(u64, 1) << @truncate(cnt);
+    }
+    return moves;
+}
+
+fn bitboardToMoves(start: u8, moves: u64, arr: *std.ArrayList(types.move)) void {
+    var lmoves = moves;
+    while (lmoves != 0) {
+        const pos = @ctz(lmoves);
+        const m: types.move = .{ .From = start, .Promo = 0, .To = pos };
+        lmoves = lmoves & ~@as(u64, 1) << @truncate(pos);
+        arr.append(m) catch unreachable;
+    }
+}

src/moves.c

@@ -1,286 +0,0 @@
-#include "moves.h"
-#include "help.h"
-#include "types.h"
-#include <stddef.h>
-#include <stdlib.h>
-
-int rookScan(game *g, move *moves, long long w, long long b);
-int bishopScan(game *g, move *moves, long long w, long long b);
-int kingScan(game *g, move *moves, long long w, long long b);
-
-int pawnMove(game *g, move *moves) {
-  long long pawns = g->whiteToMove ? g->white.pawns : g->black.pawns;
-  long long enemy = g->whiteToMove ? fullSet(&g->black) : fullSet(&g->white);
-  long long occupied = fullSetBoth(g);
-  long long promo = (0xFFLL) << (g->whiteToMove ? 56 : 0);
-
-  int movdir = g->whiteToMove ? 8 : -8;
-  int capLeft = g->whiteToMove ? 7 : -9;
-  int capRight = g->whiteToMove ? 9 : -7;
-
-  size_t index = 0;
-
-  for (int i = 0; i < 64; ++i) {
-    long long bit = 1LL << i;
-    char p = 0;
-    if (!(pawns & bit))
-      continue;
-
-    // forword
-    int to = i + movdir;
-    p = (promo & (1LL << to)) ? 'q' : 0;
-    if (to >= 0 && to < 64 && !(occupied & (1LL << to))) {
-      moves[index++] = (move){.From = i, .To = to, .Promo = p};
-    }
-
-    // left
-    to = i + capLeft;
-    p = (promo & (1LL << to)) ? 'q' : 0;
-    if (i % 8 > 0 && (to >= 0 && to < 64) && (enemy & (1LL << to))) {
-      moves[index++] = (move){.From = i, .To = to, .Promo = p};
-    }
-
-    // right
-    to = i + capRight;
-    p = (promo & (1LL << to)) ? 'q' : 0;
-    if (i % 8 < 7 && (to >= 0 && to < 64) && (enemy & (1LL << to))) {
-      moves[index++] = (move){.From = i, .To = to, .Promo = p};
-    }
-  }
-  return index;
-}
-
-int knightMove(game *g, move *moves) {
-  long long knights = g->whiteToMove ? g->white.knights : g->black.knights;
-  long long occupied = g->whiteToMove ? fullSet(&g->white) : fullSet(&g->black);
-
-  int kMoves[] = {-17, -15, -10, -6, 6, 10, 15, 17};
-  int index = 0;
-
-  for (int i = 0; i < 64; i++) {
-    long long bit = 1LL << i;
-    if (!(knights & bit))
-      continue;
-
-    for (int j = 0; j < 8; ++j) {
-      int to = i + kMoves[j];
-      if (to < 0 || to > 64)
-        continue;
-
-      int fromFile = i % 8;
-      int toFile = to % 8;
-      int fromRank = i / 8;
-      int toRank = to / 8;
-
-      int fileDiff = abs(fromFile - toFile);
-      int rankDiff = abs(fromRank - toRank);
-      if (!((fileDiff == 1 && rankDiff == 2) ||
-            (fileDiff == 2 && rankDiff == 1)))
-        continue;
-
-      long long destBit = 1LL << to;
-      if (occupied & destBit)
-        continue;
-
-      moves[index++] = (move){.From = i, .To = to, .Promo=0};
-    }
-  }
-  return index;
-}
-
-int rookMove(game *g, move *moves) {
-  return rookScan(g, moves, g->white.rooks, g->black.rooks);
-}
-
-int rookScan(game *g, move *moves, long long w, long long b) {
-  long long rooks = g->whiteToMove ? w : b;
-  long long occupied = g->whiteToMove ? fullSet(&g->white) : fullSet(&g->black);
-  long long occupiedE =
-    !g->whiteToMove ? fullSet(&g->white) : fullSet(&g->black);
-  int index = 0;
-
-  for (int i = 0; i < 64; i++) {
-    long long bit = 1LL << i;
-    int x = i % 8;
-    int y = i / 8;
-    if (!(rooks & bit))
-      continue;
-
-    // fwd
-    for (int j = y + 1; j < 8; j++) {
-      int to = (j * 8) + x;
-      long long lbit = 1LL << to;
-      if (occupied & lbit)
-        break;
-      moves[index++] = (move){.From = i, .To = to, .Promo=0};
-      if (occupiedE & lbit)
-        break;
-    }
-
-    // bck
-    for (int j = y - 1; j >= 0; j--) {
-      int to = (j * 8) + x;
-      long long lbit = 1LL << to;
-      if (occupied & lbit)
-        break;
-      moves[index++] = (move){.From = i, .To = to, .Promo=0};
-      if (occupiedE & lbit)
-        break;
-    }
-
-    // rht
-    for (int j = x + 1; j < 8; j++) {
-      int to = (y * 8) + j;
-      long long lbit = 1LL << to;
-      if (occupied & lbit)
-        break;
-      moves[index++] = (move){.From = i, .To = to, .Promo=0};
-      if (occupiedE & lbit)
-        break;
-    }
-
-    // lft
-    for (int j = x - 1; j >= 0; j--) {
-      int to = (y * 8) + j;
-      long long lbit = 1LL << to;
-      if (occupied & lbit)
-        break;
-      moves[index++] = (move){.From = i, .To = to, .Promo=0};
-      if (occupiedE & lbit)
-        break;
-    }
-  }
-  return index;
-}
-
-int bishopMove(game *g, move *moves) {
-  return bishopScan(g, moves, g->white.bishops, g->black.bishops);
-}
-
-int bishopScan(game *g, move *moves, long long w, long long b) {
-  long long bishops = g->whiteToMove ? w : b;
-  long long occupied = g->whiteToMove ? fullSet(&g->white) : fullSet(&g->black);
-  long long occupiedE =
-      !g->whiteToMove ? fullSet(&g->white) : fullSet(&g->black);
-  int index = 0;
-
-  for (int i = 0; i < 64; i++) {
-    long long bit = 1LL << i;
-    int x = i % 8;
-    int y = i / 8;
-
-    if (!(bishops & bit))
-      continue;
-
-    // ur
-    for (int j = 1;; j++) {
-      int xTo = x + j;
-      int yTo = y + j;
-      if (xTo >= 8 || yTo >= 8)
-        break;
-
-      int to = (yTo * 8) + xTo;
-      long long lbit = 1LL << to;
-
-      if (occupied & lbit)
-        break;
-      moves[index++] = (move){.From = i, .To = to, .Promo=0};
-      if (occupiedE & lbit)
-        break;
-    }
-
-    // ul
-    for (int j = 1;; j++) {
-      int xTo = x - j;
-      int yTo = y + j;
-      if (xTo < 0 || yTo >= 8)
-        break;
-
-      int to = (yTo * 8) + xTo;
-      long long lbit = 1LL << to;
-
-      if (occupied & lbit)
-        break;
-      moves[index++] = (move){.From = i, .To = to, .Promo=0};
-      if (occupiedE & lbit)
-        break;
-    }
-
-    // dr
-    for (int j = 1;; j++) {
-      int xTo = x + j;
-      int yTo = y - j;
-      if (xTo >= 8 || yTo < 0)
-        break;
-
-      int to = (yTo * 8) + xTo;
-      long long lbit = 1LL << to;
-
-      if (occupied & lbit)
-        break;
-      moves[index++] = (move){.From = i, .To = to, .Promo=0};
-      if (occupiedE & lbit)
-        break;
-    }
-
-    // dl
-    for (int j = 1;; j++) {
-      int xTo = x - j;
-      int yTo = y - j;
-      if (xTo < 0 || yTo < 0)
-        break;
-
-      int to = (yTo * 8) + xTo;
-      long long lbit = 1LL << to;
-
-      if (occupied & lbit)
-        break;
-      moves[index++] = (move){.From = i, .To = to, .Promo=0};
-      if (occupiedE & lbit)
-        break;
-    }
-  }
-  return index;
-}
-
-int queenMove(game *g, move *moves){
-  int size = 0;
-  long long w,b;
-  w = g->white.queen;
-  b = g->black.queen;
-  size += rookScan(g,moves,w,b);
-  size += bishopScan(g,(moves+size),w,b);
-  return size;
-}
-
-
-int kingMove(game *g, move *moves){
-  long long king = g->whiteToMove ? g->white.king : g->black.king;
-  long long occupied = g->whiteToMove ? fullSet(&g->white) : fullSet(&g->black);
-  int index = 0;
-
-  for (int i = 0; i < 64; i++){
-    long long bit = 1LL << i;
-    int x = i % 8;
-    int y = i / 8;
-    int movesX[] = {-1, 0, 1, -1, 1, -1, 0, 1};
-    int movesY[] = {-1, -1, -1, 0, 0, 1, 1, 1};
-
-    if(!(king & bit))
-      continue;
-
-    for (int j = 0; j < 8; ++j) {
-      int toX = x + movesX[j];
-      int toY = y + movesY[j];
-      int to = (toY * 8) + toX;
-      long long destBit = 1LL << to;
-
-      if (toX >= 0 && toX < 8 && toY >= 0 && toY < 8) {
-        if (!(occupied & destBit)) {
-          moves[index++] = (move){.From = i, .To = to, .Promo=0};
-        }
-      }
-    }
-  }
-  return index;
-}

src/types.zig

@@ -0,0 +1,47 @@
+const c = @cImport({
+    @cInclude("main.h");
+    @cInclude("types.h");
+    @cInclude("help.h");
+    @cInclude("eval.h");
+    @cInclude("moves.h");
+});
+
+const uciTag = enum {
+    text,
+    move,
+    game,
+    exit,
+    pass,
+};
+
+pub const uciRet = union(uciTag) {
+    text: []const u8,
+    move: []u8,
+    game: *game,
+    exit: void,
+    pass: void,
+};
+
+pub const set = struct {
+    pawns: u64,
+    knights: u64,
+    bishops: u64,
+    rooks: u64,
+    queen: u64,
+    king: u64,
+};
+pub const game = struct {
+    black: set,
+    white: set,
+    whiteToMove: bool,
+};
+pub const move = struct {
+    From: u32,
+    To: u32,
+    Promo: u8,
+};
+// struct {
+//     To: u8,
+//     From: u8,
+//     Promo: u8,
+// };

uchess.json

@@ -5,12 +5,12 @@
     "uciEngines": [
 	{
 	    "name":"rat",
-	    "engine":"./a.out",
+	    "engine":"./zig-out/bin/RatChess",
 	    "ponder":false
 	},
         {
             "name": "stockfish",
-            "engine": "/nix/store/5d7aqjdak73qlsimiismbj0m1h9b566j-stockfish-17/bin/stockfish",
+	    "engine": "/nix/store/xrzjqi5m9yphj4p5wgpvnamxs38ap0wv-stockfish-17/bin/stockfish",
             "hash": 128,
             "ponder": false,
             "ownBook": false,