This commit is contained in:
parent
775228d691
commit
a7c9f4f472
@ -11,13 +11,6 @@ pub fn build(b: *std.Build) void {
|
||||
});
|
||||
|
||||
const exe = b.addExecutable(.{ .name = "RatChess", .root_module = exe_mod });
|
||||
|
||||
exe.linkLibC();
|
||||
exe.addIncludePath(b.path("headers/"));
|
||||
exe.addCSourceFile(.{ .file = b.path("src/eval.c") });
|
||||
exe.addCSourceFile(.{ .file = b.path("src/help.c") });
|
||||
exe.addCSourceFile(.{ .file = b.path("src/main.c") });
|
||||
exe.addCSourceFile(.{ .file = b.path("src/moves.c") });
|
||||
b.installArtifact(exe);
|
||||
|
||||
const run_cmd = b.addRunArtifact(exe);
|
||||
|
||||
@ -1,5 +0,0 @@
|
||||
#ifndef EVAL_H
|
||||
#define EVAL_H
|
||||
move *findBest(move* move, long long size, game* g);
|
||||
void makeMove(game *g, move* m);
|
||||
#endif
|
||||
@ -1,11 +0,0 @@
|
||||
#ifndef HELP_H
|
||||
#define HELP_H
|
||||
#include "types.h"
|
||||
|
||||
unsigned long long fullSet(sets *s);
|
||||
unsigned 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);
|
||||
|
||||
#endif
|
||||
@ -1,10 +0,0 @@
|
||||
#ifndef MAIN_H
|
||||
#define MAIN_H
|
||||
#include "types.h"
|
||||
|
||||
int cmain();
|
||||
game *fenGame(char *str);
|
||||
game *playMoves(game *g, char *moves);
|
||||
char* uciGo(game *g);
|
||||
|
||||
#endif
|
||||
@ -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
|
||||
@ -1,26 +0,0 @@
|
||||
#ifndef TYPES_H
|
||||
#define TYPES_H
|
||||
#include <stdbool.h>
|
||||
|
||||
typedef struct {
|
||||
unsigned long long pawns;
|
||||
unsigned long long knights;
|
||||
unsigned long long bishops;
|
||||
unsigned long long rooks;
|
||||
unsigned long long queen;
|
||||
unsigned long long king;
|
||||
} sets;
|
||||
|
||||
typedef struct {
|
||||
sets white;
|
||||
sets black;
|
||||
bool whiteToMove;
|
||||
} game;
|
||||
|
||||
typedef struct {
|
||||
int From;
|
||||
int To;
|
||||
char Promo;
|
||||
} move;
|
||||
|
||||
#endif
|
||||
109
src/eval.c
109
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) {
|
||||
unsigned long long from_bit = 1ULL << m->From;
|
||||
unsigned long long to_bit = 1ULL << m->To;
|
||||
|
||||
unsigned long long *set = findSet(g, from_bit);
|
||||
if (!set)
|
||||
return;
|
||||
*set &= ~from_bit;
|
||||
|
||||
unsigned long long *captured = findSet(g, to_bit);
|
||||
if (captured) *captured &= ~to_bit;
|
||||
|
||||
if (m->Promo) {
|
||||
char promoChar = g->whiteToMove ? toupper(m->Promo) : m->Promo;
|
||||
unsigned 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
87
src/help.c
@ -1,87 +0,0 @@
|
||||
#include <stdio.h>
|
||||
#include "types.h"
|
||||
|
||||
unsigned long long fullSet(sets *s) {
|
||||
return s->bishops | s->king | s->knights | s->pawns | s->queen | s->rooks;
|
||||
}
|
||||
|
||||
unsigned 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");
|
||||
}
|
||||
|
||||
unsigned 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;
|
||||
}
|
||||
}
|
||||
|
||||
unsigned 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;
|
||||
}
|
||||
}
|
||||
149
src/main.c
149
src/main.c
@ -1,149 +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"
|
||||
#include "main.h"
|
||||
|
||||
#define BUFF_SIZE 4096
|
||||
|
||||
game *fenGame(char *str);
|
||||
game *playMoves(game *g, char *moves);
|
||||
|
||||
int cmain() {
|
||||
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)) {
|
||||
uciGo(g);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
char* uciGo(game *g){
|
||||
char ltz[] = "abcdefgh";
|
||||
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");
|
||||
return "0000";
|
||||
}
|
||||
|
||||
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";
|
||||
}
|
||||
|
||||
char* resultString = (char*)malloc(10 * sizeof(char));
|
||||
sprintf(resultString, "%c%d%c%d%s", ltz[xFrom], yFrom, ltz[xTo], yTo, end);
|
||||
return resultString;
|
||||
}
|
||||
|
||||
|
||||
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 = 1ULL << (rank * 8 + file);
|
||||
unsigned long long *set = charToSet(g, *str);
|
||||
if (set)
|
||||
*set |= bit;
|
||||
file++;
|
||||
str++;
|
||||
}
|
||||
str++;
|
||||
g->whiteToMove = (*str == 'w') ? true : false;
|
||||
return g;
|
||||
}
|
||||
|
||||
game* 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);
|
||||
}
|
||||
return g;
|
||||
}
|
||||
|
||||
91
src/move.zig
91
src/move.zig
@ -1,12 +1,5 @@
|
||||
const std = @import("std");
|
||||
const types = @import("types.zig");
|
||||
const c = @cImport({
|
||||
@cInclude("main.h");
|
||||
@cInclude("types.h");
|
||||
@cInclude("help.h");
|
||||
@cInclude("eval.h");
|
||||
@cInclude("moves.h");
|
||||
});
|
||||
|
||||
pub fn moveTypeToStr(move: types.move, buf: []u8) void {
|
||||
const xTo = @mod(move.To, 8);
|
||||
@ -32,11 +25,66 @@ pub fn playMoves(game: *types.game, str: []const u8) *types.game {
|
||||
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(@ptrCast(game), @ptrCast(&move));
|
||||
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,
|
||||
@ -62,6 +110,31 @@ pub fn charToSet(g: *types.game, chr: u8) *u64 {
|
||||
// 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;
|
||||
@ -71,7 +144,7 @@ pub fn knightMove(g: *types.game, arr: *std.ArrayList(types.move)) void {
|
||||
break :blk value;
|
||||
};
|
||||
const set = if (g.whiteToMove) &g.white.knights else &g.black.knights;
|
||||
const fset: u64 = if (g.whiteToMove) @as(u64, c.fullSet(@ptrCast(&g.white))) else @as(u64, c.fullSet(@ptrCast(&g.black)));
|
||||
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) |_| {
|
||||
|
||||
289
src/moves.c
289
src/moves.c
@ -1,289 +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 = (0xFFULL) << (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 = 1ULL << i;
|
||||
char p = 0;
|
||||
if (!(pawns & bit))
|
||||
continue;
|
||||
|
||||
// forword
|
||||
int to = i + movdir;
|
||||
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;
|
||||
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;
|
||||
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};
|
||||
}
|
||||
}
|
||||
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 = 1ULL << 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;
|
||||
|
||||
if(to < 0 || to > 63) continue;
|
||||
long long destBit = 1ULL << 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 = 1ULL << 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 = 1ULL << 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 = 1ULL << 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 = 1ULL << 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 = 1ULL << 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) {
|
||||
unsigned long long bishops = g->whiteToMove ? w : b;
|
||||
unsigned long long occupied = g->whiteToMove ? fullSet(&g->white) : fullSet(&g->black);
|
||||
unsigned long long occupiedE =
|
||||
!g->whiteToMove ? fullSet(&g->white) : fullSet(&g->black);
|
||||
int index = 0;
|
||||
|
||||
for (int i = 0; i < 64; i++) {
|
||||
unsigned long long bit = 1ULL << 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;
|
||||
unsigned long long lbit = 1ULL << 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;
|
||||
unsigned long long lbit = 1ULL << 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;
|
||||
unsigned long long lbit = 1ULL << 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;
|
||||
unsigned long long lbit = 1ULL << 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;
|
||||
unsigned 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){
|
||||
unsigned long long king = g->whiteToMove ? g->white.king : g->black.king;
|
||||
unsigned long long occupied = g->whiteToMove ? fullSet(&g->white) : fullSet(&g->black);
|
||||
int index = 0;
|
||||
|
||||
for (int i = 0; i < 64; i++){
|
||||
unsigned long long bit = 1ULL << 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;
|
||||
if(to > 63 || to < 1)
|
||||
continue;
|
||||
unsigned long long destBit = 1ULL << to;
|
||||
|
||||
if (toX >= 0 && toX < 8 && toY >= 0 && toY < 8) {
|
||||
if (!(occupied & destBit)) {
|
||||
moves[index++] = (move){.From = i, .To = to, .Promo=0};
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return index;
|
||||
}
|
||||
@ -21,7 +21,8 @@ pub const uciRet = union(uciTag) {
|
||||
exit: void,
|
||||
pass: void,
|
||||
};
|
||||
const set = struct {
|
||||
|
||||
pub const set = struct {
|
||||
pawns: u64,
|
||||
knights: u64,
|
||||
bishops: u64,
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user