bruno/brchess
1
0
Fork 0
Code Issues 9 Projects Releases Wiki Activity

Compare commits

base: bruno:tt
Branches Tags
bruno:master bruno:hash bruno:search bruno:thread bruno:tt bruno:movegen-review bruno:perft bruno:bitboard-switch bruno:brlib-switch
...
compare: bruno:c5a1936e3b4451101da34615d8355c4ec244ab0b
Branches Tags
bruno:hash bruno:master bruno:search bruno:thread bruno:tt bruno:movegen-review bruno:perft bruno:bitboard-switch bruno:brlib-switch

21 Commits
tt ... c5a1936e3b

Author SHA1 Message Date
Bruno Raoult
c5a1936e3b UCI moves && games states list 2024-06-27 10:11:24 +02:00
Bruno Raoult
46aed01079 hash: add hash_short macro, state_s: add prev and move 2024-06-27 08:36:08 +02:00
Bruno Raoult
ffd5d056cc move_t flags: mask -> value, unique castling flag (1 bit saved) 2024-06-25 15:33:56 +02:00
Bruno Raoult
5cb90f5396 remove move-test 2024-06-25 13:16:47 +02:00
Bruno Raoult
da489bad65 update include syntax 2024-06-25 13:07:33 +02:00
Bruno Raoult
f4280dfa13 perft-test: add error and skipped counts 2024-06-24 09:01:55 +02:00
Bruno Raoult
d1cc7a8066 movegen: cleanup + change casling/king moves handling 2024-06-24 09:00:24 +02:00
Bruno Raoult
cfa8b42077 add UCI "perft_alt" command 2024-06-24 08:52:23 +02:00
Bruno Raoult
0c2d30c938 put back bug_on() following brlib change 2024-06-23 19:52:59 +02:00
Bruno Raoult
3a6c1d11c0 rename util.h -> misc.h (2) 2024-06-23 19:22:22 +02:00
Bruno Raoult
a7311a546f add perf target 2024-06-23 19:16:05 +02:00
Bruno Raoult
84b6c41107 update brlib 2024-06-23 19:15:34 +02:00
Bruno Raoult
19d10fdfa8 rename util.h -> misc.h 2024-06-23 19:15:14 +02:00
Bruno Raoult
6e38de58cb brchess: remove any readline dependancy (issue with static linking) 2024-06-22 21:06:06 +02:00
Bruno Raoult
0c15be28b1 remove bug.h include in any .h file 2024-06-20 09:13:28 +02:00
Bruno Raoult
879bda850c pos_ok, remove unused var warnings for 'release' target 2024-06-20 09:04:54 +02:00
Bruno Raoult
0a0c3227b8 Makefile: add release & dev targets 2024-06-20 09:04:28 +02:00
Bruno Raoult
242b501404 cleanup 2024-06-20 05:36:42 +02:00
Bruno Raoult
f530a13481 prepare brchess, eval, eval-simple for future use 2024-06-19 11:01:48 +02:00
Bruno Raoult
243805f11f add git-split.sh (NOT WORKING!) 2024-06-18 06:38:04 +02:00
Bruno Raoult
ae198c891f Merge branch 'tt' 2024-06-17 07:51:45 +02:00
27 changed files with 1241 additions and 932 deletions
Expand all files Collapse all files

207
Makefile
View File

@@ -11,9 +11,17 @@
#
SHELL := /bin/bash
CC := gcc
#CC := gcc-13
#CC := clang
ifeq ($(CC),)
CC = gcc
endif
ifeq ($(CC),cc)
CC = gcc
endif
ifeq ($(BUILD),)
BUILD = perf
endif
BEAR := bear
TOUCH := touch
RM := rm
@@ -41,7 +49,7 @@ OBJ := $(addprefix $(OBJDIR)/,$(SRC_FN:.c=.o))
TSTSRC := $(wildcard $(TSTDIR)/*.c)
LIB := br_$(shell uname -m) # library name
LIBS := $(strip -l$(LIB) -lreadline)
LIBS := $(strip -l$(LIB))
DEP_FN := $(SRC_FN)
DEP := $(addprefix $(DEPDIR)/,$(DEP_FN:.c=.d))
@@ -52,34 +60,60 @@ TARGET := $(addprefix $(BINDIR)/,$(TARGET_FN))
ASMFILES := $(SRC:.c=.s) $(TSTSRC:.c=.s)
CPPFILES := $(SRC:.c=.i) $(TSTSRC:.c=.i)
##################################### set a version string
# inspired from:
# https://eugene-babichenko.github.io/blog/2019/09/28/nightly-versions-makefiles/
# last commit and date
COMMIT := $(shell git rev-parse --short HEAD)
DATE := $(shell git log -1 --format=%cd --date=format:"%Y%m%d")
# get last commit w/ tag & associated tag, if any
TAG_COMM := $(shell git rev-list --abbrev-commit --tags --max-count=1)
ifneq ($(TAG_COMMIT),)
TAG := $(shell git describe --abbrev=0 --tags ${TG_COMM} 2>/dev/null || true)
VERSION := $(TAG:v%=%)
endif
# if no version, use last commit and date.
# else, if last commit != last tag commit, add commit and date to version number
ifeq ($(VERSION),)
VERSION := build-$(COMMIT)-$(DATE)
else ifneq ($(COMMIT), $(TAG_COMMIT))
VERSION := $(VERSION)-next-$(COMMIT)-$(DATE)
endif
# if uncommited changes, add "dirty" indicator
ifneq ($(shell git status --porcelain),)
VERSION := $(VERSION)-dirty
endif
##################################### pre-processor flags
CPPFLAGS := -I$(BRINCDIR) -I$(INCDIR)
CPPFLAGS := -I$(BRINCDIR) -I$(INCDIR) -DVERSION=\"$(VERSION)\"
CPPFLAGS += -DNDEBUG # assert (unused)
CPPFLAGS += -DWARN_ON # brlib bug.h
CPPFLAGS += -DBUG_ON # brlib bug.h
ifeq ($(BUILD),release)
CPPFLAGS += -DNDEBUG # assert (unused)
else # ifeq ($(BUILD),dev)
CPPFLAGS += -DWARN_ON # brlib bug.h
CPPFLAGS += -DBUG_ON # brlib bug.h
#CPPFLAGS += -DDEBUG # global - unused
#CPPFLAGS += -DDEBUG_DEBUG # enable log() functions
#CPPFLAGS += -DDEBUG_DEBUG_C # enable log() settings
#CPPFLAGS += -DDEBUG_POOL # memory pools management
#CPPFLAGS += -DDEBUG_POS # position.c
#CPPFLAGS += -DDEBUG_MOVE # move generation
# fen.c
#CPPFLAGS += -DDEBUG_FEN # FEN decoding
# hash / TT
#CPPFLAGS += -DZOBRIST_VERIFY # double chk zobrist
#CPPFLAGS += -DPERFT_MOVE_HISTORY # perft, keep prev moves
# attack.c
#CPPFLAGS += -DDEBUG_ATTACK_ATTACKERS # sq_attackers
#CPPFLAGS += -DDEBUG_ATTACK_PINNERS # sq_pinners details
#CPPFLAGS += -DDEBUG_EVAL # eval functions
#CPPFLAGS += -DDEBUG_PIECE # piece list management
#CPPFLAGS += -DDEBUG_SEARCH # move search
#CPPFLAGS += -DDEBUG # global - unused
#CPPFLAGS += -DDEBUG_DEBUG # enable log() functions
#CPPFLAGS += -DDEBUG_DEBUG_C # enable log() settings
#CPPFLAGS += -DDEBUG_POOL # memory pools management
#CPPFLAGS += -DDEBUG_POS # position.c
#CPPFLAGS += -DDEBUG_MOVE # move generation
# fen.c
#CPPFLAGS += -DDEBUG_FEN # FEN decoding
# hash / TT
#CPPFLAGS += -DZOBRIST_VERIFY # double chk zobrist
#CPPFLAGS += -DPERFT_MOVE_HISTORY # perft, keep prev moves
# attack.c
#CPPFLAGS += -DDEBUG_ATTACK_ATTACKERS # sq_attackers
#CPPFLAGS += -DDEBUG_ATTACK_PINNERS # sq_pinners details
# CPPFLAGS += -DDEBUG_EVAL # eval functions
#CPPFLAGS += -DDEBUG_PIECE # piece list management
#CPPFLAGS += -DDEBUG_SEARCH # move search
endif
CPPFLAGS += -DDIAGRAM_SYM # UTF8 symbols in diagrams
@@ -89,41 +123,49 @@ CPPFLAGS := $(strip $(CPPFLAGS))
##################################### compiler flags
CFLAGS := -std=gnu11
### dev OR release
# dev
CFLAGS += -g # symbols (gdb, perf, etc.)
CFLAGS += -ginline-points # inlined funcs debug info
#CFLAGS += -Og
# for gprof
#CFLAGS += -pg
# Next one may be useful for valgrind (when invalid instructions)
#CFLAGS += -mno-tbm
# release
CFLAGS += -O3
CFLAGS += -march=native
CFLAGS += -flto
CFLAGS += -funroll-loops
CFLAGS += -Wall
CFLAGS += -Wextra
CFLAGS += -Wshadow
CFLAGS += -Wmissing-declarations
CFLAGS += -march=native
### dev OR release
ifeq ($(BUILD),release)
CFLAGS += -O3
CFLAGS += -g
CFLAGS += -ginline-points # inlined funcs debug info
CFLAGS += -funroll-loops
CFLAGS += -flto
else ifeq ($(BUILD),dev)
CFLAGS += -Og
CFLAGS += -g # symbols (gdb, perf, etc.)
CFLAGS += -ginline-points # inlined funcs debug info
#CFLAGS += -pg # gprof
# Next one may be useful for valgrind (when invalid instructions)
#CFLAGS += -mno-tbm
else ifeq ($(BUILD),perf)
CFLAGS += -O3
CFLAGS += -g # symbols (gdb, perf, etc.)
CFLAGS += -ginline-points # inlined funcs debug info
CFLAGS += -funroll-loops
else ifeq ($(BUILD),debug)
CFLAGS += -O0
CFLAGS += -g # symbols (gdb, perf, etc.)
# for gprof
#CFLAGS += -pg
# Next one may be useful for valgrind (when invalid instructions)
#CFLAGS += -mno-tbm
endif
CFLAGS := $(strip $(CFLAGS))
# development CFLAGS - unused - TODO
#DEV_CFLAGS := -Og
#DEV_CFLAGS += -g
# release CFLAGS - unused - TODO
#REL_CFLAGS := -Ofast
##################################### linker flags
LDFLAGS := --static
LDFLAGS += -L$(BRLIBDIR)
LDFLAGS += -flto
ifeq ($(BUILD),release)
LDFLAGS += -flto
endif
LDFLAGS := $(strip $(LDFLAGS))
@@ -168,9 +210,21 @@ $(sort all $(MAKECMDGOALS)):
else
##################################### General targets
.PHONY: all compile clean cleanall
.PHONY: all release dev perf debug compile clean cleanall
all: $(TARGET)
all: testing $(TARGET)
release:
$(MAKE) BUILD=release clean all
dev:
$(MAKE) BUILD=dev clean all
perf:
$(MAKE) BUILD=perf clean all
debug:
$(MAKE) BUILD=debug clean all
compile: brlib objs
@@ -286,7 +340,7 @@ cleanbindir:
$(call rmdir,$(BINDIR),binaries)
$(TARGET): libs $(OBJ) | $(BINDIR)
@echo generating $@.
@echo linking $@.
$(CC) $(LDFLAGS) $(OBJ) $(LIBS) -o $@
##################################### pre-processed (.i) and assembler (.s) output
@@ -301,7 +355,7 @@ cleanasmcpp:
%.s: %.c
@echo "generating $@ (asm)."
@$(CC) -S -fverbose-asm $(CPPFLAGS) $(CFLAGS) $< -o $@
$(CC) -S -fverbose-asm $(CPPFLAGS) $(CFLAGS) $< -o $@
##################################### LSP (ccls)
.PHONY: ccls
@@ -319,7 +373,7 @@ $(CCLSROOT):
# maybe run cleanobj cleanlibobj in commands ?
$(CCLSFILE): cleanobj cleanbrlib libs | $(CCLSROOT)
@echo "Generating ccls compile commands file ($@)."
@$(BEAR) -- $(MAKE) testing
@$(BEAR) -- $(MAKE)
##################################### valgrind (mem check)
.PHONY: memcheck
@@ -344,11 +398,11 @@ TEST += movedo-test perft-test tt-test
PIECE_OBJS := piece.o
FEN_OBJS := $(PIECE_OBJS) fen.o position.o bitboard.o board.o \
hyperbola-quintessence.o attack.o hash.o init.o
hyperbola-quintessence.o attack.o hash.o init.o misc.o
BB_OBJS := $(FEN_OBJS)
MOVEGEN_OBJS := $(BB_OBJS) move.o move-gen.o
ATTACK_OBJS := $(MOVEGEN_OBJS)
MOVEDO_OBJS := $(ATTACK_OBJS) move-do.o misc.o
MOVEDO_OBJS := $(ATTACK_OBJS) move-do.o
PERFT_OBJS := $(MOVEDO_OBJS) search.o
TT_OBJS := $(MOVEDO_OBJS)
@@ -370,46 +424,47 @@ test:
testing: $(TEST)
bin/piece-test: test/piece-test.c $(FEN_OBJS)
@echo compiling $@ test executable.
@echo linking $@ test executable.
@$(CC) $(ALL_CFLAGS) $< $(FEN_OBJS) $(ALL_LDFLAGS) -o $@
bin/fen-test: test/fen-test.c test/common-test.h $(FEN_OBJS)
@echo compiling $@ test executable.
@echo linking $@ test executable.
@$(CC) $(ALL_CFLAGS) $< $(FEN_OBJS) $(ALL_LDFLAGS) -o $@
bin/bitboard-test: test/bitboard-test.c test/common-test.h $(BB_OBJS)
@echo compiling $@ test executable.
@echo linking $@ test executable.
@$(CC) $(ALL_CFLAGS) $< $(BB_OBJS) $(ALL_LDFLAGS) -o $@
bin/movegen-test: test/movegen-test.c test/common-test.h $(MOVEGEN_OBJS)
@echo compiling $@ test executable.
@echo linking $@ test executable.
@$(CC) $(ALL_CFLAGS) $< $(MOVEGEN_OBJS) $(ALL_LDFLAGS) -o $@
bin/attack-test: test/attack-test.c test/common-test.h $(ATTACK_OBJS)
@echo compiling $@ test executable.
@echo linking $@ test executable.
@$(CC) $(ALL_CFLAGS) $< $(ATTACK_OBJS) $(ALL_LDFLAGS) -o $@
bin/movedo-test: test/movedo-test.c test/common-test.h $(MOVEDO_OBJS)
@echo compiling $@ test executable.
@echo linking $@ test executable.
@$(CC) $(ALL_CFLAGS) $< $(MOVEDO_OBJS) $(ALL_LDFLAGS) -o $@
bin/perft-test: test/perft-test.c test/common-test.h $(PERFT_OBJS)
@echo compiling $@ test executable.
@echo linking $@ test executable.
@$(CC) $(ALL_CFLAGS) $< $(PERFT_OBJS) $(ALL_LDFLAGS) -o $@
bin/tt-test: test/tt-test.c test/common-test.h $(TT_OBJS)
@echo compiling $@ test executable.
@echo linking $@ test executable.
@$(CC) $(ALL_CFLAGS) $< $(TT_OBJS) $(ALL_LDFLAGS) -o $@
##################################### Makefile debug
.PHONY: showflags wft
showflags:
@echo CFLAGS: "$(CFLAGS)"
@echo CPPFLAGS: $(CPPFLAGS)
@echo DEPFLAGS: $(DEPFLAGS)
@echo LDFLAGS: $(LDFLAGS)
@echo DEPFLAGS: $(DEPFLAGS)
info:
@printf "CFLAGS: +%s+\n" "$(CFLAGS)"
@printf "CPPFLAGS: +%s+\n" "$(CPPFLAGS)"
@printf "DEPFLAGS: +%s+\n" "$(DEPFLAGS)"
@printf "LDFLAGS: +%s+\n" "$(LDFLAGS)"
@printf "DEPFLAGS: +%s+\n" "$(DEPFLAGS)"
@printf "VERSION: +%s+\n" "$(VERSION)"
wtf:
@printf "BRLIBDIR=%s\n" "$(BRLIBDIR)"
@@ -422,7 +477,7 @@ wtf:
@#echo LIBSRC=$(LIBSRC)
zob:
$(CC) $(LDFLAGS) $(CPPFLAGS) $(CFLAGS) $< $(LIBS) src/util.c -o util
@#$(CC) $(LDFLAGS) $(CPPFLAGS) $(CFLAGS) $< $(LIBS) src/util.c -o util
##################################### End of multi-targets
endif

2
brlib

Submodule brlib updated: 8ff163dcf5...553dc6bd07

35
scripts/git-split.sh Executable file
View File

@@ -0,0 +1,35 @@
#!/usr/bin/env bash
#
# Duplicate file, with history (well, sort of)
#
# Copy a git file, keeping history.
# Sources:
# https://stackoverflow.com/a/53849613/3079831
# https://stackoverflow.com/a/75942970/3079831
CMDNAME=${0##*/} # script name
if (( $# != 2 )); then
printf "Usage: %s original copy\n" "$CMDNAME"
exit 1
fi
from="$1"
to="$2"
branch="split-file"
printf "Dup from=[%s] to=[%s] branch=[%s]\n" "$from" "$to" "$branch"
git checkout -b "$branch" # create and switch to branch
git mv "$from" "$to" # make the duplicate
git commit -m "Duplicate $from to $to"
git checkout HEAD~ "$from" # bring back the original
git commit -m "Restore duplicated $from"
git checkout - # switch back to source branch
git merge --no-ff "$branch" -m "Merge $branch" # merge dup into source branch
exit 0

2
src/bitboard.c
View File

@@ -14,7 +14,7 @@
#include <stdio.h>
#include <stdarg.h>
#include "brlib.h"
#include <brlib.h>
#include "chessdefs.h"
#include "piece.h"

2
src/board.h
View File

@@ -14,7 +14,7 @@
#ifndef _BOARD_H
#define _BOARD_H
#include "brlib.h"
#include <brlib.h>
#include "chessdefs.h"
#include "piece.h"

797
src/brchess.c
View File

@@ -1,6 +1,6 @@
/* brchess.c - main loop.
*
* Copyright (C) 2021-2023 Bruno Raoult ("br")
* Copyright (C) 2021-2024 Bruno Raoult ("br")
* Licensed under the GNU General Public License v3.0 or later.
* Some rights reserved. See COPYING.
*
@@ -12,25 +12,23 @@
*/
#include <err.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <readline/readline.h>
#include <readline/history.h>
#include <ctype.h>
#include <unistd.h>
#include <brlib.h>
#include <list.h>
#include <debug.h>
#include "brchess.h"
#include "chessdefs.h"
#include "board.h"
#include "piece.h"
#include "move.h"
#include "position.h"
#include "brchess.h"
#include "hash.h"
#include "fen.h"
#include "eval.h"
#include "eval-simple.h"
#include "search.h"
#include "hist.h"
#include "move-gen.h"
#include "move-do.h"
struct command {
char *name; /* User printable name */
@@ -38,289 +36,157 @@ struct command {
char *doc; /* function doc */
};
/* readline example inspired by :
* - https://thoughtbot.com/blog/tab-completion-in-gnu-readline
* - http://web.mit.edu/gnu/doc/html/rlman_2.html
*/
char **commands_completion(const char *, int, int);
char *commands_generator(const char *, int);
char *escape(const char *);
int quote_detector(char *, int);
int execute_line (pos_t *, char *line);
int execute_line (pos_t *, struct command *, char *);
struct command *find_command (char *);
char *stripwhite (char *string);
int string_trim (char *str);
/* The names of functions that actually do the manipulation. */
int do_help(pos_t *, char*);
int do_fen(pos_t *, char*);
int do_init(pos_t *, char*);
int do_pos(pos_t *, char*);
int do_genmoves(pos_t *, char*);
int do_prmoves(pos_t *, char*);
//int do_prmovepos(pos_t *pos, char *arg);
int do_prpieces(pos_t *pos, char *arg);
int do_memstats(pos_t *, char*);
int do_eval(pos_t *, char*);
int do_simple_eval(pos_t *, char*);
int do_move(pos_t *, char*);
int do_quit(pos_t *, char*);
int do_debug(pos_t *, char*);
int do_depth(pos_t *, char*);
int do_search(pos_t *, char*);
int do_pvs(pos_t *, char*);
int do_ucinewgame(pos_t *, char *);
int do_uci(pos_t *, char *);
int do_isready(pos_t *, char *);
int do_position(pos_t *, char *);
int do_moves(pos_t *, char *);
int do_diagram(pos_t *, char *);
int do_perft(pos_t *, char *);
int do_help(pos_t *, char *);
int do_quit(pos_t *, char *);
struct command commands[] = {
{ "help", do_help, "Display this text" },
{ "?", do_help, "Synonym for 'help'" },
{ "fen", do_fen, "Set position to FEN" },
{ "init", do_init, "Set position to normal start position" },
{ "pos", do_pos, "Print current position" },
{ "quit", do_quit, "Quit" },
{ "genmove", do_genmoves, "Generate move list for " },
{ "prmoves", do_prmoves, "Print position move list" },
// { "prmovepos", do_prmovepos, "Print Nth move resulting position" },
{ "prpieces", do_prpieces, "Print Pieces (from pieces lists)" },
{ "memstats", do_memstats, "Generate next move list" },
{ "eval", do_eval, "Eval current position" },
{ "simple-eval", do_simple_eval, "Simple eval current position" },
{ "do_move", do_move, "execute nth move on current position" },
{ "debug", do_debug, "Set log level to LEVEL" },
{ "depth", do_depth, "Set search depth to N" },
{ "search", do_search, "Search best move (negamax)" },
{ "pvs", do_pvs, "Search best move (Principal Variation Search)" },
{ "help", do_help, "(not UCI) This help" },
{ "?", do_help, "(not UCI) This help" },
{ "quit", do_quit, "Quit" },
{ "uci", do_uci, "" },
{ "ucinewgame", do_ucinewgame, "" },
{ "isready", do_isready, "" },
{ "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" },
/*
* { "init", do_init, "Set position to normal start position" },
* { "genmove", do_genmoves, "Generate move list for " },
* { "prmoves", do_prmoves, "Print position move list" },
* // { "prmovepos", do_prmovepos, "Print Nth move resulting position" },
* { "prpieces", do_prpieces, "Print Pieces (from pieces lists)" },
* { "memstats", do_memstats, "Generate next move list" },
* { "eval", do_eval, "Eval current position" },
* { "simple-eval", do_simple_eval, "Simple eval current position" },
* { "do_move", do_move, "execute nth move on current position" },
* { "debug", do_debug, "Set log level to LEVEL" },
* { "depth", do_depth, "Set search depth to N" },
* { "search", do_search, "Search best move (negamax)" },
* { "pvs", do_pvs, "Search best move (Principal Variation Search)" },
*/
{ NULL, (int(*)()) NULL, NULL }
};
static int done=0;
static int depth=1;
static int done = 0;
int brchess(pos_t *pos)
{
char *buffer, *s;
char *str = NULL, *saveptr, *token, *args;
int len;
size_t lenstr = 0;
struct command *command;
rl_attempted_completion_function = commands_completion;
rl_completer_quote_characters = "'\"";
rl_completer_word_break_characters = " ";
rl_char_is_quoted_p = &quote_detector;
while (!done) {
buffer = readline("chess> ");
if (!buffer)
break;
/* Remove leading and trailing whitespace from the line.
* Then, if there is anything left, add it to the history list
* and execute it.
*/
s = stripwhite(buffer);
if (*s) {
add_history(s);
execute_line(pos, s);
while (!done && getline(&str, &lenstr, stdin) >= 0) {
if (!(len = string_trim(str)))
continue;
token = strtok_r(str, " ", &saveptr);
if (! (command= find_command(token))) {
fprintf(stderr, "Unknown [%s] command. Try 'help'.\n", token);
continue;
}
free(buffer);
args = strtok_r(NULL, "", &saveptr);
execute_line(pos, command, args);
}
if (str)
free(str);
return 0;
}
//char **commands_completion(const char *text, int start, int end)
char **commands_completion(const char *text, __unused int start, __unused int end)
{
rl_attempted_completion_over = 1;
return rl_completion_matches(text, commands_generator);
}
char *commands_generator(const char *text, int state)
{
static int list_index, len;
char *name;
if (!state) {
list_index = 0;
len = strlen(text);
}
while ((name = commands[list_index++].name)) {
if (rl_completion_quote_character) {
name = strdup(name);
} else {
name = escape(name);
}
if (strncmp(name, text, len) == 0) {
return name;
} else {
free(name);
}
}
return NULL;
}
char *escape(const char *original)
{
size_t original_len;
size_t i, j;
char *escaped, *resized_escaped;
original_len = strlen(original);
if (original_len > SIZE_MAX / 2) {
errx(1, "string too long to escape");
}
if ((escaped = malloc(2 * original_len + 1)) == NULL) {
err(1, NULL);
}
for (i = 0, j = 0; i < original_len; ++i, ++j) {
if (original[i] == ' ') {
escaped[j++] = '\\';
}
escaped[j] = original[i];
}
escaped[j] = '\0';
if ((resized_escaped = realloc(escaped, j)) == NULL) {
free(escaped);
resized_escaped = NULL;
err(1, NULL);
}
return resized_escaped;
}
int quote_detector(char *line, int index)
{
return index > 0
&& line[index - 1] == '\\'
&&!quote_detector(line, index - 1);
}
/* Execute a command line. */
int execute_line(pos_t *pos, char *line)
int execute_line(pos_t *pos, struct command *command, char *args)
{
register int i;
struct command *command;
char *word;
/* Isolate the command word. */
i = 0;
while (line[i] && whitespace(line[i]))
i++;
word = line + i;
while (line[i] && !whitespace(line[i]))
i++;
if (line[i])
line[i++] = '\0';
command = find_command(word);
if (!command) {
fprintf(stderr, "%s: Unknown command.\n", word);
return -1;
}
/* Get argument to command, if any. */
while (whitespace(line[i]))
i++;
word = line + i;
/* return command number */
return (*command->func)(pos, word);
return (*command->func)(pos, args);
}
/* 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. */
/**
* 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) == 0)
return &commands[i];
if (!strcmp(name, commands[i].name))
return commands + i;
return (struct command *)NULL;
return NULL;
}
/* Strip whitespace from the start and end of STRING. Return a pointer
into STRING. */
char *stripwhite(char *string)
{
register char *s, *t;
/*
* 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;
* }
*/
for (s = string; whitespace(*s); s++)
;
/*
* int do_init(pos_t *pos, __unused char *arg)
* {
* startpos(pos);
* return 1;
* }
*/
if (*s == 0)
return s;
t = s + strlen(s) - 1;
while (t > s && whitespace(*t))
t--;
*++t = '\0';
return s;
}
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_fen(pos_t *pos, char *arg)
{
fen2pos(pos, arg);
return 1;
}
int do_init(pos_t *pos, __unused char *arg)
{
pos_startpos(pos);
return 1;
}
int do_pos(pos_t *pos, __unused char *arg)
{
pos_print(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_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)
@@ -342,43 +208,195 @@ int do_prmoves(pos_t *pos, __unused char *arg)
* }
*/
int do_prpieces(pos_t *pos, __unused char *arg)
/*
* 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)
{
log_f(1, "%s\n", arg);
pos_pieces_print(pos);
pos_clear(pos);
tt_clear();
hist_init();
return 1;
}
int do_memstats(__unused pos_t *pos,__unused char *arg)
int do_uci(__unused pos_t *pos, __unused char *arg)
{
moves_pool_stats();
piece_pool_stats();
pos_pool_stats();
printf("id name brchess " VERSION "\n");
printf("id author Bruno Raoult\n");
printf("option option name Hash type spin default %d min %d max %d\n",
hash_tt.mb, HASH_SIZE_MIN, HASH_SIZE_MAX);
printf("uciok\n");
return 1;
}
int do_move(__unused pos_t *pos, __unused char *arg)
int do_isready(__unused pos_t *pos, __unused char *arg)
{
int i = 1, nmove = atoi(arg);
move_t *move;
pos_t *newpos;
printf("readyok\n");
return 1;
}
if (list_empty(&pos->moves[pos->turn])) {
log_f(1, "No moves list.\n");
return 0;
int do_position(pos_t *pos, char *arg)
{
char *saveptr, *token, *fen, *moves;
hist_init();
/* separate "moves" section */
if ((moves = strstr(arg, "moves"))) {
*(moves - 1) = 0;
}
list_for_each_entry(move, &pos->moves[pos->turn], list) {
if (i == nmove)
goto doit;
i++;
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);
fen2pos(pos, fen);
} else {
puts("fuck");
}
log_f(1, "Invalid <%d> move, should be <1-%d>.\n", nmove, i);
if (moves) {
saveptr = NULL;
moves = strtok_r(moves, " ", &saveptr);
moves = strtok_r(NULL, "", &saveptr);
printf("moves = %s\n", moves);
do_moves(pos, moves);
}
return 1;
}
static move_t *move_find_move(move_t target, movelist_t *list)
{
move_t *move = list->move, *last = move + list->nmoves;
for (; move < last; ++move) {
if (move_from(target) == move_from(*move) &&
move_to(target) == move_to(*move) &&
move_to(target) == move_to(*move) &&
move_promoted(target) == move_promoted(*move))
return move;
}
return NULL;
}
int do_moves(__unused pos_t *pos, char *arg)
{
char *saveptr = NULL, *token, check[8];
move_t move, *foundmove;
state_t state;
movelist_t movelist;
saveptr = NULL;
token = strtok_r(arg, " ", &saveptr);
while (token) {
move = move_from_str(pos, 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));
foundmove = move_find_move(move, &movelist);
if (!foundmove) {
printf("illegal move");
return 1;
}
move_do(pos, *foundmove, &state);
hist_push(&state, &move);
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_debug(__unused pos_t *pos, __unused char *arg)
* {
* debug_level_set(atoi(arg));
* return 1;
* }
*/
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;
doit:
newpos = move_do(pos, move);
pos_print(newpos);
return 1;
}
int do_quit(__unused pos_t *pos, __unused char *arg)
@@ -386,101 +404,108 @@ int do_quit(__unused pos_t *pos, __unused char *arg)
return done = 1;
}
int do_debug(__unused pos_t *pos, __unused char *arg)
{
debug_level_set(atoi(arg));
return 1;
}
/*
* 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;
* }
*/
/* Print out help for ARG, or for all of the commands if ARG is
not present. */
int do_help(__unused pos_t *pos, __unused char *arg)
{
int i;
int printed = 0;
/*
* 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;
* }
*/
for (i = 0; commands[i].name; i++) {
if (!*arg || (strcmp(arg, commands[i].name) == 0)) {
printf("%-11.11s%s.\n", commands[i].name, commands[i].doc);
printed++;
/**
* string_trim - cleanup (trim) blank characters in string.
* @str: &string to clean
*
* str is cleaned and packed with the following rules:
* - Leading and trailing blank characters are removed.
* - consecutive blank characters are replaced by one space.
* - non printable characters are removed.
*
* "blank" means characters as understood by isspace(3): space, form-feed ('\f'),
* newline ('\n'), carriage return ('\r'), horizontal tab ('\t'), and vertical
* tab ('\v').
*
* @return: new @str len.
*/
int string_trim(char *str)
{
char *to = str, *from = str;
int state = 1;
while (*from) {
switch (state) {
case 1: /* blanks */
while (*from && isspace(*from))
from++;
state = 0;
break;
case 0: /* token */
while (*from && !isspace(*from)) {
if (isprint(*from))
*to++ = *from;
from++;
}
*to++ = ' ';
state = 1;
}
}
if (!printed) {
printf("No commands match `%s'. Possibilties are:\n", arg);
for (i = 0; commands[i].name; i++) {
/* Print in six columns. */
if (printed == 6) {
printed = 0;
printf("\n");
}
printf("%s\t", commands[i].name);
printed++;
}
if (printed)
printf("\n");
}
return 0;
if (to > str)
to--;
*to = 0;
return to - str;
}
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;
}
/** main()
* options:
int brchess(pos_t *pos)
/**
* usage - brchess usage function.
*
*/
static int usage(char *prg)
@@ -489,24 +514,26 @@ static int usage(char *prg)
return 1;
}
#include <unistd.h>
int main(int ac, char **av)
{
pos_t *pos;
pos_t *pos = pos_new();
int opt;
piece_pool_init();
moves_pool_init();
pos_pool_init();
pos = pos_get();
debug_init(1, stderr, true);
eval_simple_init();
printf("brchess " VERSION "\n");
init_all();
// size_t len = 0;
// char *str = NULL;
//while (getline(&str, &len, stdin) >= 0) {
// printf("[%s] -> ", str);
// int newlen = string_trim(str);
// printf("%d [%s]\n", newlen, str);
//}
//exit(0);
while ((opt = getopt(ac, av, "d:f:")) != -1) {
switch (opt) {
case 'd':
debug_level_set(atoi(optarg));
//debug_level_set(atoi(optarg));
break;
case 'f':
fen2pos(pos, optarg);

7
src/chessdefs.h
View File

@@ -14,7 +14,7 @@
#ifndef _CHESSDEFS_H
#define _CHESSDEFS_H
#include "brlib.h" /* brlib types */
#include <brlib.h> /* brlib types */
#define ONE 1ul
#define U64(const_u64) const_u64##UL
@@ -97,9 +97,10 @@ typedef u64 bitboard_t;
*/
//typedef s32 eval_t;
/* forward enum definition is impossible in C11, to simplify
* cross-dependancies, all important enum are moved here.
/* forward enum definition is impossible in C11.
* To simplify cross-dependancies, all important enum are moved here.
*/
typedef enum {
_SSQUARE_ = -1, /* force signed enum */
A1 = 0, B1, C1, D1, E1, F1, G1, H1,

390
src/eval-simple.c
View File

@@ -1,199 +1,201 @@
/* eval-simple.c - simple position evaluation.
*
* Copyright (C) 2023 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 "br.h"
#include "debug.h"
#include "piece.h"
#include "eval-simple.h"
#include "position.h"
/*
* Tables are from https://www.chessprogramming.org/Simplified_Evaluation_Function
* /\* eval-simple.c - simple position evaluation.
* *
* * Copyright (C) 2023 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>
* *
* *\/
*
* Attention! Tables are black point of view (to be visually easier to read).
*/
static int mg_pawn[] = {
0, 0, 0, 0, 0, 0, 0, 0,
50, 50, 50, 50, 50, 50, 50, 50,
10, 10, 20, 30, 30, 20, 10, 10,
5, 5, 10, 25, 25, 10, 5, 5,
0, 0, 0, 20, 20, 0, 0, 0,
5, -5, -10, 0, 0, -10, -5, 5,
5, 10, 10, -20, -20, 10, 10, 5,
0, 0, 0, 0, 0, 0, 0, 0
};
static int mg_knight[] = {
-50, -40, -30, -30, -30, -30, -40, -50,
-40, -20, 0, 0, 0, 0, -20, -40,
-30, 0, 10, 15, 15, 10, 0, -30,
-30, 5, 15, 20, 20, 15, 5, -30,
-30, 0, 15, 20, 20, 15, 0, -30,
-30, 5, 10, 15, 15, 10, 5, -30,
-40, -20, 0, 5, 5, 0, -20, -40,
-50, -40, -30, -30, -30, -30, -40, -50
};
static int mg_bishop[] = {
-20, -10, -10, -10, -10, -10, -10, -20,
-10, 0, 0, 0, 0, 0, 0, -10,
-10, 0, 5, 10, 10, 5, 0, -10,
-10, 5, 5, 10, 10, 5, 5, -10,
-10, 0, 10, 10, 10, 10, 0, -10,
-10, 10, 10, 10, 10, 10, 10, -10,
-10, 5, 0, 0, 0, 0, 5, -10,
-20, -10, -10, -10, -10, -10, -10, -20
};
static int mg_rook[] = {
0, 0, 0, 0, 0, 0, 0, 0,
5, 10, 10, 10, 10, 10, 10, 5,
-5, 0, 0, 0, 0, 0, 0, -5,
-5, 0, 0, 0, 0, 0, 0, -5,
-5, 0, 0, 0, 0, 0, 0, -5,
-5, 0, 0, 0, 0, 0, 0, -5,
-5, 0, 0, 0, 0, 0, 0, -5,
0, 0, 0, 5, 5, 0, 0, 0
};
static int mg_queen[] = {
-20, -10, -10, -5, -5, -10, -10, -20,
-10, 0, 0, 0, 0, 0, 0, -10,
-10, 0, 5, 5, 5, 5, 0, -10,
-5, 0, 5, 5, 5, 5, 0, -5,
0, 0, 5, 5, 5, 5, 0, -5,
-10, 5, 5, 5, 5, 5, 0, -10,
-10, 0, 5, 0, 0, 0, 0, -10,
-20, -10, -10, -5, -5, -10, -10, -20
};
static int mg_king[] = {
-30, -40, -40, -50, -50, -40, -40, -30,
-30, -40, -40, -50, -50, -40, -40, -30,
-30, -40, -40, -50, -50, -40, -40, -30,
-30, -40, -40, -50, -50, -40, -40, -30,
-20, -30, -30, -40, -40, -30, -30, -20,
-10, -20, -20, -20, -20, -20, -20, -10,
20, 20, 0, 0, 0, 0, 20, 20,
20, 30, 10, 0, 0, 10, 30, 20
};
static int eg_king[] = {
-50, -40, -30, -20, -20, -30, -40, -50,
-30, -20, -10, 0, 0, -10, -20, -30,
-30, -10, 20, 30, 30, 20, -10, -30,
-30, -10, 30, 40, 40, 30, -10, -30,
-30, -10, 30, 40, 40, 30, -10, -30,
-30, -10, 20, 30, 30, 20, -10, -30,
-30, -30, 0, 0, 0, 0, -30, -30,
-50, -30, -30, -30, -30, -30, -30, -50
};
/* as pieces bitboard tables start at position 2; we make these tables
* bigger.
*/
static int *mg_tables[] = {
NULL,
NULL,
mg_pawn,
mg_knight,
mg_bishop,
mg_rook,
mg_queen,
mg_king
};
static int *eg_tables[] = {
NULL,
NULL,
mg_pawn,
mg_knight,
mg_bishop,
mg_rook,
mg_queen,
eg_king
};
/* to flip vertically a square, we need to XOR it with 56
*/
static int mg_table[2][6 + 2][64];
static int eg_table[2][6 + 2][64];
void eval_simple_init(void)
{
# ifdef DEBUG_EVAL
log_f(1, "initializing piece tables\n");
# endif
for (int piece = BB_PAWN; piece <= BB_KING; ++piece) {
for (int square = 0; square < 64; ++square) {
mg_table[WHITE][piece][square] = mg_tables[piece][FLIP_V(square)];
eg_table[WHITE][piece][square] = eg_tables[piece][FLIP_V(square)];
mg_table[BLACK][piece][square] = mg_tables[piece][square];
eg_table[BLACK][piece][square] = eg_tables[piece][square];
}
}
}
/**
* eval_simple() - simple and fast position evaluation
* @pos: &position to evaluate
* #include "br.h"
* #include "debug.h"
*
* This function is normally used only during initialization,
* or when changing phase (middlegame <--> endgame), as the eval
* will be done increntally when doing moves.
* #include "piece.h"
* #include "eval-simple.h"
* #include "position.h"
*
* @return: the @pos evaluation in centipawns
* /\*
* * Tables are from https://www.chessprogramming.org/Simplified_Evaluation_Function
* *
* * Attention! Tables are black point of view (to be visually easier to read).
* *\/
*
* static int mg_pawn[] = {
* 0, 0, 0, 0, 0, 0, 0, 0,
* 50, 50, 50, 50, 50, 50, 50, 50,
* 10, 10, 20, 30, 30, 20, 10, 10,
* 5, 5, 10, 25, 25, 10, 5, 5,
* 0, 0, 0, 20, 20, 0, 0, 0,
* 5, -5, -10, 0, 0, -10, -5, 5,
* 5, 10, 10, -20, -20, 10, 10, 5,
* 0, 0, 0, 0, 0, 0, 0, 0
* };
*
* static int mg_knight[] = {
* -50, -40, -30, -30, -30, -30, -40, -50,
* -40, -20, 0, 0, 0, 0, -20, -40,
* -30, 0, 10, 15, 15, 10, 0, -30,
* -30, 5, 15, 20, 20, 15, 5, -30,
* -30, 0, 15, 20, 20, 15, 0, -30,
* -30, 5, 10, 15, 15, 10, 5, -30,
* -40, -20, 0, 5, 5, 0, -20, -40,
* -50, -40, -30, -30, -30, -30, -40, -50
* };
*
* static int mg_bishop[] = {
* -20, -10, -10, -10, -10, -10, -10, -20,
* -10, 0, 0, 0, 0, 0, 0, -10,
* -10, 0, 5, 10, 10, 5, 0, -10,
* -10, 5, 5, 10, 10, 5, 5, -10,
* -10, 0, 10, 10, 10, 10, 0, -10,
* -10, 10, 10, 10, 10, 10, 10, -10,
* -10, 5, 0, 0, 0, 0, 5, -10,
* -20, -10, -10, -10, -10, -10, -10, -20
* };
*
* static int mg_rook[] = {
* 0, 0, 0, 0, 0, 0, 0, 0,
* 5, 10, 10, 10, 10, 10, 10, 5,
* -5, 0, 0, 0, 0, 0, 0, -5,
* -5, 0, 0, 0, 0, 0, 0, -5,
* -5, 0, 0, 0, 0, 0, 0, -5,
* -5, 0, 0, 0, 0, 0, 0, -5,
* -5, 0, 0, 0, 0, 0, 0, -5,
* 0, 0, 0, 5, 5, 0, 0, 0
* };
*
* static int mg_queen[] = {
* -20, -10, -10, -5, -5, -10, -10, -20,
* -10, 0, 0, 0, 0, 0, 0, -10,
* -10, 0, 5, 5, 5, 5, 0, -10,
* -5, 0, 5, 5, 5, 5, 0, -5,
* 0, 0, 5, 5, 5, 5, 0, -5,
* -10, 5, 5, 5, 5, 5, 0, -10,
* -10, 0, 5, 0, 0, 0, 0, -10,
* -20, -10, -10, -5, -5, -10, -10, -20
* };
*
* static int mg_king[] = {
* -30, -40, -40, -50, -50, -40, -40, -30,
* -30, -40, -40, -50, -50, -40, -40, -30,
* -30, -40, -40, -50, -50, -40, -40, -30,
* -30, -40, -40, -50, -50, -40, -40, -30,
* -20, -30, -30, -40, -40, -30, -30, -20,
* -10, -20, -20, -20, -20, -20, -20, -10,
* 20, 20, 0, 0, 0, 0, 20, 20,
* 20, 30, 10, 0, 0, 10, 30, 20
* };
*
* static int eg_king[] = {
* -50, -40, -30, -20, -20, -30, -40, -50,
* -30, -20, -10, 0, 0, -10, -20, -30,
* -30, -10, 20, 30, 30, 20, -10, -30,
* -30, -10, 30, 40, 40, 30, -10, -30,
* -30, -10, 30, 40, 40, 30, -10, -30,
* -30, -10, 20, 30, 30, 20, -10, -30,
* -30, -30, 0, 0, 0, 0, -30, -30,
* -50, -30, -30, -30, -30, -30, -30, -50
* };
*
* /\* as pieces bitboard tables start at position 2; we make these tables
* * bigger.
* *\/
* static int *mg_tables[] = {
* NULL,
* NULL,
* mg_pawn,
* mg_knight,
* mg_bishop,
* mg_rook,
* mg_queen,
* mg_king
* };
*
* static int *eg_tables[] = {
* NULL,
* NULL,
* mg_pawn,
* mg_knight,
* mg_bishop,
* mg_rook,
* mg_queen,
* eg_king
* };
*
* /\* to flip vertically a square, we need to XOR it with 56
* *\/
* static int mg_table[2][6 + 2][64];
* static int eg_table[2][6 + 2][64];
*
* void eval_simple_init(void)
* {
* # ifdef DEBUG_EVAL
* log_f(1, "initializing piece tables\n");
* # endif
* for (int piece = BB_PAWN; piece <= BB_KING; ++piece) {
* for (int square = 0; square < 64; ++square) {
* mg_table[WHITE][piece][square] = mg_tables[piece][FLIP_V(square)];
* eg_table[WHITE][piece][square] = eg_tables[piece][FLIP_V(square)];
* mg_table[BLACK][piece][square] = mg_tables[piece][square];
* eg_table[BLACK][piece][square] = eg_tables[piece][square];
* }
* }
* }
*
* /\**
* * eval_simple() - simple and fast position evaluation
* * @pos: &position to evaluate
* *
* * This function is normally used only during initialization,
* * or when changing phase (middlegame <--> endgame), as the eval
* * will be done increntally when doing moves.
* *
* * @return: the @pos evaluation in centipawns
* *\/
* eval_t eval_simple(pos_t *pos)
* {
* eval_t eval[2] = { 0, 0 };
* int eg = simple_is_endgame(pos);
* int (*gg)[6 + 2][64]= eg? eg_table: mg_table;
*
* pos->eval_simple_phase = ENDGAME;
* # ifdef DEBUG_EVAL
* log_f(5, "phase = %s.\n", eg? "endgame": "midgame");
* # endif
*
* for (int color = WHITE; color <= BLACK; ++color) {
* for (uint piece = PAWN; piece <= KING; piece <<= 1) {
* int bb = PIECETOBB(piece), cur;
* u64 _t;
*
* # ifdef DEBUG_EVAL
* log_f(5, "p=%u bb=%d %s %s: count=%d val=%ld ", piece, bb, color? "black": "white",
* P_SYM(piece), popcount64(pos->bb[color][bb]),
* popcount64(pos->bb[color][bb]) * P_VALUE(piece));
* # endif
*
* eval[color] += popcount64(pos->bb[color][bb]) * P_LETTER(piece);
* bit_for_each64(cur, _t, pos->bb[color][bb]) {
* # ifdef DEBUG_EVAL
* log(5, "sq=%d:%d ", cur, gg[color][bb][cur]);
* # endif
* eval[color] += gg[color][bb][cur];
* }
* # ifdef DEBUG_EVAL
* log(5, "\n");
* # endif
* }
* }
* # ifdef DEBUG_EVAL
* log_f(2, "eval:%d white:%d black:%d\n", eval[WHITE] - eval[BLACK],
* eval[WHITE], eval[BLACK]);
* # endif
*
* return eval[WHITE] - eval[BLACK];
* }
*/
eval_t eval_simple(pos_t *pos)
{
eval_t eval[2] = { 0, 0 };
int eg = simple_is_endgame(pos);
int (*gg)[6 + 2][64]= eg? eg_table: mg_table;
pos->eval_simple_phase = ENDGAME;
# ifdef DEBUG_EVAL
log_f(5, "phase = %s.\n", eg? "endgame": "midgame");
# endif
for (int color = WHITE; color <= BLACK; ++color) {
for (uint piece = PAWN; piece <= KING; piece <<= 1) {
int bb = PIECETOBB(piece), cur;
u64 _t;
# ifdef DEBUG_EVAL
log_f(5, "p=%u bb=%d %s %s: count=%d val=%ld ", piece, bb, color? "black": "white",
P_SYM(piece), popcount64(pos->bb[color][bb]),
popcount64(pos->bb[color][bb]) * P_VALUE(piece));
# endif
eval[color] += popcount64(pos->bb[color][bb]) * P_LETTER(piece);
bit_for_each64(cur, _t, pos->bb[color][bb]) {
# ifdef DEBUG_EVAL
log(5, "sq=%d:%d ", cur, gg[color][bb][cur]);
# endif
eval[color] += gg[color][bb][cur];
}
# ifdef DEBUG_EVAL
log(5, "\n");
# endif
}
}
# ifdef DEBUG_EVAL
log_f(2, "eval:%d white:%d black:%d\n", eval[WHITE] - eval[BLACK],
eval[WHITE], eval[BLACK]);
# endif
return eval[WHITE] - eval[BLACK];
}

182
src/eval.c
View File

@@ -1,95 +1,97 @@
/* eval.c - static position evaluation.
/*
* /\* eval.c - static position evaluation.
* *
* * Copyright (C) 2021-2023 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>
* *
* *\/
*
* Copyright (C) 2021-2023 Bruno Raoult ("br")
* Licensed under the GNU General Public License v3.0 or later.
* Some rights reserved. See COPYING.
* #include <stdio.h>
*
* 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>.
* #include <list.h>
* #include <debug.h>
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
* #include "position.h"
* #include "eval.h"
* #include "eval-simple.h"
*
* inline eval_t eval_material(pos_t *pos, bool color)
* {
* eval_t res = 0;
*
* /\* I need to do something about the king, if it can be potentially taken
* * if pseudo-moves include a pinned piece on King.
* *\/
* for (uint piece = PAWN; piece < KING; piece <<= 1) {
* uint bb = PIECETOBB(piece);
* # ifdef DEBUG_EVAL
* log_f(2, "color=%u piece=%u bb=%u=%c count=%ul val=%ld\n",
* color, piece, bb, P_LETTER(piece), popcount64(pos->bb[color][bb]),
* P_VALUE(piece));
* # endif
* /\* attention here *\/
* res += popcount64(pos->bb[color][bb]) * P_VALUE(piece);
* }
* return res;
* }
*
* inline eval_t eval_mobility(pos_t *pos, bool color)
* {
* return pos->mobility[color];
* }
*
* inline eval_t eval_square_control(pos_t *pos, bool color)
* {
* return popcount64(pos->controlled[color]);
* }
*
* eval_t eval(pos_t *pos)
* {
* eval_t simple = 0, control[2] = {0};
*
* if (pos->eval != EVAL_INVALID)
* return pos->eval;
*
* /\* 1) pieces value *\/
* //material[WHITE] = eval_material(pos, WHITE);
* //material[BLACK] = eval_material(pos, BLACK);
* simple = eval_simple(pos);
*
* # ifdef DEBUG_EVAL
* log_f(2, "eval_simple=%d\n", simple);
* # endif
*
* /\* 2) square control: 10 square controls diff = 1 pawn *\/
* control[WHITE] = eval_square_control(pos, WHITE);
* control[BLACK] = eval_square_control(pos, BLACK);
*
* # ifdef DEBUG_EVAL
* log_f(2, "square control: W:%d B:%d diff=%d\n",
* control[WHITE], control[BLACK],
* (control[WHITE] - control[BLACK]) * 10);
* # endif
*
* /\* 3) mobility: 10 mobility diff = 1 pawn
* *\/
* # ifdef DEBUG_EVAL
* log_f(2, "mobility: W:%u B:%u diff=%d\n",
* pos->mobility[WHITE], pos->mobility[BLACK],
* (pos->mobility[WHITE] - pos->mobility[BLACK]) * 10);
* # endif
*
* eval_t res = simple +
* (control[WHITE] - control[BLACK]) * 10 +
* (pos->mobility[WHITE] - pos->mobility[BLACK]) * 10;
* # ifdef DEBUG_EVAL
* log_f(2, "eval: %d\n", res);
* # endif
* pos->eval = res;
* return res;
* }
*/
#include <stdio.h>
#include <list.h>
#include <debug.h>
#include "position.h"
#include "eval.h"
#include "eval-simple.h"
inline eval_t eval_material(pos_t *pos, bool color)
{
eval_t res = 0;
/* I need to do something about the king, if it can be potentially taken
* if pseudo-moves include a pinned piece on King.
*/
for (uint piece = PAWN; piece < KING; piece <<= 1) {
uint bb = PIECETOBB(piece);
# ifdef DEBUG_EVAL
log_f(2, "color=%u piece=%u bb=%u=%c count=%ul val=%ld\n",
color, piece, bb, P_LETTER(piece), popcount64(pos->bb[color][bb]),
P_VALUE(piece));
# endif
/* attention here */
res += popcount64(pos->bb[color][bb]) * P_VALUE(piece);
}
return res;
}
inline eval_t eval_mobility(pos_t *pos, bool color)
{
return pos->mobility[color];
}
inline eval_t eval_square_control(pos_t *pos, bool color)
{
return popcount64(pos->controlled[color]);
}
eval_t eval(pos_t *pos)
{
eval_t simple = 0, control[2] = {0};
if (pos->eval != EVAL_INVALID)
return pos->eval;
/* 1) pieces value */
//material[WHITE] = eval_material(pos, WHITE);
//material[BLACK] = eval_material(pos, BLACK);
simple = eval_simple(pos);
# ifdef DEBUG_EVAL
log_f(2, "eval_simple=%d\n", simple);
# endif
/* 2) square control: 10 square controls diff = 1 pawn */
control[WHITE] = eval_square_control(pos, WHITE);
control[BLACK] = eval_square_control(pos, BLACK);
# ifdef DEBUG_EVAL
log_f(2, "square control: W:%d B:%d diff=%d\n",
control[WHITE], control[BLACK],
(control[WHITE] - control[BLACK]) * 10);
# endif
/* 3) mobility: 10 mobility diff = 1 pawn
*/
# ifdef DEBUG_EVAL
log_f(2, "mobility: W:%u B:%u diff=%d\n",
pos->mobility[WHITE], pos->mobility[BLACK],
(pos->mobility[WHITE] - pos->mobility[BLACK]) * 10);
# endif
eval_t res = simple +
(control[WHITE] - control[BLACK]) * 10 +
(pos->mobility[WHITE] - pos->mobility[BLACK]) * 10;
# ifdef DEBUG_EVAL
log_f(2, "eval: %d\n", res);
# endif
pos->eval = res;
return res;
}

4
src/fen.c
View File

@@ -21,9 +21,7 @@
#include <bug.h>
#include "chessdefs.h"
#include "util.h"
//#include "piece.h"
//#include "bitboard.h"
#include "misc.h"
#include "position.h"
#include "fen.h"

5
src/hash.c
View File

@@ -18,7 +18,7 @@
#include <bitops.h>
#include "chessdefs.h"
#include "util.h"
#include "misc.h"
#include "position.h"
#include "piece.h"
#include "hash.h"
@@ -191,7 +191,6 @@ int tt_create(s32 sizemb)
if (sizemb <= 0)
sizemb = HASH_SIZE_DEFAULT;
sizemb = clamp(sizemb, HASH_SIZE_MIN, HASH_SIZE_MAX);
//printf("-> %'6d ", sizemb);
bytes = sizemb * 1024ull * 1024ull; /* bytes wanted */
target_nbuckets = bytes / sizeof(bucket_t); /* target buckets */
@@ -199,7 +198,7 @@ int tt_create(s32 sizemb)
nbits = msb64(target_nbuckets); /* adjust to power of 2 */
if (hash_tt.nbits != nbits) {
if (hash_tt.nbits)
if (hash_tt.keys)
tt_delete();
hash_tt.nbits = nbits;

7
src/hash.h
View File

@@ -21,7 +21,7 @@
#define ENTRIES_PER_BUCKET 4 /* buckets per hash table entry */
#define HASH_SIZE_DEFAULT 32 /* default: 32Mb */
#define HASH_SIZE_MIN 4
#define HASH_SIZE_MIN 1
#define HASH_SIZE_MAX 32768 /* 32Gb */
#define TT_MISS NULL
@@ -30,6 +30,11 @@
typedef u64 hkey_t; /* cannot use typedef for key_t */
/**
* hash_short: return the value of a hash first 7 MSB.
*/
#define hash_short(hash) ((hash) >> (64 - 8))
/**
* hentry_t: hashtable bucket.
*

123
src/hist.c Normal file
View File

@@ -0,0 +1,123 @@
/* hist.c - history management.
*
* Copyright (C) 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 <brlib.h>
#include <bug.h>
#include "position.h"
#include "hash.h"
#include "move.h"
#include "hist.h"
hist_t hist = {
.nstates = 1,
{ { .move = MOVE_NO_MOVE, .key = U64(0), .prev = &hist.state[0] } },
};
/**
* hist_init() - initialize history states data.
*
* This should be done every time a new position must be handled.
*/
void hist_init(void)
{
hist.nstates = 1;
hist.state[0].key = U64(0);
hist.state[0].move = MOVE_NO_MOVE;
hist.state[0].prev = &hist.state[0];
}
/**
* hist_push() - add a state and move to hist
* @st: &state_t to add
* @move: &move_t to add in @st
*/
void hist_push(state_t *st, move_t *move)
{
int last = hist.nstates++;
bug_on(last >= HIST_SIZE);
hist.state[last] = *st;
hist.state[last].prev = &hist.state[last - 1];
hist.state[last].move = *move;
}
/**
* hist_pop() - return last state from hist entry, and remove it from list
*
* Not used, only for debug.
*/
state_t *hist_pop(void)
{
return hist.state + --hist.nstates;
}
/**
* hist_last() - return last state from hist.
*/
state_t *hist_last(void)
{
return hist.state + hist.nstates - 1;
}
/**
* hist_prev() - return a state's ancestor.
* @st: &state_t state
*
* No test is done on ancestor. Caller should check it is different
* from HIST_START.
*/
state_t *hist_prev(state_t *st)
{
return st->prev;
}
/**
* hist_prev2() - return a state's second ancestor.
* @st: &state_t state
*
* No test is done on ancestors. Caller should check it is different
* from HIST_START.
*/
state_t *hist_prev2(state_t *st)
{
return st->prev->prev;
}
/**
* hist_prev4() - return a state's 4th ancestor.
* @st: &state_t state
*
* No test is done on ancestors. Caller should check it is different
* from HIST_START.
*/
state_t *hist_prev4(state_t *st)
{
return st->prev->prev->prev->prev;
}
/**
* hist_print() - print hist entries
*/
void hist_static_print(void)
{
char movestr[8];
printf("rev history: ");
for (state_t *p = hist_last(); p != HIST_START; p = hist_prev(p)) {
printf("%s(%lx) ",
p->move == MOVE_NO_MOVE? "none": move_to_str(movestr, p->move, 0),
hash_short(p->key));
}
printf("\n");
}

59
src/hist.h Normal file
View File

@@ -0,0 +1,59 @@
/* hist.h - history management.
*
* Copyright (C) 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>
*
*/
#ifndef HIST_H
#define HIST_H
#include <brlib.h>
#include <bug.h>
#include "position.h"
#include "hash.h"
#define HIST_SIZE 4096 /* I know, I know... */
/**
* hist - history states data.
*
* This variable is of type hist_t, which contains:
* @state: state_t array, size HIST_SIZE
* @nstates: current number of @state
*
* hist contains moves already played.
*
* Only HIST_SIZE - 1 hist elements are available, as the first element is
* used as a sentinel value (hist[0].state.prev = &hist[0].state).
* This first element allows multiple backards searches (p->prev->prev).
*
* hist is only written by main thread, and read by other threads/processes,
* therefore is never duplicated (even after a fork(), due to COW).
*/
typedef struct {
int nstates;
state_t state[HIST_SIZE];
} hist_t;
extern hist_t hist;
#define HIST_START (hist.state)
void hist_init(void);
void hist_push(state_t *st, move_t *move);
state_t *hist_pop(void);
state_t *hist_last(void);
state_t *hist_prev(state_t *st);
state_t *hist_prev2(state_t *st);
state_t *hist_prev4(state_t *st);
void hist_static_print(void);
#endif /* HIST_H */

2
src/hyperbola-quintessence.c
View File

@@ -14,7 +14,7 @@
#include <stdio.h>
#include <stdarg.h>
#include "brlib.h"
#include <brlib.h>
#include "chessdefs.h"
#include "board.h"

3
src/util.h → src/misc.h
View File

@@ -17,8 +17,6 @@
#include <stdio.h>
#include <stdlib.h>
#include <bug.h>
#include "chessdefs.h"
#undef safe_malloc
@@ -29,6 +27,7 @@
#pragma push_macro("BUG_ON")
#undef BUG_ON
#define BUG_ON
#include <bug.h>
#define safe_malloc(size) ({ \
void *_ret = malloc(size); \

15
src/move-do.c
View File

@@ -15,9 +15,9 @@
#include <ctype.h>
#include <stdlib.h>
#include "brlib.h"
#include "likely.h"
#include "bug.h"
#include <brlib.h>
#include <likely.h>
#include <bug.h>
#include "chessdefs.h"
#include "move.h"
@@ -80,13 +80,12 @@ pos_t *move_do(pos_t *pos, const move_t move, state_t *state)
if (captured != EMPTY) {
pos->clock_50 = 0;
//pos->captured = pos->board[to]; /* save capture info */
bug_on(pos->board[to] == EMPTY || COLOR(pos->captured) != them);
key ^= zobrist_pieces[captured][to];
pos_clr_sq(pos, to); /* clear square */
} else if (is_castle(move)) { /* handle rook move */
square_t rookfrom, rookto;
if (is_castle_K(move)) {
if (to > from) {
rookfrom = sq_rel(H1, us);
rookto = sq_rel(F1, us);
} else {
@@ -193,7 +192,7 @@ pos_t *move_undo(pos_t *pos, const move_t move, const state_t *state)
pos_set_sq(pos, to, pos->captured); /* restore captured piece */
} else if (is_castle(move)) { /* make reverse rook move */
square_t rookfrom, rookto;
if (is_castle_K(move)) {
if (to > from) {
rookfrom = sq_rel(F1, us);
rookto = sq_rel(H1, us);
} else {
@@ -254,7 +253,7 @@ pos_t *move_do_alt(pos_t *pos, const move_t move, state_t *state)
pos_clr_sq(pos, to); /* clear square */
} else if (is_castle(move)) { /* handle rook move */
square_t rookfrom, rookto;
if (is_castle_K(move)) {
if (to > from) {
rookfrom = sq_rel(H1, us);
rookto = sq_rel(F1, us);
} else {
@@ -344,7 +343,7 @@ pos_t *move_undo_alt(pos_t *pos, const move_t move, const state_t *state)
pos_set_sq(pos, to, pos->captured); /* restore captured piece */
} else if (is_castle(move)) { /* make reverse rook move */
square_t rookfrom, rookto;
if (is_castle_K(move)) {
if (to > from) {
rookfrom = sq_rel(F1, us);
rookto = sq_rel(H1, us);
} else {

74
src/move-gen.c
View File

@@ -26,7 +26,6 @@
#include "attack.h"
#include "move-gen.h"
/**
* pseudo_is_legal() - check if a move is legal.
* @pos: position
@@ -36,13 +35,18 @@
*/
bool pseudo_is_legal(const pos_t *pos, const move_t move)
{
color_t us = pos->turn, them = OPPONENT(us);
square_t from = move_from(move), to = move_to(move);
square_t king = pos->king[us];
color_t us = pos->turn;
color_t them = OPPONENT(us);
square_t from = move_from(move);
square_t to = move_to(move);
square_t kingsq = pos->king[us];
square_t ep = pos->en_passant;
bitboard_t kingbb = pos->bb[us][KING];
bitboard_t occ = pos_occ(pos);
u64 pinned = BIT(from) & pos->blockers;
u64 checkers = pos->checkers;
bitboard_t occ = pos_occ(pos);
u64 pinned = BIT(from) & pos->blockers;
u64 checkers = pos->checkers;
bug_on(pos->board[from] == NO_PIECE || COLOR(pos->board[from]) != us);
/* (1) - Castling & King
* For castling, we need to check intermediate squares attacks only.
@@ -50,60 +54,52 @@ bool pseudo_is_legal(const pos_t *pos, const move_t move)
* king from occupation bitboard (to catch king moving away from checker
* on same line) !
*/
if (unlikely(from == king)) {
if (unlikely(is_castle(move))) {
square_t dir = to > from? 1: -1;
if (sq_is_attacked(pos, occ, from + dir, them))
return false;
}
if (is_castle(move)) {
int dir = to > from? 1: -1;
if (sq_is_attacked(pos, occ, from + dir, them))
return false;
}
if (from == kingsq) {
return !sq_is_attacked(pos, occ ^ kingbb, to, them);
}
/* (2) - King is in check
* Double-check is already handled in (1), as only K moves were generated
* by pseudo legal move generator.
* Here, allowed dest squares are only on King-checker line, or on checker
* square.
* attacker.
* Special cases:
* e.p., legal if the grabbed pawn is giving check
* pinned piece: always illegal
* Special cases (illegal):
* - e.p., if the grabbed pawn is *not* giving check
* - piece is pinned
*/
if (checkers) {
if (pinned)
return false;
if (bb_multiple(checkers))
return false;
square_t checker = ctz64(checkers);
if (is_enpassant(move)) {
return pos->en_passant + sq_up(them) == checker;
return ep + sq_up(them) == ctz64(checkers);
}
return true;
//bitboard_t between = bb_between[king][checker] | pos->checkers;
//return mask(to) & between;
}
/* (3) - pinned pieces
* We verify here that pinned piece P stays on line King-P.
* We verify here that pinned piece P stays on line between K & dest square.
*/
if (BIT(from) & pos->blockers) {
return bb_line[from][king] & BIT(to); /* is to on pinner line ? */
if (pinned) {
return bb_line[from][kingsq] & BIT(to); /* is to on pinner line ? */
}
/* (4) - En-passant
* pinned pieces are handled in pinned section.
* pinned piece is already handled in (3).
* One case not handled anywhere else: when the two "disappearing" pawns
* would discover a R/Q horizontal check.
* Note: grabbed pawn *cannot* discover a check (impossible position).
*/
if (unlikely(is_enpassant(move))) {
if (is_enpassant(move)) {
bitboard_t rank5 = bb_rel_rank(RANK_5, us);
if (unlikely((pos->bb[us][KING] & rank5))) {
bitboard_t exclude = BIT(pos->en_passant - sq_up(us)) | BIT(from);
if (kingbb & rank5) {
bitboard_t exclude = BIT(ep + sq_up(them)) | BIT(from);
bitboard_t rooks = (pos->bb[them][ROOK] | pos->bb[them][QUEEN]) & rank5;
if (hyperbola_rank_moves(occ ^ exclude, king) & rooks)
return false;
return !(hyperbola_rank_moves(occ ^ exclude, kingsq) & rooks);
}
}
return true;
@@ -349,12 +345,12 @@ movelist_t *pos_gen_pseudo(pos_t *pos, movelist_t *movelist)
bitboard_t dest_squares = ~my_pieces;
bitboard_t occ = my_pieces | enemy_pieces;
bitboard_t empty = ~occ;
move_t *moves = movelist->move;
square_t king = pos->king[us];
bitboard_t from_bb, to_bb;
bitboard_t tmp_bb;
move_t *moves = movelist->move;
square_t from, to;
square_t king = pos->king[us];
/* king - MUST BE FIRST */
to_bb = bb_king_moves(dest_squares, king);
@@ -379,15 +375,17 @@ movelist_t *pos_gen_pseudo(pos_t *pos, movelist_t *movelist)
* To square attack check will be done in gen_is_legal.
*/
if (can_oo(pos->castle, us)) {
/* CHANGE HERE, either with bitmask >> or direct sq check */
bitboard_t occmask = rel_rank1 & (FILE_Fbb | FILE_Gbb);
if (!(occ & occmask)) {
*moves++ = move_make_flags(king, king + 2, M_CASTLE_K);
*moves++ = move_make_flags(king, king + 2, M_CASTLE);
}
}
if (can_ooo(pos->castle, us)) {
bitboard_t occmask = rel_rank1 & (FILE_Bbb | FILE_Cbb | FILE_Dbb);
if (!(occ & occmask)) { // &&
*moves++ = move_make_flags(king, king - 2, M_CASTLE_Q);
*moves++ = move_make_flags(king, king - 2, M_CASTLE);
}
}
}

31
src/move.c
View File

@@ -116,6 +116,37 @@ char *move_to_str(char *dst, const move_t move, __unused const int flags)
return dst;
}
/**
* move_from_str() - create a move from a position and UCI move string
* @pos: &pos_t
* @str: uci move string
*
* string and corresponding move are considered valid (no check is done).
*
* @return move, or NULL if error.
*/
move_t move_from_str(const pos_t *pos, const char *str)
{
move_t move;
square_t from = sq_from_string(str);
square_t to = sq_from_string(str + 2);
piece_type_t piece = PIECE(pos->board[from]);
piece_type_t promoted = piece_t_from_char(*(str+5));
if (piece == KING && sq_dist(from, to) > 1) { /* castling */
move = move_make_flags(from, to, M_CASTLE);
} else if (piece == PAWN && /* en-passant */
sq_file(from) != sq_file(to) &&
pos->board[to] == EMPTY) {
move = move_make_enpassant(from, to);
} else if (promoted != NO_PIECE_TYPE) { /* promotion */
move = move_make_promote(from, to, promoted);
} else {
move = move_make(from, to);
}
return move;
}
/**
* moves_print() - print movelist moves.
* @moves: &movelist_t moves list

59
src/move.h
View File

@@ -19,53 +19,45 @@
#include "board.h"
/* move structure:
* 3 3 2 2 1 1 1 1 1 1
* 1 0 4 3 8 7 5 4 2 1 6 5 0
* S UUUUUUU FFFFFF ccc ppp tttttt ffffff
* 1 1 1 1 1
* 8 5 4 2 1 6 5 0
* FFFF ppp tttttt ffffff
*
* bits len off range type mask get desc
* ffffff 6 0 0-5 square_t 077 &077 from
* tttttt 6 6 6-11 square_t 07700 (>>6) &077 to
* ppp 3 12 12-14 piece_type_t 070000 (>>12) &07 promoted
* ccc 3 15 15-17 piece_type_t 0700000 (>>15) &07 captured
* FFFFFF 6 18 18-23 move_flags_t 077000000 (>>18) &077 N/A flags
* UUUUUUU 7 24 24-30 unused 017700000000 future usage
* S 1 31 31-31 - 020000000000 sign
* bits len off range type mask get desc
* ffffff 6 0 0-5 square_t 077 &077 from
* tttttt 6 6 6-11 square_t 07700 (>>6) &077 to
* ppp 3 12 12-14 piece_type_t 070000 (>>12) &07 promoted
* FFF 3 15 15-17 move_flags_t 0700000 (>>15) &07 flags
*/
typedef s32 move_t;
/* special move_t values */
#define MOVE_NONE ((move_t) -1)
#define MOVE_NULL ((move_t) 0) /* hack: from = to = A1 */
typedef u32 move_t;
enum {
M_OFF_FROM = 0,
M_OFF_TO = 6,
M_OFF_PROMOTED = 12,
// M_OFF_CAPTURED = 15,
M_OFF_FLAGS = 15
};
typedef enum {
M_PROMOTION = 070000,
// M_CAPTURE = BIT(M_OFF_FLAGS + 0),
M_ENPASSANT = BIT(M_OFF_FLAGS + 0),
M_CASTLE_K = BIT(M_OFF_FLAGS + 1), /* maybe only one ? */
M_CASTLE_Q = BIT(M_OFF_FLAGS + 2), /* maybe only one ? */
M_CHECK = BIT(M_OFF_FLAGS + 3), /* maybe unknown/useless ? */
// M_DPUSH = BIT(M_OFF_FLAGS + 7) /* pawn double push */
M_PROMOTION = 070000,
M_FLAGS_MASK = 0700000,
M_ENPASSANT = (1 << M_OFF_FLAGS),
M_CASTLE = (2 << M_OFF_FLAGS), /* maybe only one ? */
// M_CHECK = (3 << M_OFF_FLAGS) /* maybe unknown/useless ? */
} move_flags_t;
#define move_set_flags(move, flags) ((move) | (flags))
/* special move_t values */
#define MOVE_NULL 0 /* hack: from = to = A1 */
#define MOVE_NONE 07777 /* hack: from = to = H8 */
#define MOVE_NO_MOVE 01010 /* hack: from = to = A2 */
//#define is_capture(m) ((m) & M_CAPTURE)
#define is_enpassant(m) ((m) & M_ENPASSANT)
#define is_promotion(m) ((m) & M_PROMOTION)
#define is_castle(m) ((m) & (M_CASTLE_K | M_CASTLE_Q))
#define is_castle_K(m) ((m) & M_CASTLE_K)
#define is_castle_Q(m) ((m) & M_CASTLE_Q)
#define is_check(m) ((m) & M_CHECK)
//#define is_dpush(m) ((m) & M_DPUSH)
#define move_set_flags(move, flags) ((move) | (flags))
#define move_flags(move) ((move) & M_FLAGS_MASK)
#define is_promotion(m) ((m) & M_PROMOTION)
#define is_enpassant(m) (move_flags(m) == M_ENPASSANT)
#define is_castle(m) (move_flags(m) == M_CASTLE)
#define is_check(m) (move_flags(m) == M_CHECK)
#define MOVES_MAX 256
@@ -153,6 +145,7 @@ static inline move_t move_make_promote(square_t from, square_t to,
//int move_print(int movenum, move_t *move, move_flags_t flags);
char *move_to_str(char *dst, const move_t move, __unused const int flags);
move_t move_from_str(const pos_t *pos, const char *str);
void moves_print(movelist_t *moves, int flags);
void move_sort_by_sq(movelist_t *moves);

21
src/position.c
View File

@@ -27,9 +27,10 @@
#include "hyperbola-quintessence.h"
#include "fen.h"
#include "piece.h"
#include "util.h"
#include "misc.h"
#include "board.h"
#include "attack.h"
#include "hist.h"
/**
* pos_new() - allocate a new position
@@ -123,8 +124,6 @@ pos_t *pos_clear(pos_t *pos)
pos->pinners = 0;
pos->blockers = 0;
pos->repeat.moves = 0;
return pos;
}
@@ -167,10 +166,12 @@ bool pos_cmp(const pos_t *pos1, const pos_t *pos2)
if (_cmpf(checkers) ||_cmpf(pinners) || _cmpf(blockers))
goto end;
if (_cmpf(repeat.moves) ||
memcmp(pos1->repeat.key, pos2->repeat.key,
pos1->repeat.moves * sizeof pos1->repeat.key))
goto end;
/*
* if (_cmpf(repeat.moves) ||
* memcmp(pos1->repeat.key, pos2->repeat.key,
* pos1->repeat.moves * sizeof pos1->repeat.key))
* goto end;
*/
ret = true;
end:
@@ -360,7 +361,7 @@ bitboard_t pos_king_blockers(const pos_t *pos, const color_t color, const bitboa
bool pos_ok(pos_t *pos, const bool strict)
{
int n, count = 0, bbcount = 0, error = 0;
color_t us = pos->turn, them = OPPONENT(us);
color_t __unused us = pos->turn, __unused them = OPPONENT(us);
/* force BUG_ON and WARN_ON */
# pragma push_macro("BUG_ON")
@@ -391,7 +392,7 @@ bool pos_ok(pos_t *pos, const bool strict)
}
for (square_t sq = 0; sq < 64; ++sq) {
piece_t piece = pos->board[sq];
bitboard_t match;
__unused bitboard_t match;
if (piece == EMPTY)
continue;
color_t c = COLOR(piece);
@@ -429,7 +430,7 @@ void pos_print(const pos_t *pos)
char str[128];
board_print(pos->board);
printf("key:%lx ", pos->key);
printf("key:%lx (#%lx)", pos->key, hash_short(pos->key));
printf("fen: %s\n", pos2fen(pos, str));
printf("checkers:%s ", pos_checkers2str(pos, str, sizeof(str)));
printf("pinners: %s ", pos_pinners2str(pos, str, sizeof(str)));

10
src/position.h
View File

@@ -28,13 +28,6 @@
#include "move.h"
#include "board.h"
#define REPEAT_SIZE 1024
typedef struct {
hkey_t key[REPEAT_SIZE];
int moves;
} repeat_t;
typedef struct __pos_s {
u64 node_count; /* evaluated nodes */
int turn; /* WHITE or BLACK */
@@ -56,6 +49,8 @@ typedef struct __pos_s {
int clock_50;
int plycount; /* plies so far, start from 1 */
piece_t captured; /* only used in move_undo */
move_t move;
struct state_s *prev;
);
bitboard_t checkers; /* opponent checkers */
bitboard_t pinners; /* opponent pinners */
@@ -64,7 +59,6 @@ typedef struct __pos_s {
piece_t board[BOARDSIZE];
bitboard_t bb[2][PIECE_TYPE_MAX]; /* bb[0][PAWN], bb[1][ALL_PIECES] */
square_t king[2]; /* dup with bb, faster retrieval */
repeat_t repeat; /* for repetition detection */
} pos_t;
typedef struct state_s state_t;

2
src/search.c
View File

@@ -70,7 +70,7 @@ u64 perft(pos_t *pos, int depth, int ply, bool output)
movelist_t movelist2;
pos_set_checkers_pinners_blockers(pos);
subnodes = pos_legal(pos, pos_gen_pseudo(pos, &movelist2))->nmoves;
} else if (ply >= 4) {
} else if (ply >= 3) {
hentry_t *entry = tt_probe_perft(pos->key, depth);
if (entry != TT_MISS) {
subnodes = HASH_PERFT_VAL(entry->data);

18
src/util.c
View File

@@ -1,18 +0,0 @@
/* util.c - various util functions.
*
* Copyright (C) 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 "util.h"
#include "bitboard.h"

33
test/common-test.h
View File

@@ -43,6 +43,33 @@ struct fentest {
* },
*/
/*
* { __LINE__, MOVEGEN | MOVEDO | PERFT,
* "from https://talkchess.com/viewtopic.php?t=74153",
* "8/p7/8/1P6/K1k3p1/6P1/7P/8 w - - 0 1", // Perft(8) == 8,103,790
* },
* 8/5p2/8/2k3P1/p3K3/8/1P6/8 b - - // Perft(8) == 64,451,405
*/
/*
* { __LINE__, MOVEGEN | MOVEDO | PERFT,
* "from https://talkchess.com/viewtopic.php?t=74153",
* "n1n5/PPPk4/8/8/8/8/4Kppp/5N1N b - - 0 1" // Perft(6) == 71,179,139
* },
* { __LINE__, MOVEGEN | MOVEDO | PERFT,
* "from https://talkchess.com/viewtopic.php?t=74153",
* "r3k2r/p6p/8/B7/1pp1p3/3b4/P6P/R3K2R w KQkq - 0 1" // Perft(6) == 77,054,993
* },
*/
/*
* { __LINE__, FEN | MOVEGEN | MOVEDO | PERFT,
* "from https://www.talkchess.com/forum/viewtopic.php?t=42463",
* "rnbqkb1r/pp1p1ppp/2p5/4P3/2B5/8/PPP1NnPP/RNBQK2R w KQkq - 0 6"
* },
*/
/*
r3k2r/pb3p2/5npp/n2p4/1p1PPB2/6P1/P2N1PBP/R3K2R w KQkq - // Perft(5) == 29,179,893
*/
/******************************************************************
* DO NOT DELETE NEXT LINE - sentinel entry for temp tests above. *
* ignored if first array entry. *
@@ -249,12 +276,16 @@ struct fentest {
"",
"6k1/6pp/R2p4/p1p5/8/1P1r3P/6P1/6K1 b - - 3 3"
},
{ __LINE__, FEN | MOVEGEN | MOVEDO | PERFT,
"from https://www.talkchess.com/forum/viewtopic.php?t=42463",
"rnbqkb1r/pp1p1ppp/2p5/4P3/2B5/8/PPP1NnPP/RNBQK2R w KQkq - 0 6"
},
// some of tests below are from:
// - Rodent IV
// - https://www.chessprogramming.net/perfect-perft/
{ __LINE__, FEN | MOVEGEN | MOVEDO | PERFT,
"",
"\"kiwipete\"",
"r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1"
},
{ __LINE__, FEN | MOVEGEN | MOVEDO | PERFT,

31
test/move-test.c
View File

@@ -1,31 +0,0 @@
#include <stdio.h>
#include "debug.h"
#include "../src/fen.h"
#include "../src/move.h"
int main(int ac, char**av)
{
pos_t *pos;
debug_init(5, stderr, true);
piece_pool_init();
moves_pool_init();
pos_pool_init();
pos = pos_get();
if (ac == 1) {
fen2pos(pos, "rnbqkbnr/pppp1ppp/8/4p3/4P3/8/PPPP1PPP/RNBQKBNR w KQkq - 0 2");
//pos_startpos(pos);
} else {
fen2pos(pos, av[1]);
}
//printf("turn = %d opponent = %d\n", pos->turn, OPPONENT(pos->turn));
moves_gen_all(pos);
pos_print(pos);
pos_pieces_print(pos);
moves_print(pos, M_PR_SEPARATE);
//bitboard_print2(castle_squares[0].controlled, castle_squares[1].controlled);
//bitboard_print2(castle_squares[0].occupied, castle_squares[1].occupied);
}

52
test/perft-test.c
View File

@@ -277,15 +277,16 @@ int main(int ac, char**av)
movelist_t fishmoves;
FILE *outfd = NULL;
s64 ms, lps;
int opt, depth = 6, run = 3, tt = 32, newtt = 32;
int opt, depth = 6, run = 3, tt, newtt = HASH_SIZE_DEFAULT;
struct {
s64 count, ms;
s64 count, countskipped, ms;
s64 minlps, maxlps;
int skipped;
int err;
} res[3] = {
{ .minlps=LONG_MAX },
{ .minlps=LONG_MAX },
{ .minlps=LONG_MAX },
{ .minlps = LONG_MAX },
{ .minlps = LONG_MAX },
{ .minlps = LONG_MAX },
};
while ((opt = getopt(ac, av, "cd:mp:st:")) != -1) {
@@ -321,9 +322,12 @@ int main(int ac, char**av)
}
init_all();
if (newtt != 32 && newtt > 1) {
printf("changing TT size from %d to %d\n", tt, newtt);
tt = hash_tt.mb;
if (run & 1 && newtt != tt) {
tt_create(newtt);
printf("changing TT size from %d to %d\n", tt, newtt);
tt = newtt;
}
printf("%s: depth:%d tt_size:%d run:%x SF:%s\n",
@@ -334,8 +338,6 @@ int main(int ac, char**av)
tt_info();
printf("\n");
printf("move_t size:%lu\n", sizeof(move_t));
if (sf_run)
outfd = open_stockfish();
@@ -346,11 +348,10 @@ int main(int ac, char**av)
continue;
}
curtest++;
printf("test:%d line:%d", curtest, cur_line());
printf("test:%d line:%d fen:%s\n", curtest, cur_line(), fen);
if (comment)
printf(" comment:%s\n",
printf("\t\"%s\"\n",
*cur_comment()? cur_comment(): "no test desc");
printf("\t%s\n", fen);
tt_clear();
@@ -362,6 +363,7 @@ int main(int ac, char**av)
ms = clock_elapsed_ms(&clock);
if (!ms) {
res[2].skipped++;
res[2].countskipped += sf_count;
lps = 0;
} else {
lps = sf_count * 1000l / ms;
@@ -382,6 +384,7 @@ int main(int ac, char**av)
ms = clock_elapsed_ms(&clock);
if (!ms) {
res[0].skipped++;
res[0].countskipped += my_count;
lps = 0;
} else {
lps = my_count * 1000l / ms;
@@ -399,6 +402,7 @@ int main(int ac, char**av)
tt_stats();
} else {
printf("perft : perft:%'lu ***ERROR***\n", my_count);
res[0].err++;
}
}
@@ -408,6 +412,7 @@ int main(int ac, char**av)
ms = clock_elapsed_ms(&clock);
if (!ms) {
res[1].skipped++;
res[1].countskipped += my_count;
lps = 0;
} else {
lps = my_count * 1000l / ms;
@@ -424,6 +429,7 @@ int main(int ac, char**av)
my_count, ms, lps);
} else {
printf("perft_alt : perft:%'lu ***ERROR***\n", my_count);
res[1].err++;
}
}
printf("\n");
@@ -432,32 +438,32 @@ int main(int ac, char**av)
if (sf_run) {
if (!res[2].ms)
res[2].ms = 1;
printf("total Stockfish : perft:%'lums ms:%'lums lps:%'lu min:%'lu max:%'lu "
printf("total Stockfish : perft:%'lu ms:%'lu lps:%'lu min:%'lu max:%'lu "
"(skipped %d/%d)\n",
res[2].count, res[2].ms,
res[2].count + res[2].countskipped, res[2].ms,
res[2].count * 1000l / res[2].ms,
res[2].minlps, res[2].maxlps,
res[0].skipped, curtest);
res[2].skipped, curtest);
}
if (run & 1) {
if (!res[0].ms)
res[0].ms = 1;
printf("total perft : perft:%'lums ms:%'lums lps:%'lu min:%'lu max:%'lu "
"(skipped %d/%d)\n",
res[0].count, res[0].ms,
printf("total perft : perft:%'lu ms:%'lu lps:%'lu min:%'lu max:%'lu "
"(pos:%d skipped:%d err:%d)\n",
res[0].count + res[0].countskipped, res[0].ms,
res[0].count * 1000l / res[0].ms,
res[0].minlps, res[0].maxlps,
res[0].skipped, curtest);
curtest, res[0].skipped, res[0].err);
}
if (run & 2) {
if (!res[1].ms)
res[1].ms = 1;
printf("total perft_alt : perft:%'lums ms:%'lums lps:%'lu min:%'lu max:%'lu "
"(skipped %d/%d)\n",
res[1].count, res[1].ms,
printf("total perft_alt : perft:%'lu ms:%'lu lps:%'lu min:%'lu max:%'lu "
"(pos:%d skipped:%d err:%d)\n",
res[1].count + res[1].countskipped, res[1].ms,
res[1].count * 1000l / res[1].ms,
res[1].minlps, res[1].maxlps,
res[0].skipped, curtest);
curtest, res[1].skipped, res[1].err);
}
return 0;
}