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

Compare commits

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

No commits in common. "d6fa80950550fef630f0d48e9206c9ce48866477" and "da8eb581e3c936843403ab71edea819b164ab9f0" have entirely different histories.
d6fa809505 ... da8eb581e3

7 changed files with 36 additions and 136 deletions
Show Stats Expand all files Collapse all files

2
headers/eval.h
View File

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

4
headers/help.h
View File

@ -5,7 +5,7 @@
long long fullSet(sets *s);
long long fullSetBoth(game *g);
void print_bitboard(long long bitboard);
unsigned long long *findSet(game *g, long long bit);
unsigned long long *charToSet(game *g, char c);
long long *findSet(game *g, long long bit);
long long *charToSet(game *g, char c);
#endif

2
headers/main.h
View File

@ -4,7 +4,7 @@
int cmain();
game *fenGame(char *str);
game *playMoves(game *g, char *moves);
void playMoves(game *g, char *moves);
char* uciGo(game *g);
#endif

13
src/main.c
View File

@ -15,7 +15,9 @@
#define BUFF_SIZE 4096
game *fenGame(char *str);
game *playMoves(game *g, char *moves);
void playMoves(game *g, char *moves);
long long *findSet(game *g, long long bit);
long long *charToSet(game *g, char c);
int cmain() {
setbuf(stdin, NULL);
@ -71,8 +73,8 @@ char* uciGo(game *g){
cnt += queenMove(g,(mov+cnt));
move *m = findBest(mov,cnt,g);
if(m == NULL){
//printf("bestmove 0000\n");
return "0000";
printf("bestmove 0000\n");
return "";
}
char *end = "";
@ -121,7 +123,7 @@ game *fenGame(char *str) {
}
long long bit = 1ULL << (rank * 8 + file);
unsigned long long *set = charToSet(g, *str);
long long *set = charToSet(g, *str);
if (set)
*set |= bit;
file++;
@ -132,7 +134,7 @@ game *fenGame(char *str) {
return g;
}
game* playMoves(game *g, char *moves) {
void playMoves(game *g, char *moves) {
char *moveStr;
moveStr = strtok_r(moves, " ", &moves);
moveStr = strtok_r(moves, " ", &moves);
@ -144,6 +146,5 @@ game* playMoves(game *g, char *moves) {
makeMove(g, &m);
moveStr = strtok_r(moves, " ", &moves);
}
return g;
}

119
src/main.zig
View File

@ -1,11 +1,7 @@
const std = @import("std");
const mov = @import("move.zig");
const c = @cImport({
@cInclude("main.h");
@cInclude("types.h");
@cInclude("help.h");
@cInclude("eval.h");
@cInclude("moves.h");
});
const uciTag = enum {
@ -18,7 +14,7 @@ const uciTag = enum {
const uciRet = union(uciTag) {
text: []const u8,
move: []u8,
move: []const u8,
game: *c.game,
exit: void,
pass: void,
@ -31,21 +27,18 @@ pub fn main() !void {
const stdin = std.io.getStdIn();
var reader = stdin.reader();
var game: *c.game = uciPos("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1", alloc);
defer alloc.destroy(game);
var game: *c.game = uciPos("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
while (true) {
const line = try reader.readUntilDelimiterAlloc(alloc, '\n', std.math.maxInt(usize));
defer alloc.free(line);
switch (uci(line, game, alloc)) {
switch (uci(line, game)) {
.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 => {
@ -58,119 +51,51 @@ pub fn main() !void {
}
}
fn uci(str: []const u8, game: *c.game, alloc: std.mem.Allocator) uciRet {
fn uci(str: []const u8, game: *c.game) 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, "go")) return .{ .move = uciGo(game) };
if (std.mem.eql(u8, tok, "position")) return .{ .game = uciPos("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1") };
if (std.mem.eql(u8, tok, "exit")) return .{ .exit = {} };
return .{ .pass = {} };
}
fn uciPos(str: []const u8, alloc: std.mem.Allocator) *c.game {
const pos = std.mem.indexOfAny(u8, str, " \t\n\r") orelse str.len;
const tok = str[0..pos];
//var game = fenGame("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1", alloc);
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 = 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 uciPos(str: []const u8) [*c]c.game {
var buffer: [256]u8 = undefined;
const len = @min(str.len, buffer.len - 1);
@memcpy(buffer[0..len], str[0..len]);
buffer[len] = 0;
fn fenGame(str: []const u8, alloc: std.mem.Allocator) [*c]c.game {
var pos: u8 = 0;
var space: u8 = 0;
const g = alloc.create(c.game) catch return null;
for (str) |chr| {
if (pos > 64) {
if (chr == ' ') space += 1;
if (space == 1 and chr == 'b') g.whiteToMove = false;
if (space == 1 and chr == 'w') g.whiteToMove = true;
continue;
}
if (std.ascii.isDigit(chr)) pos += @truncate(chr - '0');
if (chr == '/') continue;
const set: [*c]c_ulonglong = c.charToSet(g, chr);
const bit: u64 = @as(u64, 1) << @truncate(pos);
if (set != null)
set.* |= @as(c_ulonglong, bit);
pos += 1;
}
return g;
}
fn playMoves(game: [*c]c.game, str: []const u8) [*c]c.game {
if (str.len < 4) return game;
var splitItr = std.mem.splitSequence(u8, str, " ");
while (splitItr.next()) |moveString| {
var move: c.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;
c.makeMove(game, &move);
}
const game = c.fenGame(&buffer);
return game;
}
fn uciGo(game: *c.game, alloc: std.mem.Allocator) []u8 {
var moves = std.ArrayList(c.move).init(alloc);
defer moves.deinit();
const str = alloc.alloc(u8, 5) catch unreachable;
const m = c.move{ .From = 0, .To = 8, .Promo = 0 };
moves.append(m) catch return str;
_ = game;
mov.moveTypeToStr(m, str);
return str;
fn uciGo(game: *c.game) []const u8 {
return std.mem.span(c.uciGo(game));
}
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);
const game = uciPos("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
const out = uci("uci", game);
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);
const game = uciPos("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
const out = uci("isready", game);
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);
const game = uciPos("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
const out = uci("go", game);
try std.testing.expect(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);
const game = uciPos("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
const out = uci("position startpos", game);
try std.testing.expect(out == .game);
try std.testing.expect(out.game.whiteToMove == true);
}

25
src/move.zig
View File

@ -1,25 +0,0 @@
const std = @import("std");
const c = @cImport({
@cInclude("main.h");
@cInclude("types.h");
@cInclude("help.h");
@cInclude("eval.h");
@cInclude("moves.h");
});
pub fn moveTypeToStr(move: c.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 pawnMove(arr: std.ArrayList(c.move)) void {
// const move = c.move{ .From = 8, .To = 16, .Promo = 0 };
// }

7
src/moves.c
View File

@ -28,22 +28,22 @@ int pawnMove(game *g, move *moves) {
// forword
int to = i + movdir;
p = (promo & (1ULL << to)) ? 'q' : 0;
if (to >= 0 && to < 64 && !(occupied & (1ULL << to))) {
p = (promo & (1ULL << to)) ? 'q' : 0;
moves[index++] = (move){.From = i, .To = to, .Promo = p};
}
// left
to = i + capLeft;
p = (promo & (1ULL << to)) ? 'q' : 0;
if (i % 8 > 0 && (to >= 0 && to < 64) && (enemy & (1ULL << to))) {
p = (promo & (1ULL << to)) ? 'q' : 0;
moves[index++] = (move){.From = i, .To = to, .Promo = p};
}
// right
to = i + capRight;
p = (promo & (1ULL << to)) ? 'q' : 0;
if (i % 8 < 7 && (to >= 0 && to < 64) && (enemy & (1ULL << to))) {
p = (promo & (1ULL << to)) ? 'q' : 0;
moves[index++] = (move){.From = i, .To = to, .Promo = p};
}
}
@ -78,7 +78,6 @@ int knightMove(game *g, move *moves) {
(fileDiff == 2 && rankDiff == 1)))
continue;
if(to < 0 || to > 63) continue;
long long destBit = 1ULL << to;
if (occupied & destBit)
continue;