k/RatChess
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: k:zig
Branches Tags
k:main
k:zig
..
compare: k:main
Branches Tags
k:zig
k:main

No commits in common. "zig" and "main" have entirely different histories.
zig ... main

19 changed files with 681 additions and 562 deletions
Show Stats Expand all files Collapse all files

13
.gitea/workflows/nix-check.yaml
View File

@ -1,13 +0,0 @@
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

3
.gitignore vendored
View File

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

5
README.md
View File

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

29
build.zig
View File

@ -1,29 +0,0 @@
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);
}

86
build.zig.zon
View File

@ -1,86 +0,0 @@
.{
// 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",
},
}

33
default.nix
View File

@ -1,33 +0,0 @@
# 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;
}

5
headers/eval.h Normal file
View File

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

11
headers/help.h Normal file
View File

@ -0,0 +1,11 @@
#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

10
headers/moves.h Normal file
View File

@ -0,0 +1,10 @@
#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

26
headers/types.h Normal file
View File

@ -0,0 +1,26 @@
#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

6
shell.nix
View File

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

109
src/eval.c Normal file
View File

@ -0,0 +1,109 @@
#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;
}

87
src/help.c Normal file
View File

@ -0,0 +1,87 @@
#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;
}
}

140
src/main.c Normal file
View File

@ -0,0 +1,140 @@
#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);
}
}

152
src/main.zig
View File

@ -1,152 +0,0 @@
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);
}

191
src/move.zig
View File

@ -1,191 +0,0 @@
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;
}
}

286
src/moves.c Normal file
View File

@ -0,0 +1,286 @@
#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;
}

47
src/types.zig
View File

@ -1,47 +0,0 @@
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,
// };

4
uchess.json
View File

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