bruno/brchess
1
0
Fork 0
Code Issues 10 Projects Releases Wiki Activity
Files
master
brchess/src/uci.c

543 lines
14 KiB
C
Raw Permalink Blame History

/* uci.c - uci protocol
*
* Copyright (C) 2021-2024 Bruno Raoult ("br")
* Licensed under the GNU General Public License v3.0 or later.
* Some rights reserved. See COPYING.
*
* You should have received a copy of the GNU General Public License along with this
* program. If not, see <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#include <brlib.h>
#include "chessdefs.h"
#include "util.h"
#include "position.h"
#include "hist.h"
#include "fen.h"
#include "move-gen.h"
#include "move-do.h"
#include "search.h"
#include "perft.h"
#include "eval-defs.h"
#include "uci.h"
struct command {
char *name; /* command name */
int (*func)(pos_t *, char *); /* function doing the job */
char *doc; /* function doc */
};
int execute_line (pos_t *, struct command *, char *);
struct command *find_command (char *);
/* The names of functions that actually do the stuff.
*/
/* standard UCI commands */
int do_ucinewgame(pos_t *, char *);
int do_uci(pos_t *, char *);
int do_isready(pos_t *, char *);
int do_quit(pos_t *, char *);
int do_setoption(pos_t *, char *);
int do_position(pos_t *, char *);
/* commands *NOT* in UCI standard */
int do_moves(pos_t *, char *);
int do_diagram(pos_t *, char *);
int do_perft(pos_t *, char *);
int do_hist(pos_t *, char *);
int do_help(pos_t *, char *);
struct command commands[] = {
{ "quit", do_quit, "Quit" },
{ "uci", do_uci, "" },
{ "ucinewgame", do_ucinewgame, "" },
{ "isready", do_isready, "" },
{ "setoption", do_setoption, ""},
{ "position", do_position, "position startpos|fen [moves ...]" },
{ "perft", do_perft, "(not UCI) perft [divide] [alt] depth" },
{ "moves", do_moves, "(not UCI) moves ..." },
{ "diagram", do_diagram, "(not UCI) print current position diagram" },
{ "hist", do_hist, "(not UCI) print history states" },
{ "help", do_help, "(not UCI) This help" },
{ "?", do_help, "(not UCI) This help" },
{ NULL, (int(*)()) NULL, NULL }
};
/* Execute a command line. */
int execute_line(pos_t *pos, struct command *command, char *args)
{
return (*command->func)(pos, args);
}
/**
* find_command - lookup UCI command.
* @name: &command string
*
* Look up NAME as the name of a command, and return a pointer to that
* command. Return a NULL pointer if NAME isn't a command name.
*/
struct command *find_command(char *name)
{
register int i;
for (i = 0; commands[i].name; i++)
if (!strcmp(name, commands[i].name))
return commands + i;
return NULL;
}
/*
* int do_eval(__unused pos_t *pos, __unused char *arg)
* {
* eval_t material[2], control[2], mobility[2];
* for (int color = WHITE; color <= BLACK; ++color) {
* material[color] = eval_material(pos, color);
* control[color] = eval_square_control(pos, color);
* mobility[color] = eval_mobility(pos, color);
* printf("%s: material=%d mobility=%d controlled=%d\n",
* color? "Black": "White", material[color],
* mobility[color], control[color]);
* }
* eval_t res = eval(pos);
* printf("eval = %d centipawns\n", res);
* return 1;
* }
*
* int do_simple_eval(__unused pos_t *pos, __unused char *arg)
* {
* eval_t eval = eval_simple(pos);
* printf("eval = %d centipawns\n", eval);
* return 1;
* }
*/
/*
* int do_init(pos_t *pos, __unused char *arg)
* {
* startpos(pos);
* return 1;
* }
*/
/*
* int do_genmoves(pos_t *pos, __unused char *arg)
* {
* moves_gen_all(pos);
* return 1;
* }
*
* int do_prmoves(pos_t *pos, __unused char *arg)
* {
* uint debug_level = debug_level_get();
* debug_level_set(1);
* moves_print(pos, M_PR_SEPARATE | M_PR_NUM | M_PR_LONG);
* debug_level_set(debug_level);
* return 1;
* }
*/
/*
* int do_prmovepos(pos_t *pos, char *arg)
* {
* struct list_head *p_cur, *tmp;
* int movenum = atoi(arg), cur = 0; /\* starts with 0 *\/
* move_t *move;
*
* log_f(1, "%s\n", arg);
* list_for_each_safe(p_cur, tmp, &pos->moves[pos->turn]) {
* move = list_entry(p_cur, move_t, list);
* if (cur++ == movenum) {
* pos_print(move->newpos);
* break;
* }
* }
*
* return 1;
* }
*/
/*
* int do_prpieces(pos_t *pos, __unused char *arg)
* {
* log_f(1, "%s\n", arg);
* pos_pieces_print(pos);
* return 1;
* }
*
* int do_memstats(__unused pos_t *pos,__unused char *arg)
* {
* moves_pool_stats();
* piece_pool_stats();
* pos_pool_stats();
* return 1;
* }
*/
/*
* int do_move(__unused pos_t *pos, __unused char *arg)
* {
* int i = 1, nmove = atoi(arg);
* move_t *move;
* pos_t *newpos;
*
* if (list_empty(&pos->moves[pos->turn])) {
* log_f(1, "No moves list.\n");
* return 0;
* }
* list_for_each_entry(move, &pos->moves[pos->turn], list) {
* if (i == nmove)
* goto doit;
* i++;
* }
* log_f(1, "Invalid <%d> move, should be <1-%d>.\n", nmove, i);
* return 0;
* doit:
* newpos = move_do(pos, move);
* pos_print(newpos);
*
* return 1;
* }
*/
int do_ucinewgame(__unused pos_t *pos, __unused char *arg)
{
pos_clear(pos);
tt_clear();
return 1;
}
int do_uci(__unused pos_t *pos, __unused char *arg)
{
printf("id name brchess " VERSION "\n");
printf("id author Bruno Raoult\n");
printf("option name Hash type spin default %d min %d max %d\n",
hash_tt.mb, HASH_SIZE_MIN, HASH_SIZE_MAX);
if (PST_NB > 1) {
printf("option name pst type combo default %s",
pst_name(pst_current));
for (int i = 0; i < PST_NB; ++i)
printf(" var %s", pst_name(i));
}
printf("\n");
for (int var = 0; var < EV_PARAMS_NB; ++var) {
if (param_setable(var)) {
int ptyp = param_type(var);
int pmin = param_min(var);
int pmax = param_max(var);
int pval = parameters[var];
printf("option name %s ", param_name(var));
switch(ptyp) {
case PAR_BTN:
printf("type button\n");
break;
case PAR_CHK:
printf("type check default %s\n", pval? "true": "false");
break;
case PAR_SPN:
printf("type spin default %d min %d max %d\n", pval, pmin, pmax);
break;
};
}
}
printf("uciok\n");
return 1;
}
int do_isready(__unused pos_t *pos, __unused char *arg)
{
printf("readyok\n");
return 1;
}
int do_setoption(__unused pos_t *pos, __unused char *arg)
{
char *name, *value = NULL;
if (str_token(arg, "name") != arg)
return 1;
if (!(name = str_skip_word(arg)))
return 1;
/* at this point, we got a valid parameter name */
value = str_token(name, "value"); /* put '\0' at name end */
if (value) {
value = str_skip_word(value);
if (!value)
return 1;
}
if (str_eq_case(name, "hash") && value) {
tt_create(atoi(value));
} else if (str_eq_case(name, "pst")) {
pst_set(value);
} else {
int var = param_find_name(name);
if (var < 0) {
printf("wrong parameter '%s'\n", name);
return 1;
}
char *pname = param_name(var);
printf("found param <%s> = %d\n", pname, var);
if (param_setable(var)) {
int ptyp = param_min(var);
int pmin = param_min(var);
int pmax = param_max(var);
int pval;
switch(ptyp) {
case PAR_BTN:
bug_on (value);
printf("do button '%s'\n", pname);
break;
case PAR_CHK:
bug_on (!value);
if (str_eq_case(value, "true"))
pval = 1;
else if (str_eq_case(value, "false"))
pval = 0;
else {
printf("wrong value '%s' to '%s' boolean parameter\n",
value, pname);
return 1;
}
printf("set '%s' to %s\n", pname, pval? "true": "false");
param_set(var, pval);
break;
case PAR_SPN:
bug_on (!value);
pval = clamp(atoi(value), pmin, pmax);
printf("set '%s' to %d\n", param_name(var), pval);
param_set(var, pval);
break;
}
}
}
return 0;
}
int do_position(pos_t *pos, char *arg)
{
char *saveptr, *token, *fen, *moves;
hist_init();
/* separate "moves" section */
moves = str_token(arg, "moves");
saveptr = NULL;
token = strtok_r(arg, " ", &saveptr);
if (!strcmp(token, "startpos")) {
startpos(pos);
do_diagram(pos, "");
} else if (!strcmp(token, "fen")) {
fen = strtok_r(NULL, "", &saveptr); /* full fen (till '\0') */
//printf("fen=%s\n", fen);
if (!fen)
return 1;
if (!fen2pos(pos, fen))
return 1;
//do_diagram(pos, "");
} else {
return 1;
}
//puts("zob");
//move_t move_none = MOVE_NONE;
//hist_push(&pos->state, &move_none);
if (moves) {
//puts("zobi");
saveptr = NULL;
moves = strtok_r(moves, " ", &saveptr); /* skip "moves" */
moves = strtok_r(NULL, "", &saveptr); /* all moves (till '\0') */
//printf("moves = %s\n", moves);
do_moves(pos, moves);
}
/* link last position t history */
//hist_pop();
hist_link(pos);
return 1;
}
int do_moves(__unused pos_t *pos, char *arg)
{
char *saveptr = NULL, *token, check[8];
move_t move;
state_t state;
movelist_t movelist;
saveptr = NULL;
token = strtok_r(arg, " ", &saveptr);
while (token) {
move = move_from_str(token);
move_to_str(check, move, 0);
printf("move: [%s] %s\n", token, check);
pos_set_checkers_pinners_blockers(pos);
pos_legal(pos, pos_gen_pseudo(pos, &movelist));
move = move_find_in_movelist(move, &movelist);
if (move == MOVE_NONE) {
/* should we reset here ? */
return 1;
}
//printf("move: %s\n", move_to_str(check, move, 0));
hist_push(&pos->state); /* push previous state */
move_do(pos, move, &state);
pos_print(pos);
hist_static_print();
token = strtok_r(NULL, " ", &saveptr);
}
//hist_static_print();
return 1;
}
int do_diagram(pos_t *pos, __unused char *arg)
{
pos_print(pos);
return 1;
}
int do_perft(__unused pos_t *pos, __unused char *arg)
{
char *saveptr, *token;
int divide = 0, depth = 6, alt = 0;
token = strtok_r(arg, " ", &saveptr);
if (!strcmp(token, "divide")) {
divide = 1;
token = strtok_r(NULL, " ", &saveptr);
}
if (!strcmp(token, "alt")) {
alt = 1;
token = strtok_r(NULL, " ", &saveptr);
}
depth = atoi(token);
printf("perft: divide=%d alt=%d depth=%d\n", divide, alt, depth);
if (depth > 0) {
if (!alt)
perft(pos, depth, 1, divide);
else
perft_alt(pos, depth, 1, divide);
}
return 1;
}
int do_hist(__unused pos_t *pos, __unused char *arg)
{
hist_static_print();
return 0;
}
int do_help(__unused pos_t *pos, __unused char *arg)
{
for (struct command *cmd = commands; cmd->name; ++cmd) {
printf("%12s:\t%s\n", cmd->name, cmd->doc);
/* Print in six columns. */
}
return 0;
}
/*
* int do_depth(__unused pos_t *pos, char *arg)
* {
* depth = atoi(arg);
* printf("depth = %d\n", depth);
* return 1;
*
* }
*
* int do_search(pos_t *pos, __unused char *arg)
* {
* int debug_level = debug_level_get();
* float timer1, timer2, nodes_sec;
*
* timer1 = debug_timer_elapsed();
* negamax(pos, depth, pos->turn == WHITE ? 1 : -1);
* timer2 = debug_timer_elapsed();
* nodes_sec = (float) pos->node_count / ((float) (timer2 - timer1) / (float)NANOSEC);
* log(1, "best=");
* debug_level_set(1);
* move_print(0, pos->bestmove, 0);
* debug_level_set(debug_level);
* log(1, " negamax=%d\n", pos->bestmove->negamax);
* printf("Depth:%d Nodes:%luK time:%.02fs (%.0f kn/s)\n", depth,
* pos->node_count / 1000, (timer2 - timer1)/NANOSEC, nodes_sec/1000);
* return 1;
* }
*/
/*
* int do_pvs(pos_t *pos, __unused char *arg)
* {
* int debug_level = debug_level_get();
* float timer1, timer2, nodes_sec;
* eval_t _pvs;
*
* timer1 = debug_timer_elapsed();
* moves_gen_eval_sort(pos);
* _pvs = pvs(pos, depth, EVAL_MIN, EVAL_MAX, pos->turn == WHITE ? 1 : -1);
* timer2 = debug_timer_elapsed();
* nodes_sec = (float) pos->node_count / ((float) (timer2 - timer1) / (float)NANOSEC);
* log(1, "best=");
* if (pos->bestmove) {
* debug_level_set(1);
* move_print(0, pos->bestmove, 0);
* debug_level_set(debug_level);
* log(1, " pvs=%d stored=%d\n", _pvs, pos->bestmove->negamax);
* } else {
* log(1, "<no-best-move>");
* }
* printf("Depth:%d Nodes:%luK time:%.02fs (%.0f kn/s)\n", depth,
* pos->node_count / 1000, (timer2 - timer1)/NANOSEC, nodes_sec/1000);
* return 1;
* }
*/
static int done = 0;
int do_quit(__unused pos_t *pos, __unused char *arg)
{
return done = 1;
}
int uci(pos_t *pos)
{
char *str = NULL, *saveptr, *token, *args;
size_t lenstr = 0;
struct command *command;
while (!done && getline(&str, &lenstr, stdin) >= 0) {
str = str_trim(str);
if (! *str)
continue;
token = strtok_r(str, " ", &saveptr);
if (! (command = find_command(token))) {
fprintf(stderr, "Unknown [%s] command. Try 'help'.\n", token);
continue;
}
args = strtok_r(NULL, "", &saveptr);
execute_line(pos, command, args);
}
if (str)
free(str);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink