diff --git a/.dir-locals.el b/.dir-locals.el index 8933eb1..957ee03 100644 --- a/.dir-locals.el +++ b/.dir-locals.el @@ -1,3 +1,3 @@ ((nil . ((compile-command . (concat "make -C " (vc-root-dir) - " -k -j2"))))) + " -k -j2 testing"))))) diff --git a/.gitignore b/.gitignore index 2f5fb48..9dedd65 100644 --- a/.gitignore +++ b/.gitignore @@ -4,6 +4,9 @@ vgcore.* *.i *.old *.save +/GPATH +/GRTAGS +/GTAGS /.ccls-root /.ccls-cache/ /obj/ @@ -14,4 +17,5 @@ vgcore.* /tmp/ /notused/ valgrind.out +gmon.out compile_commands.json diff --git a/MEMO.org b/MEMO.org new file mode 100644 index 0000000..743a283 --- /dev/null +++ b/MEMO.org @@ -0,0 +1,2 @@ +** Some current ideas +- helpers for square, pieces, etc: validity, conversions diff --git a/Makefile b/Makefile index db511b0..1747b22 100644 --- a/Makefile +++ b/Makefile @@ -1,4 +1,4 @@ -# Makefile - GNU make only. +# Makefile - brchess Makefile, **GNU make only** # # Copyright (C) 2021-2023 Bruno Raoult ("br") # Licensed under the GNU General Public License v3.0 or later. @@ -12,6 +12,7 @@ SHELL := /bin/bash CC := gcc +#CC := clang LD := ld BEAR := bear TOUCH := touch @@ -20,9 +21,11 @@ RMDIR := rmdir MAKE := make SRCDIR := ./src +INCDIR := ./src # used by ./test sources OBJDIR := ./obj BINDIR := ./bin DEPDIR := ./dep +TSTDIR := ./test BRLIB := ./brlib BRINCDIR := $(BRLIB)/include @@ -31,39 +34,60 @@ BRLIBDIR := $(BRLIB)/lib CCLSROOT := .ccls-root CCLSFILE := compile_commands.json -SRC := $(wildcard $(SRCDIR)/*.c) # project sources -SRC_FN := $(notdir $(SRC)) # source basename +SRC := $(wildcard $(SRCDIR)/*.c) # project sources +SRC_FN := $(notdir $(SRC)) # source basename OBJ := $(addprefix $(OBJDIR)/,$(SRC_FN:.c=.o)) -LIB := br_$(shell uname -m) # library name +TSTSRC := $(wildcard $(TSTDIR)/*.c) -DEP_FN := $(SRC_FN) $(LIBSRC_FN) +LIB := br_$(shell uname -m) # library name +LIBS := $(strip -l$(LIB) -lreadline) + +DEP_FN := $(SRC_FN) DEP := $(addprefix $(DEPDIR)/,$(DEP_FN:.c=.d)) TARGET_FN := brchess TARGET := $(addprefix $(BINDIR)/,$(TARGET_FN)) -LDFLAGS := -L$(BRLIBDIR) -LIBS := -l$(LIB) -lreadline -lncurses +ASMFILES := $(SRC:.c=.s) $(TSTSRC:.c=.s) +CPPFILES := $(SRC:.c=.i) $(TSTSRC:.c=.i) ##################################### pre-processor flags -CPPFLAGS := -I$(BRINCDIR) -#CPPFLAGS += -DDEBUG # global -CPPFLAGS += -DDEBUG_DEBUG # enable log() functions -#CPPFLAGS += -DDEBUG_DEBUG_C # enable verbose log() settings -CPPFLAGS += -DDEBUG_POOL # memory pools management -CPPFLAGS += -DDEBUG_FEN # FEN decoding -CPPFLAGS += -DDEBUG_MOVE # move generation -CPPFLAGS += -DDEBUG_EVAL # eval functions -CPPFLAGS += -DDEBUG_PIECE # piece list management -CPPFLAGS += -DDEBUG_SEARCH # move search +CPPFLAGS := -I$(BRINCDIR) -I$(INCDIR) + +CPPFLAGS += -DNDEBUG # assert + +CPPFLAGS += -DBUG_ON # brlib bug.h +CPPFLAGS += -DWARN_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 + +# attack.c +#CPPFLAGS += -DDEBUG_ATTACK_ATTACKERS1 # sq_attackers details +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 += -DDIAGRAM_SYM # diagram with symbols # remove extraneous spaces (due to spaces before comments) CPPFLAGS := $(strip $(CPPFLAGS)) ##################################### compiler flags CFLAGS := -std=gnu11 -#CFLAGS += -O2 +#CFLAGS += -flto +CFLAGS += -O1 CFLAGS += -g CFLAGS += -Wall CFLAGS += -Wextra @@ -76,26 +100,37 @@ CFLAGS += -Wmissing-declarations CFLAGS := $(strip $(CFLAGS)) +##################################### linker flags +LDFLAGS := -L$(BRLIBDIR) +#LDFLAGS += -flto + +LDFLAGS := $(strip $(LDFLAGS)) + ##################################### archiver/dependency flags ARFLAGS := rcs -DEPFLAGS = -MMD -MP -MF $(DEPDIR)/$*.d +DEPFLAGS = -MMD -MP -MF $(DEPDIR)/$*.d + +##################################### archiver/dependency flags +ALL_CFLAGS = $(DEPFLAGS) $(CPPFLAGS) $(CFLAGS) +ALL_LDFLAGS = $(LDFLAGS) $(LIBS) ##################################### General targets .PHONY: all compile clean cleanall all: $(TARGET) -compile: libobjs objs +compile: brlib objs -clean: cleandep cleanobj cleanlib cleanlibobj cleanbin +libs: brlib -cleanall: clean cleandepdir cleanobjdir cleanlibdir cleanlibobjdir cleanbindir +clean: cleandep cleanasmcpp cleanobj cleanbin + +cleanall: clean cleandepdir cleanobjdir cleanallbrlib cleanbindir ##################################### cleaning functions -# rmfiles - deletes a list of files in a directory if they exist. +# rmfiles - delete a list of files if they exist. # $(1): the directory -# $(2): the list of files to delete -# $(3): The string to include in action output - "cleaning X files." +# $(2): The string to include in action output - "cleaning X files." # see: https://stackoverflow.com/questions/6783243/functions-in-makefiles # # Don't use wildcard like "$(DIR)/*.o", so we can control mismatches between @@ -111,7 +146,7 @@ define rmfiles fi endef -# rmdir - deletes a directory if it exists. +# rmdir - delete a directory if it exists. # $(1): the directory # $(2): The string to include in action output - "removing X dir." # @@ -171,46 +206,20 @@ cleanobjdir: cleanobj # The part right of '|' are "order-only prerequisites": They are build as # "normal" ones, but do not imply to rebuild target. $(OBJDIR)/%.o: $(SRCDIR)/%.c | $(OBJDIR) $(DEPDIR) - @echo compiling brchess $< "->" $@. - @$(CC) -c $(DEPFLAGS) $(CPPFLAGS) $(CFLAGS) $< -o $@ - -##################################### brlib objects -.PHONY: libobjs cleanlibobj cleanlibobjdir - -libobjs: $(LIBOBJ) - -cleanlibobj: - $(call rmfiles,$(LIBOBJ),brlib object) - -cleanlibobjdir: - $(call rmdir,$(LIBOBJDIR),brlib objects) - -$(LIBOBJDIR)/%.o: $(LIBSRCDIR)/%.c | $(LIBOBJDIR) $(DEPDIR) - @echo compiling library $< "->" $@. - $(CC) -c $(DEPFLAGS) $(CPPFLAGS) $(CFLAGS) $< -o $@ + @echo compiling brchess module: $< "->" $@. + @$(CC) -c $(ALL_CFLAGS) $< -o $@ ##################################### brlib libraries -.PHONY: libs cleanlib cleanlibdir +.PHONY: cleanbrlib cleanallbrlib brlib -cleanlib: - $(call rmfiles,$(DLIB) $(SLIB),library) +cleanbrlib: + $(MAKE) -C $(BRLIB) clean -cleanlibdir: - $(call rmdir,$(LIBDIR),libraries) +cleanallbrlib: + $(MAKE) -C $(BRLIB) cleanall -# libs: $(DLIB) $(SLIB) -libs: - $(MAKE) -C $(BRLIB) - -#$(DLIB): CFLAGS += -fPIC -#$(DLIB): LDFLAGS += -shared -#$(DLIB): $(LIBOBJ) | $(LIBDIR) -# @echo building $@ shared library. -# @$(CC) $(CFLAGS) $(LDFLAGS) $^ -o $@ -# -#$(SLIB): $(LIBOBJ) | $(LIBDIR) -# @echo building $@ static library. -# $(AR) $(ARFLAGS) $@ $^ +brlib: + $(MAKE) -C $(BRLIB) libs ##################################### brchess binaries .PHONY: targets cleanbin cleanbindir @@ -223,19 +232,22 @@ cleanbin: cleanbindir: $(call rmdir,$(BINDIR),binaries) -# We don't use static lib, but we could build it here -#$(TARGET): $(DLIB) $(OBJ) | $(BINDIR) $(SLIB) -$(TARGET): libs $(OBJ) | $(BINDIR) $(SLIB) - @echo generating $@ executable. +$(TARGET): libs $(OBJ) | $(BINDIR) + @echo generating $@. $(CC) $(LDFLAGS) $(OBJ) $(LIBS) -o $@ ##################################### pre-processed (.i) and assembler (.s) output +.PHONY: cleanasmcpp + +cleanasmcpp: + @$(call rmfiles,$(ASMFILES) $(CPPFILES),asm and pre-processed) + %.i: %.c - @echo generating $@ + @echo generating $@ (cpp processed). @$(CC) -E $(CPPFLAGS) $(CFLAGS) $< -o $@ %.s: %.c - @echo generating $@ + @echo generating $@ (asm). @$(CC) -S -fverbose-asm $(CPPFLAGS) $(CFLAGS) $< -o $@ ##################################### LSP (ccls) @@ -248,17 +260,13 @@ $(CCLSROOT): @$(TOUCH) $@ # generate compile_commands.json. -# Need to add includes and Makefile dependencies. +# TODO: add Makefile dependencies. # also, if cclsfile is newer than sources, no need to clean objects file # (and to run bear). # maybe run cleanobj cleanlibobj in commands ? -$(CCLSFILE): cleanobj cleanlibobj $(SRC) $(LIBSRC) | $(CCLSROOT) +$(CCLSFILE): cleanobj cleanbrlib libs | $(CCLSROOT) @echo "Generating ccls compile commands file ($@)." - @$(BEAR) -- make compile - -#.PHONY: bear -#bear: cleanobj cleanlibobj Makefile | $(CCLSROOT) -# @$(BEAR) -- make compile + @$(BEAR) -- $(MAKE) testing ##################################### valgrind (mem check) .PHONY: memcheck @@ -275,6 +283,62 @@ VALGRINDFLAGS += --suppressions=etc/libreadline.supp memcheck: targets @$(VALGRIND) $(VALGRINDFLAGS) $(BINDIR)/brchess +##################################### test binaries +.PHONY: testing test + +TEST := piece-test fen-test bitboard-test movegen-test attack-test movedo-test + +PIECE_OBJS := piece.o +FEN_OBJS := fen.o position.o piece.o bitboard.o board.o hyperbola-quintessence.o \ + attack.o +BB_OBJS := fen.o position.o piece.o bitboard.o board.o hyperbola-quintessence.o \ + attack.o +MOVEGEN_OBJS := fen.o position.o piece.o bitboard.o board.o hyperbola-quintessence.o \ + attack.o move.o move-gen.o +ATTACK_OBJS := fen.o position.o piece.o bitboard.o board.o hyperbola-quintessence.o \ + attack.o move.o move-gen.o +MOVEDO_OBJS := fen.o position.o piece.o bitboard.o board.o hyperbola-quintessence.o \ + attack.o move.o move-gen.o move-do.o + +TEST := $(addprefix $(BINDIR)/,$(TEST)) + +PIECE_OBJS := $(addprefix $(OBJDIR)/,$(PIECE_OBJS)) +FEN_OBJS := $(addprefix $(OBJDIR)/,$(FEN_OBJS)) +BB_OBJS := $(addprefix $(OBJDIR)/,$(BB_OBJS)) +MOVEGEN_OBJS := $(addprefix $(OBJDIR)/,$(MOVEGEN_OBJS)) +ATTACK_OBJS := $(addprefix $(OBJDIR)/,$(ATTACK_OBJS)) +MOVEDO_OBJS := $(addprefix $(OBJDIR)/,$(MOVEDO_OBJS)) + +test: + echo TEST=$(TEST) + echo FEN_OBJS=$(FEN_OBJS) + +testing: $(TEST) + +bin/piece-test: test/piece-test.c $(FEN_OBJS) + @echo compiling $@ 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. + @$(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. + @$(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. + @$(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. + @$(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. + @$(CC) $(ALL_CFLAGS) $< $(MOVEDO_OBJS) $(ALL_LDFLAGS) -o $@ + ##################################### Makefile debug .PHONY: showflags wft @@ -294,3 +358,6 @@ wtf: @#echo LIBOBJ=$(LIBOBJ) @#echo DEP=$(DEP) @#echo LIBSRC=$(LIBSRC) + +zob: + $(CC) $(LDFLAGS) $(CPPFLAGS) $(CFLAGS) $< $(LIBS) src/util.c -o util diff --git a/README.org b/README.org index 199f4df..7b5905e 100644 --- a/README.org +++ b/README.org @@ -13,6 +13,9 @@ the GNU General Public License v3.0 or later. Some rights reserved. See COPYING. ** Installation (don't do it until version 0.9) +*** dependencire +- GCC 10 or newer +- libreadline *** clone repository *user...** #+BEGIN_EXAMPLE diff --git a/brlib b/brlib index e55ac95..8ff163d 160000 --- a/brlib +++ b/brlib @@ -1 +1 @@ -Subproject commit e55ac95301c066f9ca865b7c137ed7f2d77c658c +Subproject commit 8ff163dcf569105bbdec28860eff100280e32898 diff --git a/src/attack.c b/src/attack.c new file mode 100644 index 0000000..bc09669 --- /dev/null +++ b/src/attack.c @@ -0,0 +1,157 @@ +/* attack.c - attack 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include +#include + +#include "chessdefs.h" +#include "bitboard.h" +#include "position.h" +#include "hyperbola-quintessence.h" +#include "attack.h" + + +// #define DEBUG_ATTACK_ATTACKERS1 + +/** + * sq_attackers() - find attackers on a square + * @pos: position + * @occ: occupation mask used + * @sq: square to test + * @c: attacker color + * + * Find all @c attacks on @sq. En-passant is not considered. + * + * Algorithm: We perform a reverse attack, and check if any given + * piece type on @sq can attack a @c piece of same type. + * + * For example, if @c is white, we test for all T in P,N,B,R,Q,K if + * T on @sq could attack a white T piece. + * + * @Return: a bitboard of attackers. + */ +bitboard_t sq_attackers(const pos_t *pos, const bitboard_t occ, const square_t sq, const color_t c) +{ + bitboard_t attackers = 0, tmp; + bitboard_t sqbb = mask(sq); + //bitboard_t occ = pos_occ(pos); + bitboard_t to; + color_t opp = OPPONENT(c); + + /* pawn */ + to = pos->bb[c][PAWN]; + tmp = pawn_shift_upleft(sqbb, opp) & to; + attackers |= tmp; +# ifdef DEBUG_ATTACK_ATTACKERS1 + bb_print("att pawn upleft", tmp); +# endif + tmp = pawn_shift_upright(sqbb, opp) & to; + attackers |= tmp; +# ifdef DEBUG_ATTACK_ATTACKERS1 + bb_print("att pawn upright", tmp); +# endif + + /* knight & king */ + to = pos->bb[c][KNIGHT]; + tmp = bb_knight_moves(to, sq); + attackers |= tmp; +# ifdef DEBUG_ATTACK_ATTACKERS1 + bb_print("att knight", tmp); +# endif + to = pos->bb[c][KING]; + tmp = bb_king_moves(to, sq); + attackers |= tmp; +# ifdef DEBUG_ATTACK_ATTACKERS1 + bb_print("att king", tmp); +# endif + + /* bishop / queen */ + to = pos->bb[c][BISHOP] | pos->bb[c][QUEEN]; + tmp = hyperbola_bishop_moves(occ, sq) & to; + attackers |= tmp; +# ifdef DEBUG_ATTACK_ATTACKERS1 + bb_print("att bishop/queen", tmp); +# endif + + /* rook / queen */ + to = pos->bb[c][ROOK] | pos->bb[c][QUEEN]; + tmp = hyperbola_rook_moves(occ, sq) & to; + attackers |= tmp; +# ifdef DEBUG_ATTACK_ATTACKERS1 + bb_print("att rook/queen", tmp); + bb_print("ATTACKERS", attackers); + printf("attackers=%lx\n", attackers); +# endif + + return attackers; +} + +/** + * sq_pinners() - get "pinners" on a square + * @pos: position + * @sq: square to test + * @color: attacker color + * + * Find all @c pieces which are separated from @sq by only one piece (of + * any color). + * + * @Return: bitboard of pinners. + */ +bitboard_t sq_pinners(const pos_t *pos, const square_t sq, const color_t color) +{ + bitboard_t attackers, pinners = 0; + bitboard_t occ = pos_occ(pos); + bitboard_t maybe_pinner, tmp, lines; + + /* bishop type */ + attackers = pos->bb[color][BISHOP] | pos->bb[color][QUEEN]; + /* occupancy on sq diag and antidiag */ + lines = (bb_sqdiag[sq] | bb_sqanti[sq]) & occ; + bit_for_each64(maybe_pinner, tmp, attackers) { + bitboard_t between = bb_between_excl[maybe_pinner][sq]; + /* keep only squares between AND on sq diag/anti */ + if (popcount64(between & lines) == 1) + pinners |= mask(maybe_pinner); + } + + /* same for rook type */ + attackers = pos->bb[color][ROOK] | pos->bb[color][QUEEN]; + lines = (bb_sqrank[sq] | bb_sqfile[sq]) & occ; + bit_for_each64(maybe_pinner, tmp, attackers) { + bitboard_t between = bb_between_excl[maybe_pinner][sq]; + if (popcount64(between & lines) == 1) + pinners |= mask(maybe_pinner); + } +# ifdef DEBUG_ATTACK_ATTACKERS1 + char str[32]; + printf("pinners : %s\n", pos_pinners2str(pos, str, sizeof(str))); + printf("pinners : %lx\n", pinners); +# endif + return pinners; +} + +/** + * sq_attackers() - find all attackers on a square + * @pos: position + * @sq: square to test + * + * Find all attacks on @sq. En-passant is not considered. + * Just a wrapper over @sq_attackers(). + * + * @Return: a bitboard of attackers. + */ +bitboard_t sq_attackers_all(const pos_t *pos, const square_t sq) +{ + bitboard_t occ = pos_occ(pos); + return sq_attackers(pos, occ, sq, WHITE) | sq_attackers(pos, occ, sq, BLACK); +} diff --git a/src/attack.h b/src/attack.h new file mode 100644 index 0000000..603a965 --- /dev/null +++ b/src/attack.h @@ -0,0 +1,23 @@ +/* attack.h - attack 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#ifndef _ATTACK_H +#define _ATTACK_H + +#include "chessdefs.h" +#include "bitboard.h" + +bitboard_t sq_attackers(const pos_t *pos, const bitboard_t occ, const square_t sq, const color_t c); +bitboard_t sq_attackers_all(const pos_t *pos, const square_t sq); +bitboard_t sq_pinners(const pos_t *pos, const square_t sq, const color_t c); +#endif diff --git a/src/bitboard.c b/src/bitboard.c new file mode 100644 index 0000000..e78e3d6 --- /dev/null +++ b/src/bitboard.c @@ -0,0 +1,330 @@ +/* bitboard.c - bitboard 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include +#include + +#include "brlib.h" + +#include "chessdefs.h" +#include "piece.h" +#include "board.h" +#include "bitboard.h" + +bitboard_t bb_sq[64]; +bitboard_t bb_sqrank[64], bb_sqfile[64], bb_sqdiag[64], bb_sqanti[64]; +bitboard_t bb_between_excl[64][64]; +bitboard_t bb_between[64][64]; +bitboard_t bb_line[64][64]; + +bitboard_t bb_knight[64], bb_king[64]; + +/* vectors are clockwise from N */ +static int knight_vector[] = { + NORTH_EAST + NORTH, NORTH_EAST + EAST, + SOUTH_EAST + EAST, SOUTH_EAST + SOUTH, + SOUTH_WEST + SOUTH, SOUTH_WEST + WEST, + NORTH_WEST + WEST, NORTH_WEST + NORTH +}; +static int king_vector[8] = { + NORTH, NORTH_EAST, EAST, SOUTH_EAST, + SOUTH, SOUTH_WEST, WEST, NORTH_WEST +}; + +/** + * bitboard_between_excl() - get bitboard of squares between two squares. + * @sq1, @sq2: The two square_t squares + * + * From: http://www.talkchess.com/forum3/viewtopic.php?f=7&t=12499&start=14 + * This function may be used instead of bb_XXX arrays if cache pressure is high. + * + * @Return: bitboard_t, squares between @sq1 and @sq2 (excl. @sq1 and @sq2). + */ +bitboard_t bitboard_between_excl(square_t sq1, square_t sq2) +{ + const bitboard_t m1 = -1; + const bitboard_t a2a7 = C64(0x0001010101010100); + const bitboard_t b7h1 = C64(0x0002040810204080); + bitboard_t btwn_bits, ray_bits; + u32 rank_diff, file_diff, anti_diff, diag_diff; + + btwn_bits = (m1 << sq1) ^ (m1 << sq2); /* includes sq1 and sq2 */ + rank_diff = ((sq2 | 7) - sq1) >> 3, /* signed */ + file_diff = (sq2 & 7) - (sq1 & 7); /* signed */ + + anti_diff = rank_diff + file_diff; + rank_diff = rank_diff & 15; + file_diff = file_diff & 15; + anti_diff = anti_diff & 15; + diag_diff = rank_diff ^ file_diff; + ray_bits = 2 * ((rank_diff - 1) >> 26); + + ray_bits |= bswap64((m1 + diag_diff) & b7h1); + ray_bits |= (m1 + anti_diff) & b7h1; + ray_bits |= (m1 + file_diff) & a2a7; + ray_bits *= btwn_bits & -btwn_bits; + return ray_bits & btwn_bits; +} + +/** + * bitboard_init() - initialize general bitboards + * + * Generate the following bitboards : + * bb_sq[64]: square to bitboard + * bb_sqrank[64]: square to rank + * bb_sqfile[64]: square to file + * bb_sqdiag[64]: square to diagonal + * bb_sqanti[64]: square to antidiagonal + * + * bb_between_excl[64][64]: strict squares between two squares + * bb_between[64][64]: squares between two squares including second square + * + * And the following pseudo move masks: + * bb_knight[64]: knight moves + * bb_king[64]: king moves + * + */ +void bitboard_init(void) +{ + /* for each square, the 4 masks: file, rank, diagonal, antidiagonal */ + struct { int df, dr; } vecs[4] = { + { 0, 1 }, /* vertical/file */ + { 1, 0 }, /* horizontal/rank */ + { 1, 1 }, /* diagonal */ + { 1, -1 }, /* antidiagonal */ + } ; + bitboard_t tmpbb[64][4] = { 0 }; + + /* 1) square to bitboard, and in-between-sq2-excluded */ + for (square_t sq1 = A1; sq1 <= H8; ++sq1) { + bb_sq[sq1] = mask(sq1); + for (square_t sq2 = A1; sq2 <= H8; ++sq2) + bb_between_excl[sq1][sq2] = bitboard_between_excl(sq1, sq2); + } + + /* 2) sq1-to-sq2 mask, sq2 included + * square to file/rank/dia/anti bitmaps + */ + for (square_t sq = 0; sq < 64; ++sq) { + file_t f = sq_file(sq); + rank_t r = sq_rank(sq); + for (int vec = 0; vec < 4; ++vec) { + tmpbb[sq][vec] |= mask(sq_make(f, r)); + for (int dir = -1; dir <= 1; dir += 2) { + file_t df = dir * vecs[vec].df, f2 = f + df; + rank_t dr = dir * vecs[vec].dr, r2 = r + dr; + bitboard_t mask_between = 0; + while (sq_coord_ok(f2) && sq_coord_ok(r2)) { + square_t dest = sq_make(f2, r2); + tmpbb[sq][vec] |= mask(dest); + mask_between |= mask(dest); + bb_between[sq][dest] = mask_between; + f2 += df, r2 += dr; + } + } + } + } + for (square_t sq = 0; sq < 64; ++sq) { + bb_sqfile[sq] = tmpbb[sq][0]; + bb_sqrank[sq] = tmpbb[sq][1]; + bb_sqdiag[sq] = tmpbb[sq][2]; + bb_sqanti[sq] = tmpbb[sq][3]; + } + for (square_t sq1 = 0; sq1 < 64; ++sq1) { + for (square_t sq2 = 0; sq2 < 64; ++sq2) { + if (sq1 != sq2) { + if (bb_sqfile[sq1] == bb_sqfile[sq2]) + bb_line[sq1][sq2] = bb_sqfile[sq1]; + else if (bb_sqrank[sq1] == bb_sqrank[sq2]) + bb_line[sq1][sq2] = bb_sqrank[sq1]; + else if (bb_sqdiag[sq1] == bb_sqdiag[sq2]) + bb_line[sq1][sq2] = bb_sqdiag[sq1]; + else if (bb_sqanti[sq1] == bb_sqanti[sq2]) + bb_line[sq1][sq2] = bb_sqanti[sq1]; + + //if (bb_line[sq1][sq2]) { + // printf("bb_line[%d][%d] = %16lx\n", sq1, sq2, bb_line[sq1][sq2]); + //} + } + } + } + + /* 3) knight and king moves */ + for (square_t sq = A1; sq <= H8; ++sq) { + //rank_t r1 = sq_rank(sq); + //file_t f1 = sq_file(sq); + for (int vec = 0; vec < 8; ++vec) { + int dst = sq + knight_vector[vec]; + if (sq_ok(dst)) { + if (sq_dist(dst, sq) == 2) { + bb_knight[sq] |= bb_sq[dst]; + } + } + dst = sq + king_vector[vec]; + if (sq_ok(dst)) { + if (sq_dist(dst, sq) == 1) { + bb_king[sq] |= bb_sq[dst]; + } + } + } + } +} + + +/** + * bb_knight_moves() - get bitboard of knight pseudo-moves + * @notmine: bitboard_t of squares not occupied by own pieces + * @sq: knight square + * + * @Return: bitboard of available moves. + */ +bitboard_t bb_knight_moves(bitboard_t notmine, square_t sq) +{ + //bitboard_print("bb_knight_move mask", bb_knight[sq]); + //bitboard_print("bb_knight_move res", bb_knight[sq] & notmine); + return bb_knight[sq] & notmine; +} + +/** + * bb_king_moves() - get bitboard of king pseudo-moves + * @notmine: bitboard_t of squares not occupied by own pieces + * @sq: king square + * + * @Return: bitboard of available moves. + */ +bitboard_t bb_king_moves(bitboard_t notmine, square_t sq) +{ + return bb_king[sq] & notmine; +} + +/** + * bb_print() - print simple bitboard representation + * @title: a string or NULL + * @bitboard: the bitboard + */ +void bb_print(const char *title, const bitboard_t bitboard) +{ + //char c = p? p: 'X'; + if (title) + printf("%s\n", title); + for (rank_t r = RANK_8; r >= RANK_1; --r) { + printf("%d ", r + 1); + for (file_t f = FILE_A; f <= FILE_H; ++f) { + printf(" %c", bitboard & bb_sq[sq_make(f, r)] ? 'X': '.'); + } + printf("\n"); + } + printf(" a b c d e f g h\n"); + return; +} + +/** + * bb_print_multi() - print multiple bitboards horizontally + * @title: a string or NULL + * @n: number of bitboards + * @bb_ptr...: pointers to bitboards + * + * @n is the number of bitboards to print. If @n > 10, it is reduced to 10 + */ +void bb_print_multi(const char *title, int n, ...) +{ + bitboard_t bb[8]; + va_list ap; + + n = min(n, 10); + + va_start(ap, n); + for (int i = 0; i < n; ++i) { /* save all bitboards */ + bb[i] = va_arg(ap, bitboard_t); + } + va_end(ap); + + if (title) + printf("%s\n", title); + + for (rank_t r = RANK_8; r >= RANK_1; --r) { + for (int i = 0; i < n; ++i) { + printf("%d ", r + 1); + for (file_t f = FILE_A; f <= FILE_H; ++f) { + printf(" %c", bb[i] & bb_sq[sq_make(f, r)] ? 'X': '.'); + } + printf(" "); + } + printf("\n"); + } + for (int i = 0; i < n; ++i) { + printf(" a b c d e f g h"); + printf(" "); + } + printf("\n"); + return; +} + +/** + * bb_rank_sprint() - print an u8 rank binary representation + * @str: the destination string + * @bb8: the uchar to print + * + * @return: @str, filled with ascii representation + */ +char *bb_rank_sprint(char *str, const uchar bb8) +{ + file_t f; + for (f = FILE_A; f <= FILE_H; ++f) { + *(str + f) = bb8 & mask(f) ? '1': '.'; + } + *(str + f) = 0; + //printf(" 0 1 2 3 4 5 6 7\n"); + //printf("\n"); + return str; +} + +/** + * bb_sq2str() - convert bitboard to a string with a list of squares. + * @bb: bitboard + * @str: destination string + * @len: max @str length + * + * @str will be filled with the list of string representation of @bb, up to @len + * characters. + * 3 characters are used per square, so, for example, @str len should be : + * - For a valid position checkers (two checkers max): 2*3 + 1 = 7. + * - For a valid position pinners (8 pinners): 8*3 + 1 = 25. + * - for a full bitboard: 64*3 + 1 = 193. + * + * If @len is not enough to fill all moves, the last fitting move is replaced by "...". + * + * @return: The string. + */ +char *bb_sq2str(const bitboard_t bb, char *str, const int len) +{ + bitboard_t tmp, sq; + int nocc = popcount64(bb); + int needed = 3 * nocc + 1; + int willdo = (int) len >= needed ? nocc: (len - 1) / 3 - 1; + int current = 0; + + //printf("sq2str bb=%lx len=%d willdo=%d\n", bb, len, willdo); + bit_for_each64(sq, tmp, bb) { + if (current == willdo) { + strcpy(str + current * 3, "..."); + } else { + strcpy(str + current * 3, sq_to_string(sq)); + str[current * 3 + 2] = ' '; + } + if (++current > willdo) + break; + } + str[current * 3] = 0; + return str; +} diff --git a/src/bitboard.h b/src/bitboard.h index c7f3348..c537946 100644 --- a/src/bitboard.h +++ b/src/bitboard.h @@ -1,6 +1,6 @@ /* bitboard.h - bitboard definitions. * - * Copyright (C) 2021 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. * @@ -11,60 +11,276 @@ * */ -#ifndef BITBOARD_H -#define BITBOARD_H +#ifndef _BITBOARD_H +#define _BITBOARD_H -#include "br.h" -#include "chessdefs.h" -#include "piece.h" +#include "brlib.h" #include "bitops.h" -enum bb_square { - A1 = 1UL << 0, B1 = 1UL << 1, C1 = 1UL << 2, D1 = 1UL << 3, - E1 = 1UL << 4, F1 = 1UL << 5, G1 = 1UL << 6, H1 = 1UL << 7, +#include "chessdefs.h" +#include "board.h" +#include "piece.h" - A2 = 1UL << 8, B2 = 1UL << 9, C2 = 1UL << 10, D2 = 1UL << 11, - E2 = 1UL << 12, F2 = 1UL << 13, G2 = 1UL << 14, H2 = 1UL << 15, +/* mapping square -> bitboard */ +extern bitboard_t bb_sq[64]; +/* squares between sq1 and sq2, exclusing both */ +extern bitboard_t bb_between_excl[64][64]; +/* squares between sq1 and sq2, including sq2 */ +extern bitboard_t bb_between[64][64]; - A3 = 1UL << 16, B3 = 1UL << 17, C3 = 1UL << 18, D3 = 1UL << 19, - E3 = 1UL << 20, F3 = 1UL << 21, G3 = 1UL << 22, H3 = 1UL << 23, +/** + * bb_sqrank[64]: square to rank + * bb_sqfile[64]: square to file + * bb_sqdiag[64]: square to diagonal + * bb_sqanti[64]: square to antidiagonal + */ +extern bitboard_t bb_sqrank[64], bb_sqfile[64], bb_sqdiag[64], bb_sqanti[64]; - A4 = 1UL << 24, B4 = 1UL << 25, C4 = 1UL << 26, D4 = 1UL << 27, - E4 = 1UL << 28, F4 = 1UL << 29, G4 = 1UL << 30, H4 = 1UL << 31, +/* line (rank, file, diagonal or anti-diagonal) between two squares */ +extern bitboard_t bb_line[64][64]; - A5 = 1UL << 32, B5 = 1UL << 33, C5 = 1UL << 34, D5 = 1UL << 35, - E5 = 1UL << 36, F5 = 1UL << 37, G5 = 1UL << 38, H5 = 1UL << 39, +/* knight and king moves */ +extern bitboard_t bb_knight[64], bb_king[64]; - A6 = 1UL << 40, B6 = 1UL << 41, C6 = 1UL << 42, D6 = 1UL << 43, - E6 = 1UL << 44, F6 = 1UL << 45, G6 = 1UL << 46, H6 = 1UL << 47, - A7 = 1UL << 48, B7 = 1UL << 49, C7 = 1UL << 50, D7 = 1UL << 51, - E7 = 1UL << 52, F7 = 1UL << 53, G7 = 1UL << 54, H7 = 1UL << 55, +/* TODO (maybe C23?) when we can ensure an enum can be u64 + * + * enum { + * A1bb = mask(A1), A2bb = mask(A2), A3bb = mask(A3), A4bb = mask(A4), + * A5bb = mask(A5), A6bb = mask(A6), A7bb = mask(A7), A8bb = mask(A8), + * B1bb = mask(B1), B2bb = mask(B2), B3bb = mask(B3), B4bb = mask(B4), + * B5bb = mask(B5), B6bb = mask(B6), B7bb = mask(B7), B8bb = mask(B8), + * C1bb = mask(C1), C2bb = mask(C2), C3bb = mask(C3), C4bb = mask(C4), + * C5bb = mask(C5), C6bb = mask(C6), C7bb = mask(C7), C8bb = mask(C8), + * D1bb = mask(D1), D2bb = mask(D2), D3bb = mask(D3), D4bb = mask(D4), + * D5bb = mask(D5), D6bb = mask(D6), D7bb = mask(D7), D8bb = mask(D8), + * E1bb = mask(E1), E2bb = mask(E2), E3bb = mask(E3), E4bb = mask(E4), + * E5bb = mask(E5), E6bb = mask(E6), E7bb = mask(E7), E8bb = mask(E8), + * F1bb = mask(F1), F2bb = mask(F2), F3bb = mask(F3), F4bb = mask(F4), + * F5bb = mask(F5), F6bb = mask(F6), F7bb = mask(F7), F8bb = mask(F8), + * G1bb = mask(G1), G2bb = mask(G2), G3bb = mask(G3), G4bb = mask(G4), + * G5bb = mask(G5), G6bb = mask(G6), G7bb = mask(G7), G8bb = mask(G8), + * H1bb = mask(H1), H2bb = mask(H2), H3bb = mask(H3), H4bb = mask(H4), + * H5bb = mask(H5), H6bb = mask(H6), H7bb = mask(H7), H8bb = mask(H8), + * }; + * + * enum { + * FILE_Abb = 0x0101010101010101ull, FILE_Bbb = 0x0202020202020202ull, + * FILE_Cbb = 0x0404040404040404ull, FILE_Dbb = 0x0808080808080808ull, + * FILE_Ebb = 0x1010101010101010ull, FILE_Fbb = 0x2020202020202020ull, + * FILE_Gbb = 0x4040404040404040ull, FILE_Hbb = 0x8080808080808080ull, + * + * RANK_1bb = 0x00000000000000ffull, RANK_2bb = 0x000000000000ff00ull, + * RANK_3bb = 0x0000000000ff0000ull, RANK_4bb = 0x00000000ff000000ull, + * RANK_5bb = 0x000000ff00000000ull, RANK_6bb = 0x0000ff0000000000ull, + * RANK_7bb = 0x00ff000000000000ull, RANK_8bb = 0xff00000000000000ull + * }; + */ - A8 = 1UL << 56, B8 = 1UL << 57, C8 = 1UL << 58, D8 = 1UL << 59, - E8 = 1UL << 60, F8 = 1UL << 61, G8 = 1UL << 62, H8 = 1UL << 63, -}; +/* generated with bash: + * R="ABCDEFGH" + * F="12345678" + * for i in {0..63}; do + * printf "#define %c%cbb %#018llxull\n" ${R:i/8:1} ${F:i%8:1} $((1 << i)) + * done + */ +#define A1bb 0x0000000000000001ull +#define A2bb 0x0000000000000002ull +#define A3bb 0x0000000000000004ull +#define A4bb 0x0000000000000008ull +#define A5bb 0x0000000000000010ull +#define A6bb 0x0000000000000020ull +#define A7bb 0x0000000000000040ull +#define A8bb 0x0000000000000080ull +#define B1bb 0x0000000000000100ull +#define B2bb 0x0000000000000200ull +#define B3bb 0x0000000000000400ull +#define B4bb 0x0000000000000800ull +#define B5bb 0x0000000000001000ull +#define B6bb 0x0000000000002000ull +#define B7bb 0x0000000000004000ull +#define B8bb 0x0000000000008000ull +#define C1bb 0x0000000000010000ull +#define C2bb 0x0000000000020000ull +#define C3bb 0x0000000000040000ull +#define C4bb 0x0000000000080000ull +#define C5bb 0x0000000000100000ull +#define C6bb 0x0000000000200000ull +#define C7bb 0x0000000000400000ull +#define C8bb 0x0000000000800000ull +#define D1bb 0x0000000001000000ull +#define D2bb 0x0000000002000000ull +#define D3bb 0x0000000004000000ull +#define D4bb 0x0000000008000000ull +#define D5bb 0x0000000010000000ull +#define D6bb 0x0000000020000000ull +#define D7bb 0x0000000040000000ull +#define D8bb 0x0000000080000000ull +#define E1bb 0x0000000100000000ull +#define E2bb 0x0000000200000000ull +#define E3bb 0x0000000400000000ull +#define E4bb 0x0000000800000000ull +#define E5bb 0x0000001000000000ull +#define E6bb 0x0000002000000000ull +#define E7bb 0x0000004000000000ull +#define E8bb 0x0000008000000000ull +#define F1bb 0x0000010000000000ull +#define F2bb 0x0000020000000000ull +#define F3bb 0x0000040000000000ull +#define F4bb 0x0000080000000000ull +#define F5bb 0x0000100000000000ull +#define F6bb 0x0000200000000000ull +#define F7bb 0x0000400000000000ull +#define F8bb 0x0000800000000000ull +#define G1bb 0x0001000000000000ull +#define G2bb 0x0002000000000000ull +#define G3bb 0x0004000000000000ull +#define G4bb 0x0008000000000000ull +#define G5bb 0x0010000000000000ull +#define G6bb 0x0020000000000000ull +#define G7bb 0x0040000000000000ull +#define G8bb 0x0080000000000000ull +#define H1bb 0x0100000000000000ull +#define H2bb 0x0200000000000000ull +#define H3bb 0x0400000000000000ull +#define H4bb 0x0800000000000000ull +#define H5bb 0x1000000000000000ull +#define H6bb 0x2000000000000000ull +#define H7bb 0x4000000000000000ull +#define H8bb 0x8000000000000000ull -enum bb_files { - F_1 = A1 | A2 | A3 | A4 | A5 | A6 | A7 | A8, - F_2 = B1 | B2 | B3 | B4 | B5 | B6 | B7 | B8, - F_3 = C1 | C2 | C3 | C4 | C5 | C6 | C7 | C8, - F_4 = D1 | D2 | D3 | D4 | D5 | D6 | D7 | D8, - F_5 = E1 | E2 | E3 | E4 | E5 | E6 | E7 | E8, - F_6 = F1 | F2 | F3 | F4 | F5 | F6 | F7 | F8, - F_7 = G1 | G2 | G3 | G4 | G5 | G6 | G7 | G8, - F_8 = H1 | H2 | H3 | H4 | H5 | H6 | H7 | H8, -}; +#define FILE_Abb 0x0101010101010101ull +#define FILE_Bbb 0x0202020202020202ull +#define FILE_Cbb 0x0404040404040404ull +#define FILE_Dbb 0x0808080808080808ull +#define FILE_Ebb 0x1010101010101010ull +#define FILE_Fbb 0x2020202020202020ull +#define FILE_Gbb 0x4040404040404040ull +#define FILE_Hbb 0x8080808080808080ull -enum bb_ranges { - R_1 = A1 | B1 | C1 | D1 | E1 | F1 | G1 | H1, - R_2 = A2 | B2 | C2 | D2 | E2 | F2 | G2 | H2, - R_3 = A3 | B3 | C3 | D3 | E3 | F3 | G3 | H3, - R_4 = A4 | B4 | C4 | D4 | E4 | F4 | G4 | H4, - R_5 = A5 | B5 | C5 | D5 | E5 | F5 | G5 | H5, - R_6 = A6 | B6 | C6 | D6 | E6 | F6 | G6 | H6, - R_7 = A7 | B7 | C7 | D7 | E7 | F7 | G7 | H7, - R_8 = A8 | B8 | C8 | D8 | E8 | F8 | G8 | H8, -}; +#define RANK_1bb 0x00000000000000ffull +#define RANK_2bb 0x000000000000ff00ull +#define RANK_3bb 0x0000000000ff0000ull +#define RANK_4bb 0x00000000ff000000ull +#define RANK_5bb 0x000000ff00000000ull +#define RANK_6bb 0x0000ff0000000000ull +#define RANK_7bb 0x00ff000000000000ull +#define RANK_8bb 0xff00000000000000ull -#endif /* BOARD_H */ + +/* +static __always_inline bitboard_t bb_rank(int rank) +{ + return RANK_1bb << (rank * 8); +} +static __always_inline bitboard_t bb_rel_rank(int rank, color) +{ + return RANK_1bb << (rank * 8); +} +static __always_inline bitboard_t bb_file(int file) +{ + return FILE_Abb << file; +} +*/ + +#define bb_rank(r) ((u64) RANK_1bb << ((r) * 8)) +#define BB_FILE(f) ((u64) FILE_Abb << (f)) + +#define bb_rel_rank(r, c) bb_rank(sq_rel_rank(r, c)) + +//#define BB_REL_RANK(r, c) (RANK_1bb << (SQ_REL_RANK(r, c) * 8)) +//#define BB_REL_FILE(f, c) (FILE_Abb << (SQ_REL_RANK((f), (c)))) + +/** + * bb_sq_aligned() - check if two squares are aligned (same file or rank). + * @sq1, @sq2: the two squares. + * + * @return: true if @sq1 and @sq2 are on same line, false otherwise. + */ +static __always_inline bool bb_sq_aligned(square_t sq1, square_t sq2) +{ + return bb_line[sq1][sq2]; +} + +/** + * bb_sq_aligned3() - check if 3 squares are aligned (same file or rank). + * @sq1, @sq2, @sq3: the three squares. + * + * @return: true if @sq1, @sq2, and @sq3 are aligned, false otherwise. + */ +static __always_inline bool bb_sq_aligned3(square_t sq1, square_t sq2, square_t sq3) +{ + return bb_line[sq1][sq2] & mask(sq3); +} + +/** + * bb_sq_between() - check if a square is between two squares + * @sq: the possibly "in-between" square + * @sq1: square 1 + * @sq2: square 2 + * + * @return: bitboard of @betw if between @sq1 and @sq2. + */ +static __always_inline bitboard_t bb_sq_between(square_t sq, square_t sq1, square_t sq2) +{ + return bb_between_excl[sq1][sq2] & mask(sq); +} + +/* TODO: when OK, replace with macros */ +static __always_inline bitboard_t shift_n(const bitboard_t bb) +{ + return bb << NORTH; +} +static __always_inline bitboard_t shift_ne(const bitboard_t bb) +{ + return (bb & ~FILE_Hbb) << NORTH_EAST; +} +static __always_inline bitboard_t shift_e(const bitboard_t bb) +{ + return (bb & ~FILE_Hbb) << EAST; +} +static __always_inline bitboard_t shift_se(const bitboard_t bb) +{ + return (bb & ~FILE_Hbb) >> -SOUTH_EAST; +} +static __always_inline bitboard_t shift_s(const bitboard_t bb) +{ + return bb >> -SOUTH; +} +static __always_inline bitboard_t shift_sw(const bitboard_t bb) +{ + return (bb & ~FILE_Abb) >> -SOUTH_WEST; +} +static __always_inline bitboard_t shift_w(const bitboard_t bb) +{ + return (bb & ~FILE_Abb) >> -WEST; +} +static __always_inline bitboard_t shift_nw(const bitboard_t bb) +{ + return (bb & ~FILE_Abb) << NORTH_WEST; +} + +#define pawn_up_value(c) ((c) == WHITE ? 8: -8) +/* pawn moves/attacks (for bitboards) */ +#define pawn_shift_up(bb, c) ((c) == WHITE ? shift_n(bb): shift_s(bb)) +#define pawn_shift_upleft(bb, c) ((c) == WHITE ? shift_nw(bb): shift_se(bb)) +#define pawn_shift_upright(bb, c) ((c) == WHITE ? shift_ne(bb): shift_sw(bb)) +/* pawn move (for single pawn) - NO SQUARE CONTROL HERE ! + * Need to make functions with control instead. + */ +#define pawn_push_up(sq, c) ((sq) + ((c) == WHITE ? NORTH: SOUTH)) +#define pawn_push_upleft(sq, c) ((sq) + ((c) == WHITE ? NORTH_WEST: SOUTH_EAST)) +#define pawn_push_upright(sq, c) ((sq) + ((c) == WHITE ? NORTH_EAST: SOUTH_WEST)) + +extern bitboard_t bitboard_between_excl(square_t sq1, square_t sq2); +extern void bitboard_init(void); + +extern bitboard_t bb_knight_moves(bitboard_t occ, square_t sq); +extern bitboard_t bb_king_moves(bitboard_t occ, square_t sq); + +extern void bb_print(const char *title, const bitboard_t bitboard); +extern void bb_print_multi(const char *title, const int n, ...); +extern char *bb_rank_sprint(char *str, const uchar bb8); +extern char *bb_sq2str(const bitboard_t bb, char *str, int len); + +#endif /* _BITBOARD_H */ diff --git a/src/board.c b/src/board.c new file mode 100644 index 0000000..aade98d --- /dev/null +++ b/src/board.c @@ -0,0 +1,128 @@ +/* board.c - 8x8 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include +#include + +#include "brlib.h" +#include "board.h" +#include "bitboard.h" + +static const char *sq_strings[] = { + "a1", "b1", "c1", "d1", "e1", "f1", "g1", "h1", + "a2", "b2", "c2", "d2", "e2", "f2", "g2", "h2", + "a3", "b3", "c3", "d3", "e3", "f3", "g3", "h3", + "a4", "b4", "c4", "d4", "e4", "f4", "g4", "h4", + "a5", "b5", "c5", "d5", "e5", "f5", "g5", "h5", + "a6", "b6", "c6", "d6", "e6", "f6", "g6", "h6", + "a7", "b7", "c7", "d7", "e7", "f7", "g7", "h7", + "a8", "b8", "c8", "d8", "e8", "f8", "g8", "h8", +}; + +/** + * sq_to_string() - return a square string + * @square: square (0-64) + * + * @Return: Pointer to @square string representation ("a1"-"h8"). + */ +const char *sq_to_string(const square_t square) +{ + return sq_strings[square]; +} + +/** + * sq_from_string() - return a square from a string + * @sqstr: the square representation (a1-h8) + * + * @Return: square_t representation of str. + */ +square_t sq_from_string(const char *sqstr) +{ + file_t f = C2FILE(sqstr[0]); + rank_t r = C2RANK(sqstr[1]); + return sq_coord_ok(f) && sq_coord_ok(r) ? sq_make(f, r): SQUARE_NONE; +} + +/** + * board_print() - Print a board + * @board: &board_t to print + */ +void board_print(const piece_t *board) +{ + printf(" +---+---+---+---+---+---+---+---+\n"); + for (int rank = 7; rank >= 0; --rank) { + printf("%c |", rank + '1'); + for (int file = 0; file < 8; ++file) { + piece_t pc = board[sq_make(file, rank)]; +# ifdef DIAGRAM_SYM + printf(" %s |", pc? piece_to_sym(pc): " "); +# else + printf(" %s |", pc? piece_to_fen(pc): " "); +# endif + } + printf("\n +---+---+---+---+---+---+---+---+\n"); + } + printf(" A B C D E F G H\n"); +} + +/** + * board_print_mask() - Print a board position with some reversed squares + * @board: &board_t to print + * @mask: a bitboard indicating reverse color displayed squares + * + * Squares corresponding to @mask will be displayed in reverse colors. + */ +void board_print_mask(const piece_t *board, const bitboard_t mask) +{ + // 6: blink +# define REVERSE "\e[7m▌" +# define RESET "▐\e[0m" + printf(" +---+---+---+---+---+---+---+---+\n"); + for (int rank = 7; rank >= 0; --rank) { + printf("%c |", rank + '1'); + for (int file = 0; file < 8; ++file) { + square_t sq = sq_make(file, rank); + piece_t pc = board[sq]; + bitboard_t set = mask(sq) & mask; + printf("%s", set? REVERSE : " "); +# ifdef DIAGRAM_SYM + printf("%s", pc? piece_to_sym(pc): " "); +# else + printf("%s", pc? piece_to_char_color(pc): " "); +# endif + printf("%s|", set? RESET : " "); + } + printf("\n +---+---+---+---+---+---+---+---+\n"); + } + printf(" A B C D E F G H\n"); +} + +/** + * board_print_raw - print raw (octal or FEN symbol) board + * @bb: the bitboard + * @type: int, 0 for octal, 1 for fen symbol + */ +void board_print_raw(const piece_t *board, const int type) +{ + for (rank_t r = RANK_8; r >= RANK_1; --r) { + for (file_t f = FILE_A; f <= FILE_H; ++f) { + piece_t p = board[sq_make(f, r)]; + if (type) { + printf("%s ", p == EMPTY? ".": piece_to_char(p)); + } else { + printf("%02o ", p); + } + } + printf("\n"); + } +} diff --git a/src/board.h b/src/board.h index 6543eb2..b10a35c 100644 --- a/src/board.h +++ b/src/board.h @@ -1,6 +1,6 @@ -/* board.h - board definitions. +/* board.h - 8x8 board definitions. * - * Copyright (C) 2021 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. * @@ -11,70 +11,83 @@ * */ -#ifndef BOARD_H -#define BOARD_H +#ifndef _BOARD_H +#define _BOARD_H + +#include "brlib.h" -#include #include "chessdefs.h" #include "piece.h" +#include "bitboard.h" -typedef struct board_s { - piece_t piece; - piece_list_t *s_piece; - //struct list_head *s_piece; -} board_t; /* 0x88 board */ -#define BOARDSIZE (8*8*2) +/* from human to machine */ +#define C2FILE(c) (tolower(c) - 'a') +#define C2RANK(c) (tolower(c) - '1') +/* from machine to human */ +#define FILE2C(f) ((f) + 'a') +#define RANK2C(r) ((r) + '1') -/* definitions for 0x88 representation +/* a square is defined as + * rrrfff */ -#define SQ88(f, r) (((r) << 4) | (f)) /* from rank,file to sq88 */ -#define F88(s) ((s) & 0x0f) /* from sq88 to file */ -#define R88(s) ((s) >> 4) /* from sq88 to rank */ +#define SQ_FILEMASK (007) /* warning, octal */ +#define SQ_RANKMASK (070) -#define SETF88(s, r) ((s) &= 0xf0, (s) |= (r)) -#define SETR88(s, f) ((s) &= 0x0f, (s) |= (f)<<4) -#define SQ88_NOK(s) ((s) & 0x88) /* invalid square */ -#define SQ88_OK(s) (!SQ88_NOK(s)) - -/* definitions for bitboard representation +/* flip a 0-63 square: + * Vertical: G8 (62) becomes G1 (6) + * Horizontal: G8 (62) becomes B8 (57) */ -#define BB(f, r) (1ULL << (8 * (r) + (f))) /* from rank,file to bitboard */ -#define SQ88_2_BB(s) (BB(F88(s), R88(s))) /* from sq88 to bitboard */ -#define FILEBB(b) ((b) % 8) /* from sq88 to file */ -#define RANKBB(b) ((b) / 8) /* from sq88 to rank */ +#define FLIP_V(sq) ((sq) ^ 56) +#define FLIP_H(sq) ((sq) ^ 7) +#define FLIP_HV(sq) ((sq) ^ 63) /* FLIP_V ^ FLIP_H */ -#define SQ88_NOK(s) ((s) & 0x88) /* invalid square */ -#define SQ88_OK(s) (!SQ88_NOK(s)) +/* TODO: revert to macros after bitboard migration */ +static __always_inline square_t sq_make(file_t file, rank_t rank) +{ + return (rank << 3) + file; +} +static __always_inline file_t sq_file(square_t square) +{ + return square & SQ_FILEMASK; +} +static __always_inline rank_t sq_rank(square_t square) +{ + return square >> 3; +} -/* piece human notation +#define sq_ok(sq) ((sq) >= A1 && (sq) <= H8) +#define sq_coord_ok(c) ((c) >= 0 && (c) < 8) + +/** + * sq_dist() - Chebyshev (king) distance between two squares (macro). + * @sq1, @sq2: The two squares. + * + * See: https://www.chessprogramming.org/Distance + * Distance is max( |r2 - r1|, |f2 - f1| ) + * + * @Return: the Chebyshev distance. */ -#define CHAR_EMPTY ' ' -#define CHAR_PAWN 'P' -#define CHAR_KNIGHT 'N' -#define CHAR_BISHOP 'B' -#define CHAR_ROOK 'R' -#define CHAR_QUEEN 'Q' -#define CHAR_KING 'K' +#define sq_dist(sq1, sq2) (max(abs(sq_file(sq2) - sq_file(sq1)), \ + abs(sq_rank(sq2) - sq_rank(sq1)))) -/* from human to machine +/** + * sq_taxi() - Manhattan (taxi) distance between two squares (macro). + * @sq1, @sq2: The two squares. + * + * See: https://www.chessprogramming.org/Distance + * Distance is |r2 - r1| + |f2 - f1|. + * + * @Return: the Manhattan distance. */ -#define C2FILE(c) (tolower(c) - 'a') -#define C2RANK(c) (tolower(c) - '1') -/* from machine to human - */ -#define FILE2C(f) ((f) + 'a') -#define RANK2C(r) ((r) + '1') +#define sq_taxi(sq1, sq2) (abs(sq_file(sq2) - sq_file(sq1)) + \ + abs(sq_rank(sq2) - sq_rank(sq1))) -enum x88_square { - x88_A1=0x00, x88_B1, x88_C1, x88_D1, x88_E1, x88_F1, x88_G1, x88_H1, - x88_A2=0x10, x88_B2, x88_C2, x88_D2, x88_E2, x88_F2, x88_G2, x88_H2, - x88_A3=0x20, x88_B3, x88_C3, x88_D3, x88_E3, x88_F3, x88_G3, x88_H3, - x88_A4=0x30, x88_B4, x88_C4, x88_D4, x88_E4, x88_F4, x88_G4, x88_H4, - x88_A5=0x40, x88_B5, x88_C5, x88_D5, x88_E5, x88_F5, x88_G5, x88_H5, - x88_A6=0x50, x88_B6, x88_C6, x88_D6, x88_E6, x88_F6, x88_G6, x88_H6, - x88_A7=0x60, x88_B7, x88_C7, x88_D7, x88_E7, x88_F7, x88_G7, x88_H7, - x88_A8=0x70, x88_B8, x88_C8, x88_D8, x88_E8, x88_F8, x88_G8, x88_H8, -}; +extern const char *sq_to_string(const square_t sq); +extern square_t sq_from_string(const char *sq_string); -#endif /* BOARD_H */ +extern void board_print(const piece_t *board); +extern void board_print_mask(const piece_t *board, const bitboard_t mask); +extern void board_print_raw(const piece_t *board, const int type); + +#endif /* _BOARD_H */ diff --git a/src/brchess.c b/src/brchess.c index 2661fdf..9af49e7 100644 --- a/src/brchess.c +++ b/src/brchess.c @@ -18,7 +18,7 @@ #include #include -#include +#include #include #include diff --git a/src/brchess.h b/src/brchess.h index 4309270..e8863d3 100644 --- a/src/brchess.h +++ b/src/brchess.h @@ -1,6 +1,6 @@ -/* bodichess.h - main loop. +/* brchess.h - main loop. * - * Copyright (C) 2021 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. * diff --git a/src/chessdefs.h b/src/chessdefs.h index 44b4ef5..27bcdb5 100644 --- a/src/chessdefs.h +++ b/src/chessdefs.h @@ -1,6 +1,6 @@ -/* chessdefs.h - generic chess definitions. +/* chessdefs.h - generic/catchall chess definitions. * - * Copyright (C) 2021 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. * @@ -11,98 +11,69 @@ * */ -#ifndef CHESSDEFS_H -#define CHESSDEFS_H +#ifndef _CHESSDEFS_H +#define _CHESSDEFS_H -#include "br.h" +#include "brlib.h" /* brlib types */ -/* piece_t bits structure - * MSB 8 7 6 5 4 3 2 1 LSB - * 1: color (0 for white) - * 2-7: bit set for pawn (2), knight, bishop, rook, queen, king (7) +#define ONE 1ull +#define C64(const_u64) const_u64##ULL +#define mask(i) ( (u64) (ONE << (i)) ) + +#define BOARDSIZE (8*8) + +/** + * sq_rel - get relative square + * @sq: white point of view square + * @c: color + * + * Get relative (mirrored if @c is BLACK) square. + * Example: sq_rel(A1, WHITE) = A1, sq_rel(B2, BLACK) = B7 + * + * @return: Relative square. */ -typedef u8 piece_t; +#define sq_rel(sq, c) ((square_t)((sq) ^ (56 * (c)))) -enum { - E_EMPTY = 0, - E_COLOR, /* LSB */ - E_PAWN, - E_KNIGHT, - E_BISHOP, - E_ROOK, - E_QUEEN, - E_KING, -}; - -/* pos_t bitboards tables +/** + * sq_rel_rank - get relative rank + * @rank: white point of view rank + * @c: color + * + * Get relative (mirrored if @c is BLACK) rank. + * Example: sq_rel(RANK_2, WHITE) = RANK_2, sq_rel(RANK_6, BLACK) = RANK_3 + * + * @return: Relative rank. */ -enum { - BB_ALL = 0, /* OR of all bitboards */ - BB_UNUSED, /* future use ? */ - BB_PAWN = E_PAWN, - BB_KNIGHT, - BB_BISHOP, - BB_ROOK, - BB_QUEEN, - BB_KING, - BB_END -}; - -/* piece bitmask in piece_t - */ -enum { - EMPTY = 0, - PAWN = 1 << (E_PAWN - 1), /* 1<<(2-1) = 0x02 00000010 */ - KNIGHT = 1 << (E_KNIGHT - 1), /* 0x04 00000100 */ - BISHOP = 1 << (E_BISHOP - 1), /* 0x08 00001000 */ - ROOK = 1 << (E_ROOK - 1), /* 0x10 00010000 */ - QUEEN = 1 << (E_QUEEN - 1), /* 0x20 00100000 */ - KING = 1 << (E_KING - 1), /* 0x40 01000000 */ -}; - -#define PIECETOBB(p) (ffs64(PIECE(p))) /* from piece_t to bb piece array */ - -#define WHITE 0 /* 0x00 00000000 */ -#define BLACK 1 /* 0x01 00000001 */ -#define OPPONENT(p) !(p) - -#define MASK_COLOR 0x01 /* 00000001 */ -#define MASK_PIECE 0x7E /* 01111110 */ - -#define COLOR(p) ((p) & MASK_COLOR) /* bitmask */ -#define PIECE(p) ((p) & MASK_PIECE) -#define E_PIECE(p) (ffs64(PIECE(p))) /* convert mask to E_XX */ - -#define IS_WHITE(p) (!COLOR(p)) -#define IS_BLACK(p) (COLOR(p)) - -#define SET_WHITE(p) ((p) &= ~MASK_COLOR) -#define SET_BLACK(p) ((p) |= MASK_COLOR) -#define SET_COLOR(p, c) (!(c)? SET_WHITE(p): SET_BLACK(p)) - -/* flip a 0-63 square: - * Vertical: G8 (62) becomes G1 (6) - * Horizontal: G8 (62) becomes B8 (57) - */ -#define FLIP_V(sq) ((sq) ^ 56) -#define FLIP_H(sq) ((sq) ^ 7) -/* square_t bits structure : rrrrffff - * ffff: file - * rrrr: rank - */ -typedef unsigned char square_t; +#define sq_rel_rank(rank, c) ((rank_t)((7 * (c)) ^ rank)) /* castle_t bits structure */ -typedef unsigned char castle_t; +typedef enum { + CASTLE_WK = (1 << 0), /* 0x01 00000001 */ + CASTLE_WQ = (1 << 1), /* 0x02 00000010 */ + CASTLE_BK = (1 << 2), /* 0x04 00000100 */ + CASTLE_BQ = (1 << 3), /* 0x08 00001000 */ -#define CASTLE_WK (1 << 0) /* 0x01 00000001 */ -#define CASTLE_WQ (1 << 1) /* 0x02 00000010 */ -#define CASTLE_BK (1 << 2) /* 0x04 00000100 */ -#define CASTLE_BQ (1 << 3) /* 0x08 00001000 */ + CASTLE_W = (CASTLE_WK | CASTLE_WQ), /* 00000011 W castle mask */ + CASTLE_B = (CASTLE_BK | CASTLE_BQ), /* 00001100 B castle mask */ -#define CASTLE_W (CASTLE_WK | CASTLE_WQ) /* 00000011 W castle mask */ -#define CASTLE_B (CASTLE_BK | CASTLE_BQ) /* 00001100 B castle mask */ + CASTLE_K = (1 << 0), /* generic K/Q, bits 0 and 1 */ + CASTLE_Q = (1 << 1), + CASTLE_KQ = (CASTLE_K |CASTLE_Q) +} castle_rights_t; + +/* determine is oo or ooo is possible with castle flags f and color c + */ +//#define NORM_CASTLE(f, c) ((f) >> (2 * (c))) /* shift flags to bits 0/1 */ +//#define +//(NORM_CASTLE(f, c) & CASTLE_Q) +#define can_oo(f, c) ((f) & (CASTLE_K << ((c) * 2))) +#define can_ooo(f, c) ((f) & (CASTLE_Q << ((c) * 2))) +#define can_castle(f, c) ((f) & (CASTLE_KQ << ((c) * 2))) + +#define clr_oo(f, c) ((f) & ~(CASTLE_K << (2 * (c)))) +#define clr_ooo(f, c) ((f) & ~(CASTLE_Q << (2 * (c)))) +#define clr_castle(f, c) ((f) & ~(CASTLE_KQ << (2 * (c)) )) /* game phases */ @@ -110,20 +81,58 @@ typedef unsigned char castle_t; #define MIDDLEGAME 1 #define ENDGAME 2 -/* bitboard +/* forward defs */ +typedef struct __pos_s pos_t; +typedef struct __movelist_s movelist_t; + +/* basic types */ typedef u64 bitboard_t; - /* eval type */ -typedef s32 eval_t; +//typedef s32 eval_t; -/* forward typedefs +/* forward enum definition is impossible in C11, to simplify + * cross-dependancies, all important enum are moved here. */ -typedef struct piece_list_s piece_list_t; -typedef struct board_s board_t; -typedef struct pos_s pos_t; -typedef struct move_s move_t; +typedef enum { + _SSQUARE_ = -1, /* force signed enum */ + A1 = 0, B1, C1, D1, E1, F1, G1, H1, + A2, B2, C2, D2, E2, F2, G2, H2, + A3, B3, C3, D3, E3, F3, G3, H3, + A4, B4, C4, D4, E4, F4, G4, H4, + A5, B5, C5, D5, E5, F5, G5, H5, + A6, B6, C6, D6, E6, F6, G6, H6, + A7, B7, C7, D7, E7, F7, G7, H7, + A8, B8, C8, D8, E8, F8, G8, H8, + SQUARE_MAX = 64, + SQUARE_NONE = 64 +} square_t; -#endif +typedef enum { + _SFILE_ = -1, /* force signed enum */ + FILE_A = 0, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H, + FILE_MAX, +} file_t; + +typedef enum { + _SRANK_ = -1, /* force signed enum */ + RANK_1 = 0, RANK_2, RANK_3, RANK_4, RANK_5, RANK_6, RANK_7, RANK_8, + RANK_MAX, +} rank_t; + +typedef enum { + NORTH = 8, + EAST = 1, + SOUTH = -NORTH, + WEST = -EAST, + + NORTH_EAST = (NORTH + EAST), + SOUTH_EAST = (SOUTH + EAST), + SOUTH_WEST = (SOUTH + WEST), + NORTH_WEST = (NORTH + WEST), +} dir_t; + + +#endif /* _CHESSDEFS_H */ diff --git a/src/fen.c b/src/fen.c index 86d3206..8b34afa 100644 --- a/src/fen.c +++ b/src/fen.c @@ -1,6 +1,6 @@ -/* fen.c - fen notation. +/* fen.c - fen parsing/generation/test. * - * Copyright (C) 2021 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. * @@ -18,158 +18,337 @@ #include #include +#include #include "chessdefs.h" +#include "util.h" +//#include "piece.h" +//#include "bitboard.h" #include "position.h" -#include "board.h" #include "fen.h" -#include "piece.h" -/* Starting Position : - * rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1 - * After 1.e4 : - * rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1 - * After 1... c5 : - * rnbqkbnr/pp1ppppp/8/2p5/4P3/8/PPPP1PPP/RNBQKBNR w KQkq c6 0 2 - * After 2. Nf3: - * rnbqkbnr/pp1ppppp/8/2p5/4P3/5N2/PPPP1PPP/RNBQKB1R b KQkq - 1 2 - * - * 1 : White uppercase +/* FEN description: + * 1 : pieces on board (no space allowed): + * - rank 8 first, '/' between ranks + * - piece is usual piece notation(PNBRQK), black lowercase. + * - empty: number of consecutive empty squares (digit) * 2 : next move (w or b) * 3 : Castling capabilities: "-" if none, KQ/kq if white/black can castle * on K or Q side - * 4 : en-passant: if pawn just moved 2 squares, indicate target square (e.g. - * for e2-e4 this field is e3) + * 4 : en-passant: "-" if none. If pawn just moved 2 squares, indicate target + * en-passant square (e.g. for e2-e4 this field is e3) * 5 : half moves since last capture or pawn advance (for 50 moves rule) * 6 : full moves, starts at 1, increments after black move * + * Examples: + * + * starting position: + * rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1 + * after 1.e4 e6 2.e5 d5 + * rnbqkbnr/ppp2ppp/4p3/3pP3/8/8/PPPP1PPP/RNBQKBNR w KQkq d6 0 3 + * 3.Nc3 Nc6 4.Rb1 Rb8 5.Nf3 h5 6.Be2 + * 1rbqkbnr/ppp2pp1/2n1p3/3pP2p/8/2N2N2/PPPPBPPP/1RBQK2R b Kk - 1 6 + * 6...Be7 + * 1rbqk1nr/ppp1bpp1/2n1p3/3pP2p/8/2N2N2/PPPPBPPP/1RBQK2R w Kk - 2 7 + * 7.Nxd5 h4 8.g4 + * 1rbqk1nr/ppp1bpp1/2n1p3/3NP3/6Pp/5N2/PPPPBP1P/1RBQK2R b Kk g3 0 8 */ -// warning, we expect a valid fen input -pos_t *fen2pos(pos_t *pos, char *fen) +/* chess startup position FEN */ +const char *startfen="rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"; +static const char *castle_str = "KQkq"; + +#define SKIP_BLANK(p) for(;isspace(*(p)); (p)++) + +/** + * fen_check(pos_t *pos) - test (and try to fix) fen-generated position. + * @pos: position + * + * Test and fix the following: + * - inconsistent castle flags (if K & R are not in correct position) + * - inconsistent en-passant square (turn, bad pawn position) + * + * pos_check() is also called, leading to fatal errors if something is wrong. + * + * @return: 0 if OK, 1 if OK after fix, -1 if fatal issue. + */ +static int fen_check(pos_t *pos) { - char *p = fen; - short rank, file, skip, color, bbpiece; - piece_t piece; - board_t *board = pos->board; -# define SKIP_BLANK(p) for(;*(p) == ' '; (p)++) + char *colstr[2] = { "white", "black"}; + int error = 0, warning = 0; - pos_clear(pos); - /* 1) get piece placement information - */ - for (rank = 7, file = 0; *p && *p != ' '; ++p) { - color = isupper(*p)? WHITE: BLACK; - char cp = toupper(*p); - switch (cp) { - case CHAR_PAWN: - bbpiece = BB_PAWN; - piece = PAWN; - goto set_square; - case CHAR_KNIGHT: - bbpiece = BB_KNIGHT; - piece = KNIGHT; - goto set_square; - case CHAR_BISHOP: - bbpiece = BB_BISHOP; - piece = BISHOP; - goto set_square; - case CHAR_ROOK: - bbpiece = BB_ROOK; - piece = ROOK; - goto set_square; - case CHAR_QUEEN: - bbpiece = BB_QUEEN; - piece = QUEEN; - goto set_square; - case CHAR_KING: - bbpiece = BB_KING; - piece = KING; - //pos->bb[color][BB_KING] = BB(file, rank); - //goto set_square; - set_square: -# ifdef DEBUG_FEN - log_i(5, "f=%d r=%d *p=%c piece=%c color=%d\n", - file, rank, *p, cp, color); -# endif - pos->bb[color][bbpiece] |= BB(file, rank); - pos->occupied[color] |= BB(file, rank); - SET_COLOR(piece, color); - board[SQ88(file, rank)].piece = piece; - board[SQ88(file, rank)].s_piece = - piece_add(pos, piece, SQ88(file, rank)); - file++; - break; - case '/': - rank--; - file = 0; - break; - default: - skip = cp - '0'; - while (skip--) { - board[SQ88(file++, rank)].piece = EMPTY; - } + /* en passant, depends on who plays next */ + if (pos->en_passant != SQUARE_NONE) { + rank_t eprank = sq_rank(pos->en_passant); + file_t epfile = sq_file(pos->en_passant); + rank_t rank5 = sq_rel_rank(RANK_5, pos->turn); + rank_t rank6 = sq_rel_rank(RANK_6, pos->turn); + rank_t rank7 = sq_rel_rank(RANK_7, pos->turn); + piece_t pawn = pos->turn == WHITE? B_PAWN: W_PAWN; + if (warn(eprank != rank6 || + pos->board[sq_make(epfile, rank5)] != pawn || + pos->board[sq_make(epfile, rank6)] != EMPTY || + pos->board[sq_make(epfile, rank7)] != EMPTY, + "fen warn: wrong en-passant settings. (fixed)\n")) { +# ifdef DEBUG_FEN + printf("ep5=%o ep6=%o ep7=%o\n", sq_make(epfile, rank5), + sq_make(epfile, rank6), sq_make(epfile, rank7)); +# endif + warning++; + pos->en_passant = SQUARE_NONE; } } -# ifdef DEBUG_FEN - for (rank = 7; rank >= 0; --rank) { - for (file = 0; file < 8; ++file) { - log(5, "%02x ", board[SQ88(file, rank)].piece); + + for (int color = WHITE; color <= BLACK; ++color) { + rank_t rank1 = color == WHITE? RANK_1: RANK_8; + + /* castling */ + /* where K and R should be for valid castle flag */ + bitboard_t k = bb_sq[sq_make(FILE_E, rank1)]; + bitboard_t r_k = bb_sq[sq_make(FILE_H, rank1)]; + bitboard_t r_q = bb_sq[sq_make(FILE_A, rank1)]; + + /* where they are */ + bitboard_t kings = pos->bb[color][KING]; + bitboard_t rooks = pos->bb[color][ROOK]; + castle_rights_t castle_k = color == WHITE? CASTLE_WK: CASTLE_BK; + castle_rights_t castle_q = color == WHITE? CASTLE_WQ: CASTLE_BQ; + if (pos->castle & castle_k) { + if (warn(!(k & kings && r_k & rooks), + "fen warn: wrong %s short castling K or R position (fixed)\n", + colstr[color])) { + warning++; + pos->castle &= ~castle_k; + } } - log(5, "\n"); - } -# endif - - /* 2) next move color - */ - SKIP_BLANK(p); - SET_COLOR(pos->turn, *p == 'w' ? WHITE : BLACK); - p++; - - /* 3) castle status - */ - SKIP_BLANK(p); - pos->castle = 0; - if (*p != '-') { - for (; *p && *p != ' '; ++p) { - switch (*p) { - case 'K': - pos->castle |= CASTLE_WK; - break; - case 'k': - pos->castle |= CASTLE_BK; - break; - case 'Q': - pos->castle |= CASTLE_WQ; - break; - case 'q': - pos->castle |= CASTLE_BQ; - break; + if (pos->castle & castle_q) { + if (warn(!(k & kings && r_q & rooks), + "fen warn: wrong %s long castling K or R position (fixed)\n", + colstr[color])) { + warning++; + pos->castle &= ~castle_q; } } } - p++; + if (!(error = pos_check(pos, 0))) { + /* TODO: Should it really be here ? */ + pos->checkers = pos_checkers(pos, pos->turn); + pos->pinners = pos_king_pinners(pos, pos->turn); + pos->blockers = pos_king_blockers(pos, pos->turn, pos->pinners); + } + return error ? -1: warning; +} + +/** + * startpos - create a game start position + * @pos: a position pointer or NULL + * + * See @fen2pos function. + * + * @return: the pos position. + */ +pos_t *startpos(pos_t *pos) +{ + return fen2pos(pos, startfen); +} + +/** + * fen2pos - make a position from a fen string + * @pos: a position pointer or NULL + * @fen: a valid fen string + * + * If @pos is NULL, a position will be allocated with @pos_new(), + * that should be freed by caller. + * + * @return: the pos position, or NULL if error. + */ +pos_t *fen2pos(pos_t *pos, const char *fen) +{ + const char *cur = fen; + char *p; + short rank, file, tmp; + piece_t piece; + int consumed, err_line = 0, err_pos, err_char; + pos_t tmppos; + + pos_clear(&tmppos); + /* 1) get piece placement information + */ + for (rank = 7, file = 0; *cur && !isspace(*cur); ++cur) { + if (*cur == '/') { /* next rank */ + rank--; + file = 0; + continue; + } + if (isdigit(*cur)) { /* empty square(s) */ + file += *cur - '0'; + continue; + } + if ((piece = piece_from_fen(*cur)) != EMPTY) { +# ifdef DEBUG_FEN + printf("f=%d r=%d *p=%c piece=%#04x t=%d c=%d\n", file, rank, *cur, + piece, PIECE(piece), COLOR(piece)); +# endif + pos_set_sq(&tmppos, sq_make(file, rank), piece); + file++; + } else { /* error */ + err_line = __LINE__, err_char = *cur, err_pos = cur - fen; + goto end; + } + } + SKIP_BLANK(cur); + + /* 2) next turn color + */ + tmppos.turn = *cur++ == 'w' ? WHITE : BLACK; + SKIP_BLANK(cur); + + /* 3) castle rights + */ + if (*cur == '-') { + cur++; + } else { + for (; *cur && !isspace(*cur); ++cur) { + if ((p = strchr(castle_str, *cur))) { /* valid castle letter */ + tmppos.castle |= 1 << (p - castle_str); + } else { + err_line = __LINE__, err_char = *cur, err_pos = cur - fen; + goto end; + } + } + } + SKIP_BLANK(cur); /* 4) en passant */ - SKIP_BLANK(p); - pos->en_passant = 0; - if (*p != '-') { - //SET_F(pos->en_passant, C2FILE(*p++)); - //SET_R(pos->en_passant, C2RANK(*p++)); - pos->en_passant = SQ88(C2FILE(*p), C2RANK(*(p+1))); - pos += 2; + if (*cur == '-') { + cur++; } else { - p++; + tmppos.en_passant = sq_from_string(cur); + cur += 2; } + SKIP_BLANK(cur); - /* 5) half moves since last capture or pawn move and - * 6) current move number + /* 5) half moves since last capture or pawn move (50 moves rule) */ - SKIP_BLANK(p); - //log_i(5, "pos=%d\n", (int)(p-fen)); - sscanf(p, "%hd %hd", &pos->clock_50, &pos->curmove); + tmppos.clock_50 = 0; + tmppos.plycount = 1; + if (sscanf(cur, "%hd%n", &tmp, &consumed) != 1) + goto end; /* early end, ignore w/o err */ + + tmppos.clock_50 = tmp; + cur += consumed; + SKIP_BLANK(cur); + + /* 6) current full move number, starting with 1 + */ + if (sscanf(cur, "%hd", &tmp) != 1) + goto end; + if (tmp <= 0) /* fix faulty numbers*/ + tmp = 1; + tmp = 2 * (tmp - 1) + (tmppos.turn == BLACK); /* plies, +1 if black turn */ + tmppos.plycount = tmp; + +end: + if (warn(err_line, "FEN error line %d: charpos=%d char=%#x(%c)\n", + err_line, err_pos, err_char, err_char)) { + return NULL; + } + if (fen_check(&tmppos) < 0) + return NULL; + if (!pos) + pos = pos_dup(&tmppos); + //puts("prout 1"); + //pos_print_raw(&tmppos, 1); + //puts("prout 2"); # ifdef DEBUG_FEN - log_i(5, "50 rule=%d current move=%d\n", pos->clock_50, pos->curmove); + pos_print_raw(&tmppos, 1); # endif + return pos; } + +/** + * pos2fen - make a FEN string from a position. + * @pos: a position pointer + * @fen: destination FEN char*, or NULL + * + * If @fen is NULL, a 92 bytes memory will be allocated with malloc(1), + * that should be freed by caller. + * + * Note: If @fen is given, no check is done on its length, but to + * be on secure side, it should be at least 90 bytes. See: + * https://chess.stackexchange.com/questions/30004/longest-possible-fen + * For convenience, use FENSTRLEN. + * + * @return: the pos position, or NULL if error. + */ +char *pos2fen(const pos_t *pos, char *fen) +{ + int cur = 0; + + if (!fen) + fen = safe_malloc(92); + + /* 1) position + */ + for (rank_t r = RANK_8; r >= RANK_1; --r) { + for (file_t f = FILE_A; f <= FILE_H;) { + square_t sq = sq_make(f, r); + piece_t piece = pos->board[sq]; +# ifdef DEBUG_FEN + printf("r=%d f=%d p=%d pos=%d\n", r, f, piece, cur); +# endif + if (piece == EMPTY) { + int len = 0; + for (; f <= FILE_H && pos->board[sq_make(f, r)] == EMPTY; f++) + len++; +# ifdef DEBUG_FEN + printf("empty=%d char=%c\n", len, '0' + len); +# endif + fen[cur++] = '0' + len; + } else { + fen[cur++] = *piece_to_fen(piece); +# ifdef DEBUG_FEN + printf("f1=%d r=%d c=%c t=%d c=%d \n", f, r, + *(piece_to_fen(piece)), PIECE(piece), COLOR(piece)); +# endif + f++; + } + } + fen[cur++] = r == RANK_1? ' ': '/'; + } + + /* 2) next turn color + */ + fen[cur++] = pos->turn == WHITE? 'w': 'b'; + fen[cur++] = ' '; + + /* 3) castle rights + */ + if (pos->castle == 0) { + fen[cur++] = '-'; + } else { + for (int i = 0; i < 4; ++i) + if (pos->castle & mask(i)) + fen[cur++] = castle_str[i]; + } + fen[cur++] = ' '; + + /* 4) en passant + */ + if (pos->en_passant == SQUARE_NONE) { + fen[cur++] = '-'; + } else { + fen[cur++] = FILE2C(sq_file(pos->en_passant)); + fen[cur++] = RANK2C(sq_rank(pos->en_passant)); + } + fen[cur++] = ' '; + + /* 5) moves since last capture or pawn move (50 moves rule) + * 6) current full move number, starting with 1 + */ + sprintf(fen+cur, "%d %d", pos->clock_50, + 1 + (pos->plycount - (pos->turn == BLACK)) / 2); + return fen; +} diff --git a/src/fen.h b/src/fen.h index a57b5a7..6a38b0a 100644 --- a/src/fen.h +++ b/src/fen.h @@ -1,6 +1,6 @@ /* fen.h - fen notation. * - * Copyright (C) 2021 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. * @@ -14,8 +14,14 @@ #ifndef FEN_H #define FEN_H -#include "position.h" +#include "chessdefs.h" -pos_t *fen2pos(pos_t *pos, char *fen); +#define FENSTRLEN 92 /* secure FEN string size */ + +extern const char *startfen; /* startup position */ + +extern pos_t *startpos(pos_t *pos); +extern pos_t *fen2pos(pos_t *pos, const char *fen); +extern char *pos2fen(const pos_t *pos, char *fen); #endif /* FEN_H */ diff --git a/src/hyperbola-quintessence.c b/src/hyperbola-quintessence.c new file mode 100644 index 0000000..2346748 --- /dev/null +++ b/src/hyperbola-quintessence.c @@ -0,0 +1,210 @@ +/* hyperbola-quintessence.c - hyperbola quintessence 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include +#include + +#include "brlib.h" + +#include "chessdefs.h" +#include "board.h" +#include "bitboard.h" +#include "hyperbola-quintessence.h" + + +uchar bb_rank_attacks[64 * 8]; + +/** + * hyperbola_init() - init hyperbola quintessence attack bitboards + * + * See: https://www.chessprogramming.org/Kindergarten_Bitboards + * and https://www.chessprogramming.org/Hyperbola_Quintessence + * + * + * Rank attacks table: + * bb_rank_hyperbola[512 = 9 bits], indexed by oooooofff where: + * - O = oooooo: occupation of inner 6 bits on rank + * - F = fff: file of sliding piece + * The index is built as (oooooo << 3 + fff), = ((O << 3) + F), where: + * - O = all combinations of 6 bits (loop from 0 to 64) + * - F = all files (loop from 0 to 7) + * To retrieve the index, given an 8 bits mask M=XooooooX, and a file F=fff, + * we get O from M with: + * 1) remove bits 'X' (O = M & 01111110) + * 2) shift left result 2 more bits, as bit 0 is unused and already cleared: + * (O <<= 2) + * + * TODO ? create masks excluding slider (eg. bb_diag ^ bb_sq[square]), + * to save one operation in hyperbola_moves(). + * TODO ? replace rank attack with this idea, mapping rank to diagonal ? + * See http://timcooijmans.blogspot.com/2014/04/ + */ +void hyperbola_init() +{ + /* generate rank attacks, not handled by HQ + */ + for (int occ = 0; occ < 64; ++occ) { + for (int file = 0; file < 8; ++file) { + int attacks = 0; + //int o = mask << 1; /* skip right square */ + + /* set f left attacks */ + for (int slide = file - 1; slide >= 0; --slide) { + int b = bb_sq[slide]; /* bit to consider */ + attacks |= b; /* add to attack mask */ + if ((occ << 1) & b) /* piece on b, we stop */ + break; + } + /* set f right attacks */ + for (int slide = file + 1; slide < 8; ++slide) { + int b = bb_sq[slide]; + attacks |= b; + if ((occ << 1) & b) /* piece on b, we stop */ + //if ((o & b) == b) + break; + } + bb_rank_attacks[(occ << 3) + file] = attacks; + + //if (((occ << 3) + file) == 171) { + //char str[64], str2[64]; + //printf("mask=%x=%s file=%d att=%x=%s\n", + // occ, bitboard_rank_sprint(str, occ), file, + // attacks, bitboard_rank_sprint(str2, attacks)); + //} + } + } +} + +/** + * hyperbola_rank_moves() - get rank moves for a sliding piece. + * @pieces: occupation bitboard + * @sq: piece square + * + * Rank attacks are not handled by HQ, so this function uses a pre-calculated + * rank attacks table (@bb_rank_attacks). + * + * @Return: bitboard of @piece available pseudo-moves. + */ +bitboard_t hyperbola_rank_moves(bitboard_t occ, square_t sq) +{ + u32 rank = sq & SQ_RANKMASK; + u32 file = sq & SQ_FILEMASK; + u64 o = (occ >> rank) & 0176; /* 01111110 clear bits 0 & 7 */ + //char zob[128], zob2[128]; + //printf("rank_moves: occ=%lx=%s file=%d o=%lx=%s index=%ld=%ld attack=%lx=%s\n", occ, + // bitboard_rank_sprint(zob, occ), file, o, + // bitboard_rank_sprint(zob, o), (o << 2) + file, (o * 4) + file, + // (bitboard_t)bb_rank_attacks[(o << 2) + file] << rank, + // bitboard_rank_sprint(zob2, (bitboard_t)bb_rank_attacks[(o << 2) + file] << rank)); + return ((bitboard_t)bb_rank_attacks[(o << 2) + file]) << rank; +} + +/** + * hyperbola_moves() - get hyperbola pseudo-moves for a sliding piece + * @pieces: occupation bitboard + * @sq: piece square + * @mask: the appropriate mask (pre-calculated) + * + * This function can be used for files, diagonal, and anti-diagonal attacks. + * @mask is the corresponding pre-calculated table (@bb_sqfile, @bb_sqdiag, + * or @bb_sqanti). + * See https://www.chessprogramming.org/Hyperbola_Quintessence for details. + * + * @Return: bitboard of piece available pseudo-moves. + */ +bitboard_t hyperbola_moves(const bitboard_t pieces, const square_t sq, + const bitboard_t mask) +{ + bitboard_t o = pieces & mask; + bitboard_t r = bswap64(o); + square_t r_sq = FLIP_V(sq); + + return ( (o - 2 * mask(sq) ) + ^ bswap64(r - 2 * mask(r_sq))) + & mask; +} + +/** + * hyperbola_file_moves() - get file pseudo-moves for a sliding piece. + * @pieces: occupation bitboard + * @sq: piece square + * + * @Return: bitboard of piece available pseudo-moves on its file. + */ +bitboard_t hyperbola_file_moves(const bitboard_t occ, const square_t sq) +{ + return hyperbola_moves(occ, sq, bb_sqfile[sq]); +} + +/** + * hyperbola_diag_moves() - get diagonal pseudo-moves for a sliding piece. + * @pieces: occupation bitboard + * @sq: piece square + * + * @Return: bitboard of piece available pseudo-moves on its diagonal. + */ +bitboard_t hyperbola_diag_moves(const bitboard_t occ, const square_t sq) +{ + return hyperbola_moves(occ, sq, bb_sqdiag[sq]); +} + +/** + * hyperbola_anti_moves() - get anti-diagonal pseudo-moves for a sliding piece. + * @pieces: occupation bitboard + * @sq: piece square + * + * @Return: bitboard of piece available pseudo-moves on its anti-diagonal. + */ +bitboard_t hyperbola_anti_moves(const bitboard_t occ, const square_t sq) +{ + return hyperbola_moves(occ, sq, bb_sqanti[sq]); +} + +/** + * hyperbola_bishop_moves() - get bitboard of bishop pseudo-moves + * @occ: occupation bitboard + * @sq: bishop square + * + * @Return: bitboard of bishop available pseudo-moves. + */ +bitboard_t hyperbola_bishop_moves(const bitboard_t occ, const square_t sq) +{ + return hyperbola_diag_moves(occ, sq) | hyperbola_anti_moves(occ, sq); +} + +/** + * hyperbola_rook_moves() - get bitboard of rook pseudo-moves + * @occ: occupation bitboard + * @sq: rook square + * + * @Return: bitboard of rook available pseudo-moves. + */ +bitboard_t hyperbola_rook_moves(const bitboard_t occ, const square_t sq) +{ + return hyperbola_file_moves(occ, sq) | hyperbola_rank_moves(occ, sq); +} + +/** + * hyperbola_queen_moves() - get bitboard of queen pseudo-moves + * @occ: occupation bitboard + * @sq: queen square + * + * This function is a wrapper over @hyperbola_bishop_moves() and + * @hyperbola_rook_moves(). + * + * @Return: bitboard of queen available pseudo-moves. + */ +bitboard_t hyperbola_queen_moves(const bitboard_t occ, const square_t sq) +{ + return hyperbola_bishop_moves(occ, sq) | hyperbola_rook_moves(occ, sq); +} diff --git a/src/hyperbola-quintessence.h b/src/hyperbola-quintessence.h new file mode 100644 index 0000000..c7cc8b7 --- /dev/null +++ b/src/hyperbola-quintessence.h @@ -0,0 +1,33 @@ +/* hyperbola-quintessence.h - hyperbola-quintessence definitions. + * + * 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#ifndef _HYPERBOLA_QUINTESSENCE_H +#define _HYPERBOLA_QUINTESSENCE_H + +#include "board.h" +#include "bitboard.h" + +extern void hyperbola_init(void); + +extern bitboard_t hyperbola_rank_moves(const bitboard_t occ, const square_t sq); +extern bitboard_t hyperbola_moves(const bitboard_t pieces, const square_t sq, + const bitboard_t mask); +extern bitboard_t hyperbola_file_moves(const bitboard_t occ, const square_t sq); +extern bitboard_t hyperbola_diag_moves(const bitboard_t occ, const square_t sq); +extern bitboard_t hyperbola_anti_moves(const bitboard_t occ, const square_t sq); + +extern bitboard_t hyperbola_bishop_moves(const bitboard_t occ, const square_t sq); +extern bitboard_t hyperbola_rook_moves(const bitboard_t occ, const square_t sq); +extern bitboard_t hyperbola_queen_moves(const bitboard_t occ, const square_t sq); + +#endif /* _HYPERBOLA_QUINTESSENCE_H */ diff --git a/src/move-do.c b/src/move-do.c new file mode 100644 index 0000000..e8d7478 --- /dev/null +++ b/src/move-do.c @@ -0,0 +1,172 @@ +/* move-do.c - move do/undo. + * + * 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include +#include +#include + +#include "brlib.h" +#include "likely.h" + +#include "chessdefs.h" +#include "move.h" +#include "position.h" + +/** + * move_do() - do move. + * @pos: &pos_t position + * @move: move to apply + * @state: &state_t address where irreversible changes will be saved + * + * @move is applied to @pos: + * - bitboards and board are updated + * - counters are updated: + * - move count + * - 50-moves rule count + * - flags are possibly updated: + * - castling + * - en-passant + * - captured piece (excl. en-passant) + * + * @return: pos. + */ +pos_t *move_do(pos_t *pos, move_t move, state_t *state) +{ +//# ifdef DEBUG_MOVE_DO +// move_print(move, M_PR_NL | M_PR_LONG); +//# endif + *state = pos->state; /* save irreversible changes */ + + color_t us = pos->turn, them = OPPONENT(us); + square_t from = move_from(move), to = move_to(move); + piece_t piece = pos->board[from]; + piece_t new_piece = piece; + + ++pos->clock_50; + ++pos->plycount; + pos->en_passant = SQUARE_NONE; + pos->turn = them; + + if (is_promotion(move)) + new_piece = MAKE_PIECE(move_promoted(move), us); + + if (is_capture(move)) { + pos->clock_50 = 0; + pos->captured = pos->board[to]; /* save capture info */ + pos_clr_sq(pos, to); /* clear square */ + } else if (is_castle(move)) { /* handle rook move */ + square_t rookfrom, rookto; + if (is_castle_K(move)) { + rookfrom = sq_rel(H1, us); + rookto = sq_rel(F1, us); + } else { + rookfrom = sq_rel(A1, us); + rookto = sq_rel(D1, us); + } + pos_set_sq(pos, rookto, pos->board[rookfrom]); + pos_clr_sq(pos, rookfrom); + pos->castle = clr_castle(pos->castle, us); + } else if (PIECE(piece) == PAWN) { /* pawn non capture or e.p. */ + pos->clock_50 = 0; + if (is_dpush(move)) /* if pawn double push, set e.p. */ + pos->en_passant = pawn_push_up(from, us); + else if (is_enpassant(move)) { /* clear grabbed pawn */ + square_t grabbed = pawn_push_up(to, them); + pos_clr_sq(pos, grabbed); + } + } + + pos_clr_sq(pos, from); /* always clear "from" and set "to" */ + pos_set_sq(pos, to, new_piece); + + /* update castling flags + * As we always consider flags are valid, we : + * - adjust our flags if relative from is "E1", "A1", H1" + * - adjust opp flags if relative to if "A8", H8" + */ + if (can_castle(pos->castle, us)) { /* do we save time with this test ? */ + square_t rel_e1 = sq_rel(E1, us); + square_t rel_a1 = sq_rel(A1, us); square_t rel_h1 = sq_rel(H1, us); + if (from == rel_e1) + pos->castle = clr_castle(pos->castle, us); + else if (from == rel_a1) + pos->castle = clr_ooo(pos->castle, us); + else if (from == rel_h1) + pos->castle = clr_oo(pos->castle, us); + } + if (can_castle(pos->castle, them)) { /* do we save time with this test ? */ + square_t rel_a8 = sq_rel(A8, us); square_t rel_h8 = sq_rel(H8, us); + if (to == rel_a8) + pos->castle = clr_ooo(pos->castle, them); + else if (to == rel_h8) + pos->castle = clr_oo(pos->castle, them); + } + + return pos; +} + +/** + * move_undo() - undo move. + * @pos: &pos_t position + * @move: move to undo + * @state: &state_t address where irreversible changes were saved + * + * @move is applied to @pos: + * - bitboards and board are updated + * - previous information is restored: + * - castling + * - en-passant + * - captured piece (excl. en-passant) + * - move count + * - 50-moves rule count + * + * @return: pos. + */ +pos_t *move_undo(pos_t *pos, const move_t move, const state_t *state) +{ +//# ifdef DEBUG_MOVE + //log(1, "new move: "); + //move_print(0, move, M_PR_NL | M_PR_LONG); +//# endif + color_t them = pos->turn, us = OPPONENT(them); + square_t from = move_from(move), to = move_to(move); + piece_t piece = pos->board[to]; + + pos->state = *state; /* restore irreversible changes */ + + if (is_promotion(move)) + piece = MAKE_PIECE(PAWN, us); + + pos_clr_sq(pos, to); /* always clear "to" and set "from" */ + pos_set_sq(pos, from, piece); + + if (is_capture(move)) { + 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)) { + rookfrom = sq_rel(F1, us); + rookto = sq_rel(H1, us); + } else { + rookfrom = sq_rel(D1, us); + rookto = sq_rel(A1, us); + } + pos_set_sq(pos, rookto, pos->board[rookfrom]); + pos_clr_sq(pos, rookfrom); + } else if (is_enpassant(move)) { /* restore grabbed pawn */ + square_t grabbed = pawn_push_up(to, them); + pos_set_sq(pos, grabbed, MAKE_PIECE(PAWN, them)); + } + + return pos; +} diff --git a/src/move-do.h b/src/move-do.h new file mode 100644 index 0000000..4a6b34a --- /dev/null +++ b/src/move-do.h @@ -0,0 +1,20 @@ +/* move-do.h - move do/undo. + * + * Copyright (C) 2021 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#ifndef MOVE_DO_H +#define MOVE_DO_H + +//extern pos_t *move_do(pos_t *pos, move_t *move); +//extern void move_undo(pos_t *pos, move_t *move); + +#endif /* MOVE_DO_H */ diff --git a/src/move-gen.c b/src/move-gen.c new file mode 100644 index 0000000..9c53b9a --- /dev/null +++ b/src/move-gen.c @@ -0,0 +1,345 @@ +/* move-gen.c - move generation + * + * 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include + +#include "bitops.h" +#include "bug.h" + +#include "chessdefs.h" +#include "board.h" +#include "bitboard.h" +#include "piece.h" +#include "position.h" +#include "move.h" +#include "hyperbola-quintessence.h" +#include "attack.h" +#include "move-gen.h" + + +/** + * pseudo_is_legal() - check if a move is legal. + * @pos: position + * @move: move_t to verify + * + * @return: true if move is valid, false otherwise. + */ +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), king = pos->king[us], sq; + piece_type_t piece = PIECE(pos->board[from]); + bitboard_t kingbb = pos->bb[us][KING], tmp; + + /* (1) - King + * For castling, we already tested intermediate squares attacks + * in pseudo move generation, so we only care destination square here. + * Attention: We need to exclude king from occupation bitboard ! + */ + if (piece == KING) { + bitboard_t occ = pos_occ(pos) ^ kingbb; + return !sq_attackers(pos, occ, to, them); + } + + /* (2) - King is in check + * Double-check is already handled, as only K moves were generated. + * Here, allowed moves are only on King-attacker line, including + * attacker.We can move a piece on + * in pseudo move generation, so we only care destination square here. + */ + if (pos->checkers) { + if (popcount64(pos->checkers) == 1) { /* one checker */ + square_t checker = ctz64(pos->checkers); + bitboard_t between = bb_between[king][checker]; + return mask(to) & between; + } + return false; /* double check */ + } + + /* (3) - pinned pieces + * We verify here that pinned piece P stays on line King-P. + */ + if (mask(from) & pos->blockers & pos->bb[us][ALL_PIECES]) { + bitboard_t line = bb_line[from][king]; + return line & mask(to); /* to is not on pin line */ + } + + /* (4) - En-passant + * We only care the situation where our King and enemy R/Q are on + * 5th relative rank. To do so, we create an occupation bb without + * the 2 pawns. + */ + if (is_enpassant(move)) { + /* from rank bitboard */ + bitboard_t rank5 = bb_sqrank[from]; + /* enemy rooks/queens on from rank */ + bitboard_t rooks = (pos->bb[them][ROOK] | pos->bb[them][QUEEN]) & rank5; + + if ((kingbb & rank5) && rooks) { /* K and enemy R/Q on rank */ + /* captured pawn square (beside from square) */ + square_t captured = sq_make(sq_file(pos->en_passant), sq_rank(from)); + /* occupation bitboard without the two "disappearing" pawns */ + bitboard_t occ = pos_occ(pos) ^ mask(from) ^ mask(captured); + + bit_for_each64(sq, tmp, rooks) /* check all rooks/queens */ + if (hyperbola_rank_moves(occ, sq) & kingbb) + return false; + } + return true; + } + return true; +} + +/** + * pos_next_legal() - get next legal move in position. + * @pos: position + * @start: &int, starting position in move list + * + * Get next valid move in @pos move list, from move @start, or MOVE_NONE. + * @start is set to next non-checked move in pseudo-legal list. + * Position pseudo-legal moves must be already calculated before calling this function. + * + * @return: move, or -1 if no move. + */ +move_t pos_next_legal(const pos_t *pos, int *start) +{ + const int nmoves = pos->moves.nmoves; + const move_t *moves = pos->moves.move; + move_t move; + + while (*start < nmoves) { + if (pseudo_is_legal(pos, (move = moves[(*start)++] ))) + return move; + } + return MOVE_NONE; +} + +/** + * pos_all_legal() - get the list of legal moves from pseudo-legal. + * @pos: position + * @dest: destination &movelist_t + * + * The pseudo-legal moves must be already calculated before calling this function. + * No check is done on @dest limits. + * + * @Return: @dest + */ +movelist_t *pos_all_legal(const pos_t *pos, movelist_t *dest) +{ + int tmp = dest->nmoves = 0; + move_t move; + //int tmp = 0; + + while ((move = pos_next_legal(pos, &tmp)) != MOVE_NONE) + dest->move[dest->nmoves++] = move; + return dest; +} + +/** + * pos_gen_pseudomoves() - generate position pseudo-legal moves + * @pos: position + * + * Generate all @pos pseudo moves for player-to-move. + * The @pos->moves table is filled with the moves. + * + * Only a few validity checks are done here (i.e. moves are not generated): + * - castling, if king is in check + * - castling, if king passes an enemy-controlled square (not final square). + * When immediately known, a few move flags are also applied in these cases: + * - castling: M_CASTLE_{K,Q} + * - pawn capture (excl. en-passant): M_CAPTURE + * - en-passant: M_EN_PASSANT + * - pawn double push: M_DPUSH + * - promotion: M_PROMOTION + * - promotion and capture + * + * TODO: move code to specific functions (especially castling, pawn push/capture) + * + * @Return: The total number of moves. + */ +int pos_gen_pseudomoves(pos_t *pos) +{ + color_t us = pos->turn; + color_t them = OPPONENT(us); + + bitboard_t my_pieces = pos->bb[us][ALL_PIECES]; + bitboard_t not_my_pieces = ~my_pieces; + bitboard_t enemy_pieces = pos->bb[them][ALL_PIECES]; + bitboard_t occ = my_pieces | enemy_pieces; + bitboard_t empty = ~occ; + + bitboard_t movebits, from_pawns; + bitboard_t tmp1, tmp2; + + move_t *moves = pos->moves.move; + int nmoves = pos->moves.nmoves; + int from, to; + + bug_on(nmoves != 0); + + /* king - MUST BE FIRST (we stop if doubler check) */ + from = pos->king[us]; + movebits = bb_king_moves(not_my_pieces, from); + bit_for_each64(to, tmp1, movebits & empty) { + moves[nmoves++] = move_make(from, to); + } + bit_for_each64(to, tmp1, movebits & enemy_pieces) { + moves[nmoves++] = move_make_capture(from, to); + } + + if (popcount64(pos->checkers) > 1) /* double check, we stop here */ + return (pos->moves.nmoves = nmoves); + + /* sliding pieces */ + bit_for_each64(from, tmp1, pos->bb[us][BISHOP] | pos->bb[us][QUEEN]) { + movebits = hyperbola_bishop_moves(occ, from) & not_my_pieces; + bit_for_each64(to, tmp2, movebits & empty) { + moves[nmoves++] = move_make(from, to); + } + bit_for_each64(to, tmp2, movebits & enemy_pieces) { + moves[nmoves++] = move_make_capture(from, to); + } + } + bit_for_each64(from, tmp1, pos->bb[us][ROOK] | pos->bb[us][QUEEN]) { + // printf("rook=%d/%s\n", from, sq_to_string(from)); + movebits = hyperbola_rook_moves(occ, from) & not_my_pieces; + bit_for_each64(to, tmp2, movebits & empty) { + moves[nmoves++] = move_make(from, to); + } + bit_for_each64(to, tmp2, movebits & enemy_pieces) { + moves[nmoves++] = move_make_capture(from, to); + } + } + + /* knight */ + bit_for_each64(from, tmp1, pos->bb[us][KNIGHT]) { + movebits = bb_knight_moves(not_my_pieces, from); + bit_for_each64(to, tmp2, movebits & empty) { + moves[nmoves++] = move_make(from, to); + } + bit_for_each64(to, tmp2, movebits & enemy_pieces) { + moves[nmoves++] = move_make_capture(from, to); + } + } + + /* pawn: relative rank and files */ + bitboard_t rel_rank7 = bb_rel_rank(RANK_7, us); + bitboard_t rel_rank3 = bb_rel_rank(RANK_3, us); + + /* pawn: ranks 2-6 push 1 and 2 squares */ + movebits = pawn_shift_up(pos->bb[us][PAWN] & ~rel_rank7, us) & empty; + bit_for_each64(to, tmp1, movebits) { + from = pawn_push_up(to, them); /* reverse push */ + //printf("push %d->%d %s->%s", from, to, sq_to_string(from), sq_to_string(to)); + moves[nmoves++] = move_make(from, to); + } + /* possible second push */ + movebits = pawn_shift_up(movebits & rel_rank3, us) & empty; + bit_for_each64(to, tmp1, movebits) { + from = pawn_push_up(pawn_push_up(to, them), them); + moves[nmoves++] = move_make_flags(from, to, M_DPUSH); + } + + /* pawn: ranks 2-6 captures left */ + from_pawns = pos->bb[us][PAWN] & ~rel_rank7; // & ~rel_filea; + movebits = pawn_shift_upleft(from_pawns, us) & enemy_pieces; + bit_for_each64(to, tmp1, movebits) { + from = pawn_push_upleft(to, them); /* reverse capture */ + moves[nmoves++] = move_make_capture(from, to); + } + /* pawn: ranks 2-6 captures right */ + from_pawns = pos->bb[us][PAWN] & ~rel_rank7; // & ~rel_fileh; + movebits = pawn_shift_upright(from_pawns, us) & enemy_pieces; + bit_for_each64(to, tmp1, movebits) { + from = pawn_push_upright(to, them); + moves[nmoves++] = move_make_capture(from, to); + } + + /* pawn: en-passant */ + if ((to = pos->en_passant) != SQUARE_NONE) { + movebits = mask(to); + from_pawns = pos->bb[us][PAWN] + & (pawn_shift_upleft(movebits, them) | pawn_shift_upright(movebits, them)); + bit_for_each64(from, tmp1, from_pawns) { + moves[nmoves++] = move_make_enpassant(from, to); + } + } + + /* pawn: rank 7 push */ + movebits = pawn_shift_up(pos->bb[us][PAWN] & rel_rank7, us) & empty; + bit_for_each64(to, tmp1, movebits) { + from = pawn_push_up(to, them); /* reverse push */ + moves[nmoves++] = move_make_promote(from, to, QUEEN); + moves[nmoves++] = move_make_promote(from, to, ROOK); + moves[nmoves++] = move_make_promote(from, to, BISHOP); + moves[nmoves++] = move_make_promote(from, to, KNIGHT); + } + /* pawn promotion: rank 7 captures left */ + from_pawns = pos->bb[us][PAWN] & rel_rank7; // & ~rel_filea; + movebits = pawn_shift_upleft(from_pawns, us) & enemy_pieces; + bit_for_each64(to, tmp1, movebits) { + from = pawn_push_upleft(to, them); /* reverse capture */ + moves[nmoves++] = move_make_promote_capture(from, to, QUEEN); + moves[nmoves++] = move_make_promote_capture(from, to, ROOK); + moves[nmoves++] = move_make_promote_capture(from, to, BISHOP); + moves[nmoves++] = move_make_promote_capture(from, to, KNIGHT); + } + /* pawn: rank 7 captures right */ + from_pawns = pos->bb[us][PAWN] & rel_rank7; // & ~rel_fileh; + movebits = pawn_shift_upright(from_pawns, us) & enemy_pieces; + bit_for_each64(to, tmp1, movebits) { + from = pawn_push_upright(to, them); /* reverse capture */ + moves[nmoves++] = move_make_promote_capture(from, to, QUEEN); + moves[nmoves++] = move_make_promote_capture(from, to, ROOK); + moves[nmoves++] = move_make_promote_capture(from, to, BISHOP); + moves[nmoves++] = move_make_promote_capture(from, to, KNIGHT); + } + + /* castle - Attention ! Castling flags are assumed correct + */ + if (!pos->checkers) { + bitboard_t rel_rank1 = bb_rel_rank(RANK_1, us); + from = pos->king[us]; + square_t from_square[2] = { E1, E8 }; /* verify king is on E1/E8 */ + bug_on(can_castle(pos->castle, us) && from != from_square[us]); + /* For castle, we check the opponent attacks on squares between from and to. + * To square attack check will be done in gen_is_legal. + */ + if (can_oo(pos->castle, us)) { + bitboard_t occmask = rel_rank1 & (FILE_Fbb | FILE_Gbb); + if (!(occ & occmask) && + !sq_attackers(pos, occ, from+1, them)) { /* f1/f8 */ + moves[nmoves++] = move_make_flags(from, from + 2, M_CASTLE_K); + } + } + if (can_ooo(pos->castle, us)) { + bitboard_t occmask = rel_rank1 & (FILE_Bbb | FILE_Cbb | FILE_Dbb); + if (!(occ & occmask) && + !sq_attackers(pos, occ, from-1, them)) { /* d1/d8 */ + moves[nmoves++] = move_make_flags(from, from - 2, M_CASTLE_Q); + } + } + } + /* TODO + * DONE. pawn ranks 2-6 advance (1 push, + 2 squares for rank 2) + * DONE. pawns rank 7 advance + promotions + * DONE. pawns ranks 2-6 captures, left and right + * DONE. pawns en-passant (with capture) + * DONE. pawns rank 7 capture + promotion + * DONE. castle + * + * add function per piece, and type, for easier debug + * + */ + return (pos->moves.nmoves = nmoves); +} diff --git a/src/move-gen.h b/src/move-gen.h new file mode 100644 index 0000000..a249c46 --- /dev/null +++ b/src/move-gen.h @@ -0,0 +1,29 @@ +/* move-gen.h - move generation + * + * 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#ifndef MOVEGEN_H +#define MOVEGEN_H + +#include "bitops.h" + +#include "bitboard.h" +#include "hyperbola-quintessence.h" +#include "piece.h" +#include "move.h" + +bool pseudo_is_legal(const pos_t *pos, const move_t move); +move_t pos_next_legal(const pos_t *pos, int *start); +movelist_t *pos_all_legal(const pos_t *pos, movelist_t *dest); +int pos_gen_pseudomoves(pos_t *pos); + +#endif /* MOVEGEN_H */ diff --git a/src/move.c b/src/move.c index b44ac78..1154e11 100644 --- a/src/move.c +++ b/src/move.c @@ -13,65 +13,86 @@ #include #include - -#include -#include -#include -#include +#include #include "chessdefs.h" -#include "board.h" -#include "bitboard.h" -#include "piece.h" #include "move.h" -#include "eval.h" -#include "eval-simple.h" - -static pool_t *moves_pool; - -static struct vector { - unsigned char ndirs; - char slide; - char dir[8]; -} vectors[] = { - [KNIGHT] = { 8, 0, { -33, -31, -18, -14, 14, 18, 31, 33 }}, - [BISHOP] = { 4, 1, { -15, -17, 15, 17 }}, - [ROOK] = { 4, 1, { -1, -16, 1, 16 }}, - [QUEEN] = { 8, 1, { -1, -16, 1, 16, -15, -17, 15, 17 }}, - [KING] = { 8, 0, { -1, -16, 1, 16, -15, -17, 15, 17 }} -}; +#include "position.h" -/* squares needed to be empty & not controlled by opponent for castle. - * For black castle, same values 7 rows higher (>> 7*8) +/* + * /\** + * * move_print() - print a move + * * @movenum: move number + * * @move: &move to display + * * @flags: options to display + * * + * * Possible flags are: + * * M_PR_CAPT: print move if capture + * * M_PR_NCAPT: print move if non capture + * * M_PR_NUM: print also move number + * * M_PR_LONG: print long notation + * * M_PR_NL: print a newline after move + * * M_PR_EVAL: print move eval + * * + * * @return: 0 if nothing printed, 1 otherwise + * *\/ + * int move_print(int movenum, move_t *move, move_flags_t flags) + * { + * if ((flags & M_PR_CAPT) && !(move->flags & M_CAPTURE)) { + * # ifdef DEBUG_MOVE + * log_i(9, "skipping capture & %#04x\n", move->flags); + * # endif + * return 0; + * } + * if ((flags & M_PR_NCAPT) && (move->flags & M_CAPTURE)) { + * # ifdef DEBUG_MOVE + * log_i(9, "skipping !capture & %#04x\n", move->flags); + * # endif + * return 0; + * } + * if (flags & M_PR_NUM) + * log(1, "%d:", movenum); + * if (move->flags & M_CASTLE_K) { + * log(1, "O-O"); + * goto end; + * } else if (move->flags & M_CASTLE_Q) { + * log(1, "O-O-O"); + * goto end; + * } else { + * log(1, "%s%c%c", P_SYM(move->piece), + * FILE2C(F88(move->from)), + * RANK2C(R88(move->from))); + * if (move->flags & M_CAPTURE) { + * log(1, "x"); + * if (flags & M_PR_LONG) + * log(1, "%s", P_SYM(move->capture)); + * } else { + * log(1, "-"); + * } + * log(1, "%c%c", + * FILE2C(F88(move->to)), + * RANK2C(R88(move->to))); + * if (flags & M_PR_LONG && move->flags & M_EN_PASSANT) + * log(1, "e.p."); + * if (move->promotion) + * log(1, "=%s", P_SYM(move->promotion)); + * if (flags & M_PR_EVAL) + * log(1, "[ev:%d] ", move->eval); + * end: + * log(1, " "); + * } + * if (flags & M_PR_NL) + * log(1, "\n"); + * return 1; + * } */ -static struct can_castle { - bitboard_t controlled[2]; - bitboard_t occupied[2]; -} castle_squares[2] = { - /* Queen side King side Queen side King side */ - { { C1|D1|E1, E1|F1|G1, }, { B1|C1|D1, F1|G1 } }, - { { C8|D8|E8, E8|F8|G8, }, { B8|C8|D8, F8|G8 } } -}; - -pool_t *moves_pool_init() -{ - if (!moves_pool) - moves_pool = pool_create("moves", 128, sizeof(move_t)); - return moves_pool; -} - -void moves_pool_stats() -{ - if (moves_pool) - pool_stats(moves_pool); -} /** - * move_print() - print a move - * @movenum: move number - * @move: &move to display - * @flags: options to display + * move_str() - get a move string + * @dst: destination memory + * @move: move + * @flags: moves selection and display options. * * Possible flags are: * M_PR_CAPT: print move if capture @@ -80,805 +101,72 @@ void moves_pool_stats() * M_PR_LONG: print long notation * M_PR_NL: print a newline after move * M_PR_EVAL: print move eval - * - * @return: 0 if nothing printed, 1 otherwise */ -int move_print(int movenum, move_t *move, move_flags_t flags) +char *move_str(char *dst, const move_t move, __unused const int flags) { - if ((flags & M_PR_CAPT) && !(move->flags & M_CAPTURE)) { -# ifdef DEBUG_MOVE - log_i(9, "skipping capture & %#04x\n", move->flags); -# endif - return 0; + square_t from = move_from(move); + square_t to = move_to(move); + int len; + sprintf(dst, "%s%s%n", sq_to_string(from), sq_to_string(to), &len); + + if (is_promotion(move)) { + piece_t promoted = (piece_t) move_promoted(move); + sprintf(dst + len, "%s", piece_to_low(promoted)); } - if ((flags & M_PR_NCAPT) && (move->flags & M_CAPTURE)) { -# ifdef DEBUG_MOVE - log_i(9, "skipping !capture & %#04x\n", move->flags); -# endif - return 0; - } - if (flags & M_PR_NUM) - log(1, "%d:", movenum); - if (move->flags & M_CASTLE_K) { - log(1, "O-O"); - goto end; - } else if (move->flags & M_CASTLE_Q) { - log(1, "O-O-O"); - goto end; - } else { - log(1, "%s%c%c", P_SYM(move->piece), - FILE2C(F88(move->from)), - RANK2C(R88(move->from))); - if (move->flags & M_CAPTURE) { - log(1, "x"); - if (flags & M_PR_LONG) - log(1, "%s", P_SYM(move->capture)); - } else { - log(1, "-"); - } - log(1, "%c%c", - FILE2C(F88(move->to)), - RANK2C(R88(move->to))); - if (flags & M_PR_LONG && move->flags & M_EN_PASSANT) - log(1, "e.p."); - if (move->promotion) - log(1, "=%s", P_SYM(move->promotion)); - if (flags & M_PR_EVAL) - log(1, "[ev:%d] ", move->eval); - end: - log(1, " "); - } - if (flags & M_PR_NL) - log(1, "\n"); - return 1; + return dst; } -void moves_print(pos_t *pos, move_flags_t flags) -{ - struct list_head *p_cur, *tmp; - move_t *move; - int movenum; - for (int color=WHITE; color <= BLACK; ++color) { - int verif = 0; - log(1, "%s pseudo-moves:\n\t", color == WHITE? "White": "Black"); - if (! (flags & M_PR_SEPARATE)) { - movenum = 1; - list_for_each_safe(p_cur, tmp, &pos->moves[color]) { - move = list_entry(p_cur, move_t, list); - verif += move_print(movenum++, move, flags); - } - } else { - log(1, "captures: "); - movenum = 1; - list_for_each_safe(p_cur, tmp, &pos->moves[color]) { - move = list_entry(p_cur, move_t, list); - verif += move_print(movenum++, move, flags | M_PR_CAPT); - } - movenum = 1; - log(1, "\n\tothers : "); - list_for_each_safe(p_cur, tmp, &pos->moves[color]) { - move = list_entry(p_cur, move_t, list); - verif += move_print(movenum++, move, flags | M_PR_NCAPT); - } - } - log(1, "\n\tTotal moves = %d mobility=%u\n", verif, pos->mobility[color]); - } +/** + * moves_print() - print movelist moves. + * @moves: &movelist_t moves list + * @flags: moves selection and display options. + * + * Possible flags are: + * M_PR_CAPT: print move if capture + * M_PR_NCAPT: print move if non capture + * M_PR_NUM: print also move number + * M_PR_LONG: print long notation + * M_PR_NL: print a newline after each move + * M_PR_EVAL: print move eval + */ +void moves_print(movelist_t *moves, __unused int flags) +{ + char str[16]; + //printf("%2d:", moves->nmoves); + for (int m = 0; m < moves->nmoves; ++m) + printf("%s ", move_str(str, moves->move[m], flags)); + printf("\n"); } -static move_t *move_add(pos_t *pos, piece_t piece, square_t from, - square_t to) +static int _moves_cmp_bysquare(const void *p1, const void *p2) { - board_t *board = pos->board; - move_t *move; - int color = COLOR(pos->board[from].piece); - -# ifdef DEBUG_MOVE - log_i(3, "piece_color=%d turn=%d from=%c%c to=%c%c\n", - color, pos->turn, - FILE2C(F88(from)), - RANK2C(R88(from)), - FILE2C(F88(to)), - RANK2C(R88(to))); -# endif - /* invalid position if opponent king is attacked - */ - if (board[to].piece & KING) { -# ifdef DEBUG_MOVE - log_i(2, "invalid position: opponent king [%c%c] is in check.\n", - FILE2C(F88(to)), RANK2C(R88(to))); -# endif - return NULL; - } - if (!(move = pool_get(moves_pool))) - return NULL; - list_add(&move->list, &pos->moves[color]); - - move->piece = piece | color; - move->from = from; - move->to = to; - move->capture = board[to].piece; - if (PIECE(move->capture) == KING) - pos->check[color]++; - - move->flags = M_NORMAL; - if (move->capture) - move->flags |= M_CAPTURE; - move->pos = NULL; -# ifdef DEBUG_MOVE - log_i(3, "added %s %s move from %c%c to %c%c\n", - COLOR(move->piece)? "black": "white", - P_NAME(PIECE(move->piece)), - FILE2C(F88(move->from)), RANK2C(R88(move->from)), - FILE2C(F88(move->to)), RANK2C(R88(move->to))); -# endif - return move; + move_t m1 = *(move_t *)p1; + move_t m2 = *(move_t *)p2; + square_t f1 = move_from(m1); + square_t t1 = move_to(m1); + square_t f2 = move_from(m2); + square_t t2 = move_to(m2); + piece_type_t prom1 = move_promoted(m1); + piece_type_t prom2 = move_promoted(m2); + if (f1 < f2) return -1; + if (f1 > f2) return 1; + /* f1 == f2 */ + if (t1 < t2) return -1; + if (t1 > t2) return 1; + /* t1 == t2 */ + if (prom1 < prom2) return -1; + if (prom1 > prom2) return 1; + return 0; } /** - * move_del() - delete a move from list. - * @ptr: move &list_head + * move_sort_by_sq() - sort moves list by from/to squares ascending + * @moves: &movelist_t * - * Remove the move whose 'list' element address is @ptr. + * Used for perft, for easier comparison. */ -void move_del(struct list_head *ptr) +void move_sort_by_sq(movelist_t *moves) { - move_t *move = list_entry(ptr, move_t, list); - -# ifdef DEBUG_MOVE - log_i(3, "delete move from %c%c to %c%c\n", - FILE2C(F88(move->from)), RANK2C(R88(move->from)), - FILE2C(F88(move->to)), RANK2C(R88(move->to))); -# endif - - if (move->pos) - pos_del(move->pos); - list_del(ptr); - pool_add(moves_pool, move); - return; -} - -/** - * move_del() - delete all position moves. - * @ppos: &position. - * - * Remove all generated moves from @pos structure. - */ -int moves_del(pos_t *pos) -{ - struct list_head *p_cur, *tmp, *head; - int count = 0; - - for (int color = WHITE; color <= BLACK; ++color) { - head = &pos->moves[color]; - - list_for_each_safe(p_cur, tmp, head) { - move_del(p_cur); - count++; - } - } -# ifdef DEBUG_PIECE - log_f(3, "%d moves removed\n", count); -# endif - return count; -} - -/* TODO: return nmoves */ -static move_t *move_pawn_add(pos_t *pos, piece_t piece, square_t from, - square_t to, unsigned char rank7) -{ - move_t *move; - piece_t promote; - unsigned char color = COLOR(piece); - - if (R88(from) == rank7) { /* promotion */ - for (promote = QUEEN; promote > PAWN; promote >>= 1) { - if ((move = move_add(pos, piece, from, to))) { - move->flags |= M_PROMOTION; - move->promotion = promote | color; - } - } - } else { - move = move_add(pos, piece, from, to); - } - return move; -} - -/** - * pseudo_moves_pawn() - generate moves for pawn. - * @pos: &position - * @ppiece: &piece_list pawn structure pointer - * @doit: add move to moves list - * - * Calculate all possible moves for @ppiece pawn. - * If @doit is true, add moves to @pos' moves list. - */ -int pseudo_moves_pawn(pos_t *pos, piece_list_t *ppiece, bool doit) -{ - piece_t piece = PIECE(ppiece->piece); - unsigned char color = COLOR(ppiece->piece); - square_t square = ppiece->square, new; - board_t *board = pos->board; - unsigned char rank2, rank7, rank5; - move_t *move = NULL; - char dir; - int count = 0; - - /* setup direction */ - if (IS_WHITE(color)) { - dir = 1; - rank2 = 1; - rank7 = 6; - rank5 = 4; - } else { - dir = -1; - rank2 = 6; - rank7 = 1; - rank5 = 3; - } - -# ifdef DEBUG_MOVE - log_f(2, "pos:%p turn:%s piece:%d [%s %s] dir:%d at %#04x[%c%c]\n", - pos, - IS_WHITE(pos->turn)? "white": "black", - piece, - IS_WHITE(color)? "white": "black", - P_NAME(piece), - dir, - square, - FILE2C(F88(square)), RANK2C(R88(square))); -# endif - - /* normal push. We do not test for valid destination square here, - * assuming position is valid. Is that correct ? - */ - new = square + dir * 16; - if (!board[new].piece) { -# ifdef DEBUG_MOVE - log_i(4, "pushing pawn %#04x\n", square); -# endif - pos->mobility[color]++; - count++; - if (doit) - move_pawn_add(pos, piece | color, square, new, rank7); - /* push 2 squares */ - log(4, "R88(%#x)=%d R2=%d \n", square, R88(square), rank2); - if (R88(square) == rank2) { - new += dir * 16; - if (SQ88_OK(new) && !board[new].piece) { -# ifdef DEBUG_MOVE - log_i(4, "pushing pawn %#04x 2 squares\n", square); -# endif - //log_f(2, "pawn move2 mobility\n"); - pos->mobility[color]++; - count++; - if (doit) - move_pawn_add(pos, piece | color, square, new, rank7); - } - } - } - - /* en passant - not accounted for mobility. Correct ? */ - if (pos->en_passant && R88(square) == rank5) { - unsigned char ep_file = F88(pos->en_passant); - unsigned char sq_file = F88(square); - -# ifdef DEBUG_MOVE - log_i(4, "possible en passant on rank %#x (current = %#0x)\n", ep_file, - sq_file); -# endif - if (sq_file == ep_file - 1 || sq_file == ep_file + 1) { - square_t t_square = SQ88(ep_file, rank5); /* taken pawn square */ - piece_t captured = board[t_square].piece; - move = move_pawn_add(pos, piece | color , square, pos->en_passant, rank7); - move->flags |= M_EN_PASSANT | M_CAPTURE; - move->capture = captured; - pos->mobility[color]++; - count++; - } - - } - - /* capture */ - int two=0; - for (new = square + dir * 15; two < 2; new = square + dir * 17, two++) { -# ifdef DEBUG_MOVE - log_i(4, "pawn capture %#04x %#04x\n", square, new); -# endif - if (SQ88_NOK(new)) - continue; - pos->controlled[color] |= SQ88_2_BB(new); - if (board[new].piece && COLOR(board[new].piece) != color) { - if (PIECE(board[new].piece) == KING) - pos->check[color]++; - //log_f(2, "pawn capture mobility\n"); - pos->mobility[color]++; - count++; - if (doit) - move_pawn_add(pos, piece | color, square, new, rank7); - } - } -# ifdef DEBUG_MOVE - log_f(2, "pos:%p turn:%s piece:%d [%s %s] dir:%d at %#04x[%c%c] count=%d\n", - pos, - IS_WHITE(pos->turn)? "white": "black", - piece, - IS_WHITE(color)? "white": "black", - P_NAME(piece), - dir, - square, - FILE2C(F88(square)), RANK2C(R88(square)), count); -# endif - return count; -} - -/** - * pseudo_moves_castle() - generate castle moves. - * @pos: &position - * @color: side for which to generate moves - * @doit: add move to moves list - * @do_king: count king moves in mobility - * - * Calculate the possible castle moves for @color side. - * If @doit is true, add moves to @pos' moves list. - * If @do_king is true, account king moves (incl. castle) to mobility. - * - * @return: The number of possible king moves. - */ -int pseudo_moves_castle(pos_t *pos, bool color, bool doit, bool do_king) -{ - board_t *board = pos->board; - unsigned char rank1, castle_K, castle_Q; - move_t *move = NULL; - unsigned short count=0; - struct can_castle *can_castle; - bitboard_t controlled; - bitboard_t occupied = pos->occupied[WHITE] | pos->occupied[BLACK]; - //pos_t *newpos; - -# ifdef DEBUG_MOVE - log_f(2, "pos:%p turn:%s color:%s\n", - pos, - IS_WHITE(pos->turn)? "white": "black", - IS_WHITE(color)? "white": "black"); -# endif - - if (IS_WHITE(color)) { - rank1 = 0; - castle_K = pos->castle & CASTLE_WK; - castle_Q = pos->castle & CASTLE_WQ; - can_castle = castle_squares+WHITE; - controlled = pos->controlled[BLACK]; - } else { - rank1 = 7; - castle_K = pos->castle & CASTLE_BK; - castle_Q = pos->castle & CASTLE_BQ; - can_castle = castle_squares+BLACK; - controlled = pos->controlled[WHITE]; - } - if (castle_K) { - if (occupied & can_castle->occupied[1]) { -# ifdef DEBUG_MOVE - log(5, "Cannot castle K side: occupied\n"); -# endif - goto next; - } - if (controlled & can_castle->controlled[1]) { -# ifdef DEBUG_MOVE - log(5, "Cannot castle K side: controlled\n"); -# endif - goto next; - } - if (do_king) { - pos->mobility[color]++; - count++; - } - if (doit) { - move = move_add(pos, board[SQ88(4, rank1)].piece, - SQ88(4, rank1), SQ88(6, rank1)); - if (move) - move->flags |= M_CASTLE_K; - } - } - -next: - if (castle_Q) { - if (occupied & can_castle->occupied[0]) { -# ifdef DEBUG_MOVE - log(5, "Cannot castle Q side: occupied\n"); -# endif - goto end; - } - if (controlled & can_castle->controlled[0]) { -# ifdef DEBUG_MOVE - log(5, "Cannot castle Q side: controlled\n"); -# endif - goto end; - } - if (do_king) { - pos->mobility[color]++; - count++; - } - if (doit) { - move = move_add(pos, board[SQ88(4, rank1)].piece, - SQ88(4, rank1), SQ88(2, rank1)); - if (move) - move->flags |= M_CASTLE_Q; - } - } -end: - return count; -} - -/** - * pseudo_moves_gen() - general move generation for non pawn pieces - * @pos: &position - * @ppiece: &piece_list structure pointer - * @doit: add move to moves list - * @do_king: count king moves - * - * Calculate all possible moves for @ppiece. - * If @doit is true, add moves to @pos' moves list. - * If @do_king is true, account king moves (incl. castle) to mobility. - */ -int pseudo_moves_gen(pos_t *pos, piece_list_t *ppiece, bool doit, bool do_king) -{ - piece_t piece = PIECE(ppiece->piece); - unsigned char color = COLOR(ppiece->piece); - struct vector *vector = vectors+piece; - square_t square = ppiece->square; - unsigned char ndirs = vector->ndirs; - char slide = vector->slide; - board_t *board = pos->board; - //move_t *move; - int count = 0; - u64 bb_new; - -# ifdef DEBUG_MOVE - log_f(2, "pos:%p turn:%s piece:%d [%s %s] at %#04x[%c%c]\n", - pos, - IS_WHITE(pos->turn)? "white": "black", - piece, - IS_WHITE(color)? "white": "black", - P_NAME(piece), - square, - FILE2C(F88(square)), RANK2C(R88(square))); - log_i(5, "vector=%ld ndirs=%d slide=%d\n", vector-vectors, ndirs, slide); -# endif - - for (int curdir = 0; curdir < ndirs; ++curdir) { - char dir = vector->dir[curdir]; - for (square_t new = square + dir; ; new = new + dir) { - /* outside board */ - if (SQ88_NOK(new)) { -# ifdef DEBUG_MOVE - log_i(4,"skipping %04x (invalid square)\n", new); -# endif - break; - } - bb_new = SQ88_2_BB(new); -# ifdef DEBUG_MOVE - log_i(2, "trying %#x=%c%c bb=%#lx\n", - new, FILE2C(F88(new)), RANK2C(R88(new)), - bb_new); - //bitboard_print(new_bitboard); -# endif - - pos->controlled[color] |= bb_new;; - - /* king: do not move to opponent controlled square */ - if (piece == KING && pos->controlled[OPPONENT(color)] & bb_new) { -# ifdef DEBUG_MOVE - log_i(2, "%s king cannot move to %c%c\n", - IS_WHITE(color)? "white": "black", - FILE2C(F88(new)), RANK2C(R88(new))); -# endif - break; - } - - if (bb_new & pos->occupied[color]) { - //bitboard_print(pos->occupied[color]); - //bitboard_print(pos->occupied[OPPONENT(color)]); -# ifdef DEBUG_MOVE - log_i(2, "BB: skipping %#lx [%c%c] (same color piece)\n", - bb_new, FILE2C(F88(new)), RANK2C(R88(new))); -# endif - break; - } - - /* we are sure the move is valid : we create move */ - if (piece != KING || do_king) { - pos->mobility[color]++; - count++; - } - if (doit) - move_add(pos, ppiece->piece, square, new); - if (board[new].piece) { /* stopper move */ - break; - } - if (!slide) - break; - } - } -# ifdef DEBUG_MOVE - log_f(2, "pos:%p turn:%s piece:%d [%s %s] at %#04x[%c%c] count=%d\n", - pos, - IS_WHITE(pos->turn)? "white": "black", - piece, - IS_WHITE(color)? "white": "black", - P_NAME(piece), - square, - FILE2C(F88(square)), RANK2C(R88(square)), count); -# endif - return count; -} - -/** - * moves_gen() - move generation for one color - * @pos: &position - * @color: side - * @doit: add move to moves list - * @do_king: count king moves - * - * Calculate all possible moves for @color. - * If @doit is true, add moves to @pos' moves list. - * If @do_king is true, account king moves (incl. castle) to mobility. - */ -int moves_gen(pos_t *pos, bool color, bool doit, bool do_king) -{ - struct list_head *p_cur, *tmp, *piece_list; - piece_list_t *piece; - int count = 0; - -# ifdef DEBUG_MOVE - log_f(2, "color:%s doit:%d\n", color? "Black": "White", doit); -# endif - - /* do not generate moves if already done for color */ - if (!list_empty(&pos->moves[color])) - doit = false; - - piece_list = &pos->pieces[color]; - pos->mobility[color] = 0; - pos->controlled[color] = 0; - count += pseudo_moves_castle(pos, color, doit, do_king); - list_for_each_safe(p_cur, tmp, piece_list) { - piece = list_entry(p_cur, piece_list_t, list); - if (PIECE(piece->piece) != PAWN) - count += pseudo_moves_gen(pos, piece, doit, do_king); - else - count += pseudo_moves_pawn(pos, piece, doit); - - count++; - } - return count; -} - -/** - * moves_gen_king_moves() - adjust king mobility - * @pos: &position - * @color: king color - * @doit: add move to moves list - * - * Compute the number of king moves (incl. castle), after opponent controlled - * are known. - * If @doit is true, add moves to @pos' moves list. - * - * @return: The number of possible king moves. - */ -int moves_gen_king_moves(pos_t *pos, bool color, bool doit) -{ - int count = 0; - piece_list_t *king = list_first_entry(&pos->pieces[color], piece_list_t, list); - count = pseudo_moves_castle(pos, king, doit, true); - count += pseudo_moves_gen(pos, king, doit, true); - return count; -} - -static int moves_cmp_eval(__unused void *data, const struct list_head *h1, const struct list_head *h2) -{ - move_t *m1 = list_entry(h1, move_t, list); - move_t *m2 = list_entry(h2, move_t, list); - return m2->eval_simple - m1->eval_simple; -} - -/** - * moves_sort() sort - sort moves list, best eval first. - * @pos: &position. - */ -void moves_sort(pos_t *pos) -{ - list_sort(NULL, &pos->moves[pos->turn], moves_cmp_eval); -} - -/** - * moves_gen_all_eval_sort() - calculate/generate/sort moves for side to play. - * @pos: &position - * - * Generate positions for each move for player to move. - * For each of them generate opponents moves, calculate eval, and sort the moves list. - */ -void moves_gen_eval_sort(pos_t *pos) -{ - move_t *move; - pos_t *newpos; - - moves_gen_all(pos); - - list_for_each_entry(move, &pos->moves[pos->turn], list) { - newpos = move_do(pos, move); - move->pos = newpos; - //move_print(0, move, 0); - move->eval_simple = eval_simple(newpos); - newpos->eval_simple = move->eval_simple; - } - moves_sort(pos); - //moves_print(pos, 0); -} - -/** - * moves_gen_all() - calculate all moves, and generate moves for side to play. - * @pos: &position - * - * Compute pseudo moves for both sides, and generate moves for player to move. - */ -void moves_gen_all(pos_t *pos) -{ - //log_f(1, "turn=%d opponent=%d\n", pos->turn, OPPONENT(pos->turn)); - if (!pos->moves_generated) { - if (!pos->moves_counted) {} - moves_gen(pos, OPPONENT(pos->turn), false, false); - moves_gen(pos, pos->turn, true, true); - if (!pos->moves_counted) - moves_gen_king_moves(pos, OPPONENT(pos->turn), false); - pos->moves_counted = true; - pos->moves_generated = true; - } -} - -/** - * moves_gen_all_nomoves() - calculate number of moves for each player. - * @pos: &position - */ -void moves_gen_all_nomoves(pos_t *pos) -{ - //log_f(1, "turn=%d opponent=%d\n", pos->turn, OPPONENT(pos->turn)); - if (!pos->moves_counted) { - moves_gen(pos, OPPONENT(pos->turn), false, false); - moves_gen(pos, pos->turn, false, true); - moves_gen_king_moves(pos, OPPONENT(pos->turn), false); - pos->moves_counted = true; - } -} - -/** - * move_do() - execute move in a duplicated position. - * @pos: &pos_t struct on which move will be applied - * @move: &move_t struct to apply - * - * @return: &new position - */ -pos_t *move_do(pos_t *pos, move_t *move) -{ -# ifdef DEBUG_MOVE - //log(1, "new move: "); - //move_print(0, move, M_PR_NL | M_PR_LONG); -# endif - - pos_t *new = pos_dup(pos); - piece_t piece = PIECE(move->piece), newpiece = piece, captured = move->capture; - int color = COLOR(move->piece); - square_t from = move->from, to = move->to; - u64 bb_from = SQ88_2_BB(from), bb_to = SQ88_2_BB(to); - - if (move->capture || piece == PAWN) /* 50 moves */ - new->clock_50 = 0; - else - new->clock_50++; - - if (move->flags & M_CAPTURE) { /* capture */ - if (move->flags & M_EN_PASSANT) { - uchar ep_file = F88(pos->en_passant); - square_t ep_grab = color == WHITE ? SQ88(ep_file, 4): SQ88(ep_file, 3); - u64 bb_ep_grab = SQ88_2_BB(ep_grab); - - log_f(5, "en-passant=%d,%d\n", ep_file, color == WHITE ? 4 : 3); - piece_del(&new->board[ep_grab].s_piece->list); - new->board[ep_grab].piece = 0; - new->occupied[OPPONENT(color)] &= ~bb_ep_grab; - new->bb[OPPONENT(color)][BB_PAWN] &= ~bb_ep_grab; - - } else { - piece_del(&new->board[to].s_piece->list); - new->board[to].piece = 0; - new->occupied[OPPONENT(color)] &= ~bb_to; - new->bb[OPPONENT(color)][PIECETOBB(captured)] &= ~bb_to; - } - - } else if (move->flags & M_CASTLE_Q) { - uchar row = R88(from); - square_t rook_from = SQ88(0, row); - square_t rook_to = SQ88(3, row); - u64 bb_rook_from = SQ88_2_BB(rook_from); - u64 bb_rook_to = SQ88_2_BB(rook_to); - - new->board[rook_to] = new->board[rook_from]; - new->board[rook_to].s_piece->square = rook_to; - new->occupied[color] &= ~bb_rook_from; - new->occupied[color] |= bb_rook_to; - new->bb[color][PIECETOBB(BB_ROOK)] &= ~bb_rook_from; - new->bb[color][PIECETOBB(BB_ROOK)] |= bb_rook_to; - new->board[rook_from].piece = 0; - new->board[rook_from].s_piece = NULL; - //new->castle &= color == WHITE? ~CASTLE_W: ~CASTLE_B; - - } else if (move->flags & M_CASTLE_K) { - uchar row = R88(from); - square_t rook_from = SQ88(7, row); - square_t rook_to = SQ88(5, row); - u64 bb_rook_from = SQ88_2_BB(rook_from); - u64 bb_rook_to = SQ88_2_BB(rook_to); - - new->board[rook_to] = new->board[rook_from]; - new->board[rook_to].s_piece->square = rook_to; - new->occupied[color] &= ~bb_rook_from; - new->occupied[color] |= bb_rook_to; - new->bb[color][PIECETOBB(BB_ROOK)] &= ~bb_rook_from; - new->bb[color][PIECETOBB(BB_ROOK)] |= bb_rook_to; - new->board[rook_from].piece = 0; - new->board[rook_from].s_piece = NULL; - // new->castle &= color == WHITE? ~CASTLE_W: ~CASTLE_B; - } - - new->board[to] = new->board[from]; - /* fix dest square */ - new->board[to].s_piece->square = to; - if (move->flags & M_PROMOTION) { - log_f(5, "promotion to %s\n", P_SYM(move->promotion)); - log_f(5, "newpiece=%#x p=%#x\n", move->promotion, PIECE(move->promotion)); - newpiece = PIECE(move->promotion); - new->board[to].piece = move->promotion; - new->board[to].s_piece->piece = move->promotion; - } - /* replace old occupied bitboard by new one */ - new->occupied[color] &= ~bb_from; - new->occupied[color] |= bb_to; - new->bb[color][PIECETOBB(piece)] &= ~bb_from; - new->bb[color][PIECETOBB(newpiece)] |= bb_to; - if (move->flags & M_PROMOTION) { - log_f(5, "promotion color=%d bbpiece=%d\n", color, PIECETOBB(newpiece)); - //bitboard_print(new->bb[color][PIECETOBB(newpiece)]); - } - /* set en_passant */ - new->en_passant = 0; - if (piece == PAWN) { - if (R88(from) == 1 && R88(to) == 3) - pos->en_passant = SQ88(F88(from), 2); - else if (R88(from) == 6 && R88(to) == 4) - pos->en_passant = SQ88(F88(from), 5); - } - - /* always make "from" square empty */ - new->board[from].piece = 0; - new->board[from].s_piece = NULL; - - //printf("old turn=%d ", color); - SET_COLOR(new->turn, OPPONENT(color)); /* pos color */ - //printf("new turn=%d\n", new->turn); - //fflush(stdout); - /* adjust castling flags */ - if ((bb_from | bb_to) & (A1 | E1)) - new->castle &= ~CASTLE_WQ; - else if ((bb_from | bb_to) & (E1 | H1)) - new->castle &= ~CASTLE_WK; - else if ((bb_from | bb_to) & (A8 | E8)) - new->castle &= ~CASTLE_BQ; - else if ((bb_from | bb_to) & (E8 | H8)) - new->castle &= ~CASTLE_BK; - return new; -} - -void move_undo(pos_t *pos, __unused move_t *move) -{ - pos_del(pos); + qsort(moves->move, moves->nmoves, sizeof(move_t), _moves_cmp_bysquare); } diff --git a/src/move.h b/src/move.h index 2e706e2..19fbb66 100644 --- a/src/move.h +++ b/src/move.h @@ -15,20 +15,121 @@ #define MOVE_H #include "chessdefs.h" -#include "position.h" -#include "pool.h" #include "piece.h" +#include "board.h" -/* move flags +/* 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 + * + * 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 */ -typedef unsigned char move_flags_t; -#define M_NORMAL 0x00 -#define M_CHECK 0x01 /* unsure if we know */ -#define M_CAPTURE 0x02 -#define M_EN_PASSANT 0x04 -#define M_PROMOTION 0x08 -#define M_CASTLE_K 0x10 -#define M_CASTLE_Q 0x20 +typedef s32 move_t; + +/* special move_t values */ +#define MOVE_NONE (-1) +#define MOVE_NULL (0) /* hack: from = to = A1 */ + +enum { + M_OFF_FROM = 0, + M_OFF_TO = 6, + M_OFF_PROMOTED = 12, + M_OFF_CAPTURED = 15, + M_OFF_FLAGS = 18 +}; + +typedef enum { + M_CAPTURE = mask(M_OFF_FLAGS + 0), + M_ENPASSANT = mask(M_OFF_FLAGS + 1), + M_PROMOTION = mask(M_OFF_FLAGS + 2), + M_CASTLE_K = mask(M_OFF_FLAGS + 3), /* maybe only one ? */ + M_CASTLE_Q = mask(M_OFF_FLAGS + 5), /* maybe only one ? */ + M_CHECK = mask(M_OFF_FLAGS + 6), /* maybe unknown/useless ? */ + M_DPUSH = mask(M_OFF_FLAGS + 7) /* pawn double push */ +} move_flags_t; + +#define move_set_flags(move, flags) ((move) | (flags)) + +#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 MOVES_MAX 256 + +typedef struct __movelist_s { + move_t move[MOVES_MAX]; + int nmoves; /* total moves (fill) */ +} movelist_t; + +static inline square_t move_from(move_t move) +{ + return move & 077; +} + +static inline square_t move_to(move_t move) +{ + return (move >> M_OFF_TO) & 077; +} + +static inline piece_type_t move_promoted(move_t move) +{ + return (move >> M_OFF_PROMOTED) & 07; +} + +static inline piece_type_t move_captured(move_t move) +{ + return (move >> M_OFF_CAPTURED) & 07; +} + +static inline move_t move_make(square_t from, square_t to) +{ + return (to << M_OFF_TO) | from; +} + +static inline move_t move_make_flags(square_t from, square_t to, move_flags_t flags) +{ + return move_set_flags(move_make(from, to), flags); +} + +static inline move_t move_make_capture(square_t from, square_t to) +{ + return move_make_flags(from, to, M_CAPTURE); +} + +static inline move_t move_make_enpassant(square_t from, square_t to) +{ + return move_make_flags(from, to, M_ENPASSANT); +} + +static inline move_t move_make_promote(square_t from, square_t to, + piece_type_t promoted) +{ + return move_make_flags(from, to, M_PROMOTION) | (promoted << M_OFF_PROMOTED); +} + +static inline move_t move_make_promote_capture(square_t from, square_t to, + piece_type_t promoted) +{ + return move_make_promote(from, to, promoted) | M_CAPTURE; +} + +static inline move_t move_set_captured(move_t move, piece_type_t captured) +{ + return move | (captured << M_OFF_CAPTURED); +} /* moves_print flags */ @@ -36,44 +137,14 @@ typedef unsigned char move_flags_t; #define M_PR_NCAPT 0x02 #define M_PR_NUM 0x04 #define M_PR_NL 0x08 +#define M_UCI 0x10 /* UCI style - e7e8q */ #define M_PR_EVAL 0x20 /* separate captures */ #define M_PR_SEPARATE 0x40 /* separate captures */ #define M_PR_LONG 0x80 -typedef struct move_s { - piece_t piece; - square_t from, to; - piece_t capture; /* captured piece */ - piece_t promotion; /* promoted piece */ - move_flags_t flags; - eval_t negamax; - eval_t eval; - eval_t eval_simple; - pos_t *pos; - struct list_head list; /* next move */ -} move_t; - -pool_t *moves_pool_init(); -void moves_pool_stats(); -int move_print(int movenum, move_t *move, move_flags_t flags); -void moves_print(pos_t *move, move_flags_t flags); - -void move_del(struct list_head *ptr); -int moves_del(pos_t *pos); - -int pseudo_moves_castle(pos_t *pos, bool color, bool doit, bool do_king); -int pseudo_moves_gen(pos_t *pos, piece_list_t *piece, bool doit, bool do_king); -int pseudo_moves_pawn(pos_t *pos, piece_list_t *piece, bool doit); -int moves_gen(pos_t *pos, bool color, bool doit, bool do_king); -int moves_gen_king_moves(pos_t *pos, bool color, bool doit); - -void moves_sort(pos_t *pos); -void moves_gen_eval_sort(pos_t *pos); - -void moves_gen_all(pos_t *pos); -void moves_gen_all_nomoves(pos_t *pos); - -pos_t *move_do(pos_t *pos, move_t *move); -void move_undo(pos_t *pos, move_t *move); +//int move_print(int movenum, move_t *move, move_flags_t flags); +char *move_str(char *dst, const move_t move, __unused const int flags); +void moves_print(movelist_t *moves, int flags); +void move_sort_by_sq(movelist_t *moves); #endif /* MOVE_H */ diff --git a/src/piece.c b/src/piece.c index b6e4eeb..e00f9d5 100644 --- a/src/piece.c +++ b/src/piece.c @@ -1,6 +1,6 @@ /* piece.c - piece list management. * - * Copyright (C) 2021 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. * @@ -13,106 +13,83 @@ #include #include +#include +#include -#include -#include -#include +#include "bug.h" #include "chessdefs.h" #include "piece.h" -#include "board.h" -#include "bitboard.h" -#include "position.h" -static pool_t *pieces_pool; - -struct piece_details piece_details[] = { - [E_EMPTY] = { ' ', ' ', " ", " ", "", 0 }, - [E_PAWN] = { 'P', 'p', "♙", "♟", "Pawn", PAWN_VALUE }, - [E_KNIGHT] = { 'N', 'n', "♘", "♞", "Knight", KNIGHT_VALUE }, - [E_BISHOP] = { 'B', 'b', "♗", "♝", "Bishop", BISHOP_VALUE }, - [E_ROOK] = { 'R', 'r', "♖", "♜", "Rook", ROOK_VALUE }, - [E_QUEEN] = { 'Q', 'q', "♕", "♛", "Queen", QUEEN_VALUE }, - [E_KING] = { 'K', 'k', "♔", "♚", "King", KING_VALUE } +/** + * piece_details + */ +const struct piece_details piece_details[PIECE_MAX] = { + /* cap low fen sym name values */ + [EMPTY] = { "", "", "", "", "", 0, 0, 0 }, + [W_PAWN] = { "", "", "P", "♙", "Pawn", P_VAL_OPN, P_VAL_MID, P_VAL_END }, + [W_KNIGHT] = { "N", "n", "N", "♘", "Knight", N_VAL_OPN, N_VAL_MID, N_VAL_END }, + [W_BISHOP] = { "B", "b", "B", "♗", "Bishop", B_VAL_OPN, B_VAL_MID, B_VAL_END }, + [W_ROOK] = { "R", "r", "R", "♖", "Rook", R_VAL_OPN, R_VAL_MID, R_VAL_END }, + [W_QUEEN] = { "Q", "q", "Q", "♕", "Queen", Q_VAL_OPN, Q_VAL_MID, Q_VAL_END }, + [W_KING] = { "K", "k", "K", "♔", "King", K_VAL_OPN, K_VAL_MID, K_VAL_END }, + [7] = { "", "", "", "", "", 0, 0, 0 }, + [8] = { "", "", "", "", "", 0, 0, 0 }, + [B_PAWN] = { "", "", "p", "♟", "Pawn", P_VAL_OPN, P_VAL_MID, P_VAL_END }, + [B_KNIGHT] = { "N", "n", "n", "♞", "Knight", P_VAL_OPN, N_VAL_MID, N_VAL_END }, + [B_BISHOP] = { "B", "b", "b", "♝", "Bishop", P_VAL_OPN, B_VAL_MID, B_VAL_END }, + [B_ROOK] = { "R", "r", "r", "♜", "Rook", P_VAL_OPN, R_VAL_MID, R_VAL_END }, + [B_QUEEN] = { "Q", "q", "q", "♛", "Queen", P_VAL_OPN, Q_VAL_MID, Q_VAL_END }, + [B_KING] = { "K", "k", "k", "♚", "King", P_VAL_OPN, K_VAL_MID, K_VAL_END }, }; -void piece_list_print(struct list_head *list) +const char pieces_str[6+6+1] = "PNBRQKpnbrqk"; + +bool piece_ok(piece_t p) { - struct list_head *p_cur, *tmp; - piece_list_t *piece; - - list_for_each_safe(p_cur, tmp, list) { - piece = list_entry(p_cur, piece_list_t, list); - - printf("%s%c%c ", P_SYM(piece->piece), - FILE2C(F88(piece->square)), - RANK2C(R88(piece->square))); - } - printf("\n"); + piece_type_t pt = PIECE(p); + return !(p & ~(MASK_COLOR | MASK_PIECE)) && pt && (pt <= KING); } -pool_t *piece_pool_init() +char *piece_to_cap(piece_t p) { - if (!pieces_pool) - pieces_pool = pool_create("pieces", 128, sizeof(piece_list_t)); - return pieces_pool; + return piece_details[p].cap; } -void piece_pool_stats() +char *piece_to_char(piece_t p) { - if (pieces_pool) - pool_stats(pieces_pool); + return piece_details[p].fen; } -piece_list_t *piece_add(pos_t *pos, piece_t piece, square_t square) +char *piece_to_low(piece_t p) { - piece_list_t *new; - short color = COLOR(piece); - -# ifdef DEBUG_PIECE - log_f(3, "piece=%02x square=%02x\n", piece, square); - log_f(5, "Adding %s %s on %c%c\n", color? "Black": "White", - P_NAME(piece), FILE2C(F88(square)), RANK2C(R88(square))); -# endif - if ((new = pool_get(pieces_pool))) { - /* first piece is always king */ - if (PIECE(piece) == KING) - list_add(&new->list, &pos->pieces[color]); - else - list_add_tail(&new->list, &pos->pieces[color]); - new->piece = piece; - new->square = square; - new->castle = 0; - new-> value = piece_details[PIECE(piece)].value; - } - - return new; + return piece_details[p].low; } -void piece_del(struct list_head *ptr) +char *piece_to_sym(piece_t p) { - piece_list_t *piece = list_entry(ptr, piece_list_t, list); -# ifdef DEBUG_PIECE - log_f(3, "piece=%02x square=%02x\n", piece->piece, piece->square); -# endif - list_del(ptr); - pool_add(pieces_pool, piece); - return; + return piece_details[p].sym; } -int pieces_del(pos_t *pos, short color) +char *piece_to_name(piece_t p) { - struct list_head *p_cur, *tmp, *head; - int count = 0; - - head = &pos->pieces[color]; - - list_for_each_safe(p_cur, tmp, head) { - piece_del(p_cur); - count++; - } -# ifdef DEBUG_PIECE - log_f(3, "color=%d removed=%d\n", color, count); -# endif - return count; + return piece_details[p].name; +} + +piece_type_t piece_t_from_char(char c) +{ + char *p = strchr(pieces_str, c); + return p? (p - pieces_str) % 6 + 1: NO_PIECE_TYPE; +} + +//piece_type_t piece_from_promotion(char c, color_t color) +//{ +// piece_type_t piece = piece_t_from_char(c); +// return piece? SET_COLOR()p? (p - pieces_str) % 6 + 1: NO_PIECE_TYPE; +//} + +piece_t piece_from_char(char c) +{ + piece_type_t piece = piece_t_from_char(c); + return isupper(c)? SET_WHITE(piece): SET_BLACK(piece); } diff --git a/src/piece.h b/src/piece.h index 48e3462..8ec11fc 100644 --- a/src/piece.h +++ b/src/piece.h @@ -1,6 +1,6 @@ /* piece.h - piece definitions. * - * Copyright (C) 2021 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. * @@ -14,58 +14,127 @@ #ifndef PIECE_H #define PIECE_H -#include +#include #include "chessdefs.h" -#include "list.h" -#include "pool.h" -#define PIECE_DEFAULT_VALUE 0 +/* piece_t bits structure + * piece is on bits 1-3, color on bit 4: + * .... CPPP + * C: 0 for white, 1: black + * PPP: pawn (1), knight, bishop, rook, queen, king (6) + */ +typedef enum { + WHITE, BLACK, + COLOR_MAX +} color_t; -/* initial default values */ -#define PAWN_VALUE 100 -#define KNIGHT_VALUE 300 -#define BISHOP_VALUE 300 -#define ROOK_VALUE 500 -#define QUEEN_VALUE 900 -#define KING_VALUE 20000 +typedef enum { + ALL_PIECES = 0, /* 'all pieces' bitboard */ + NO_PIECE_TYPE = 0, + PAWN = 1, KNIGHT, BISHOP, ROOK, QUEEN, KING, + PIECE_TYPE_MAX = 7 /* bit 4 */ +} piece_type_t; -typedef struct piece_list_s { - piece_t piece; - square_t square; - short castle; - s64 value; - struct list_head list; -} piece_list_t; +typedef enum __piece_e { + EMPTY = 0, + NO_PIECE = 0, + W_PAWN = PAWN, W_KNIGHT, W_BISHOP, W_ROOK, W_QUEEN, W_KING, + B_PAWN = PAWN | 8, B_KNIGHT, B_BISHOP, B_ROOK, B_QUEEN, B_KING, + PIECE_MAX +} piece_t; + +/* default values for opening, midgame, endgame + */ +#define E_VAL_OPN 0 /* empty */ +#define P_VAL_OPN 100 +#define N_VAL_OPN 300 +#define B_VAL_OPN 300 +#define R_VAL_OPN 500 +#define Q_VAL_OPN 900 +#define K_VAL_OPN 20000 + +#define E_VAL_MID 0 +#define P_VAL_MID 100 +#define N_VAL_MID 300 +#define B_VAL_MID 300 +#define R_VAL_MID 500 +#define Q_VAL_MID 900 +#define K_VAL_MID 20000 + +#define E_VAL_END 0 +#define P_VAL_END 100 +#define N_VAL_END 300 +#define B_VAL_END 300 +#define R_VAL_END 500 +#define Q_VAL_END 900 +#define K_VAL_END 20000 /* some default values for pieces + * @abbr: char, piece capital letter (used for game notation) + * @abbr_c: char, capital for white, lowercase for black + * char *sym; + * char *sym_c; + * char *name; + * s64 opn_value; + * s64 mid_value; + * s64 end_value; */ -extern struct piece_details { - char abbrev_w; /* used for game notation */ - char abbrev_b; - char *symbol_w; - char *symbol_b; /* used for game notation */ - char *name; - s64 value; -} piece_details[]; +extern const struct piece_details { + char *cap; /* used for game notation */ + char *low; /* used also for UCI promotion */ + char *fen; /* cap=white, low=black */ + char *sym; /* UTF-8 symbol */ + char *name; /* piece name */ + s64 opn_value; /* value opening */ + s64 mid_value; /* value midgame */ + s64 end_value; /* value endgame */ +} piece_details[PIECE_MAX]; + +extern const char pieces_str[6+6+1]; /* to search from fen/user input */ + +#define OPPONENT(color) !(color) + +#define MASK_PIECE 0x07 /* 00000111 */ +#define MASK_COLOR 0x08 /* 00001000 */ + +#define COLOR(p) ((p) >> 3) /* bitmask */ +#define PIECE(p) ((p) & MASK_PIECE) +#define MAKE_PIECE(p, c) ((p) | (c) << 3) + +#define IS_WHITE(p) (!COLOR(p)) +#define IS_BLACK(p) (COLOR(p)) + +#define SET_WHITE(p) (piece_t)((p) &= ~MASK_COLOR) +#define SET_BLACK(p) (piece_t)((p) |= MASK_COLOR) +#define SET_COLOR(p, c) (piece_t)(!(c)? SET_WHITE(p): SET_BLACK(p)) + +bool piece_ok(piece_t p); + +char *piece_to_cap(piece_t p); +char *piece_to_low(piece_t p); +char *piece_to_fen(piece_t p); +char *piece_to_sym(piece_t p); +char *piece_to_name(piece_t p); + +#define piece_to_char(c) piece_to_fen(c) +//#define piece_to_char_t(p) piece_to_uci(p) + +//piece_type_t char_to_piece(char c); +piece_type_t piece_t_from_char(char c); +piece_t piece_from_fen(char c); + +#define piece_from_char(c) piece_from_fen(c) -#define P_NAME(p) piece_details[E_PIECE(p)].name -#define P_LETTER(p) piece_details[E_PIECE(p)].abbrev_w -#define P_SYM(p) piece_details[E_PIECE(p)].symbol_b -#define P_CSHORT(p) (IS_WHITE(p)? piece_details[E_PIECE(p)].abbrev_w: \ - piece_details[E_PIECE(p)].abbrev_b) -#define P_CSYM(p) (IS_WHITE(p)? piece_details[E_PIECE(p)].symbol_w: \ - piece_details[E_PIECE(p)].symbol_b) -#define P_VALUE(p) (piece_details[E_PIECE(p)].value) /* use short name or symbol - no effect */ #define P_USE_UTF 1 -void piece_list_print(struct list_head *list); -pool_t *piece_pool_init(); -void piece_pool_stats(); -piece_list_t *piece_add(pos_t *pos, piece_t piece, square_t square); -void piece_del(struct list_head *ptr); -int pieces_del(pos_t *pos, short color); +//void piece_list_print(struct list_head *list); +//pool_t *piece_pool_init(); +//void piece_pool_stats(); +//piece_list_t *piece_add(pos_t *pos, piece_t piece, square_t square); +//void piece_del(struct list_head *ptr); +//int pieces_del(pos_t *pos, short color); #endif diff --git a/src/position.c b/src/position.c index 051d174..2d98be4 100644 --- a/src/position.c +++ b/src/position.c @@ -1,6 +1,6 @@ /* position.c - position management. * - * Copyright (C) 2021 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. * @@ -16,213 +16,49 @@ #include #include #include +#include + +#include "brlib.h" +#include "bitops.h" #include "chessdefs.h" #include "position.h" -#include "move.h" +#include "bitboard.h" #include "fen.h" #include "piece.h" -#include "eval.h" +#include "util.h" +#include "board.h" +#include "attack.h" -static pool_t *pos_pool; - -#define BYTE_PRINT "%c%c%c%c%c%c%c%c" -#define BYTE2BIN(b) ((b) & 0x01 ? '1' : '0'), \ - ((b) & 0x02 ? '1' : '0'), \ - ((b) & 0x04 ? '1' : '0'), \ - ((b) & 0x08 ? '1' : '0'), \ - ((b) & 0x10 ? '1' : '0'), \ - ((b) & 0x20 ? '1' : '0'), \ - ((b) & 0x40 ? '1' : '0'), \ - ((b) & 0x80 ? '1' : '0') - -inline void bitboard_print(bitboard_t bb) +/** + * pos_new() - allocate a new position + * + * Position is not initialized. + * If BUG_ON compilation is defined, the program will fail. + * + * @Return: The new position or NULL. + */ +pos_t *pos_new(void) { - int i; - printf("%#018lx\n", bb); - for (i=56; i>=0; i-=8) - printf("\t"BYTE_PRINT"\n", - BYTE2BIN(bb>>i)); -} - -inline void bitboard_print2(bitboard_t bb1, bitboard_t bb2) -{ - int i; - printf("\tW: %#018lx\tB: %#018lx\n", bb1, bb2); - for (i=56; i>=0; i-=8) - printf("\t"BYTE_PRINT"\t\t"BYTE_PRINT"\n", - BYTE2BIN(bb1>>i), - BYTE2BIN(bb2>>i)); + return safe_malloc(sizeof(pos_t)); } /** - * pos_pieces_print() - Print position pieces - * @pos: &position + * pos_dup() - duplicate a position. + * @pos: &position to duplicate. + * + * Return a copy, allocated with malloc(1), of @pos. + * + * @Return: The new position. + * + * TODO: merge with pos_new - NULL for init, non null for duplicate */ -void pos_pieces_print(pos_t *pos) +pos_t *pos_dup(const pos_t *pos) { - printf("White pieces (%d): \t", popcount64(pos->occupied[WHITE])); - piece_list_print(&pos->pieces[WHITE]); - printf("Black pieces (%d): \t", popcount64(pos->occupied[BLACK])); - piece_list_print(&pos->pieces[BLACK]); -} + pos_t *newpos = safe_malloc(sizeof(pos_t)); -/** - * pos_bitboards_print() - Print position bitboards - * @pos: &position - */ -void pos_bitboards_print(pos_t *pos) -{ - printf("Bitboards occupied :\n"); - bitboard_print2(pos->occupied[WHITE], pos->occupied[BLACK]); - printf("Bitboards controlled :\n"); - bitboard_print2(pos->controlled[WHITE], pos->controlled[BLACK]); - -} - -/** - * pos_print() - Print position on stdout. - * @pos: &position - */ -void pos_print(pos_t *pos) -{ - int rank, file; - piece_t piece; - board_t *board = pos->board; - piece_list_t *wk = list_first_entry(&pos->pieces[WHITE], piece_list_t, list), - *bk = list_first_entry(&pos->pieces[BLACK], piece_list_t, list); - - - printf(" +---+---+---+---+---+---+---+---+\n"); - for (rank = 7; rank >= 0; --rank) { - printf("%c |", rank + '1'); - for (file = 0; file < 8; ++file) { - piece = board[SQ88(file, rank)].piece; - printf(" %s |", P_CSYM(piece)); - } - printf("\n +---+---+---+---+---+---+---+---+\n"); - } - printf(" A B C D E F G H\n\n"); - printf("Turn: %s.\n", IS_WHITE(pos->turn) ? "white" : "black"); - printf("Kings: W:%c%c B:%c%c\n", - FILE2C(F88(wk->square)), - RANK2C(R88(wk->square)), - FILE2C(F88(bk->square)), - RANK2C(R88(bk->square))); - printf("Possible en-passant: [%#x] ", pos->en_passant); - if (pos->en_passant == 0) - printf("None.\n"); - else - printf("%d %d = %c%c\n", - F88(pos->en_passant), - R88(pos->en_passant), - FILE2C(F88(pos->en_passant)), - RANK2C(R88(pos->en_passant))); - - printf("castle [%#x] : ", pos->castle); - - if (pos->castle & CASTLE_WK) - printf("K"); - if (pos->castle & CASTLE_WQ) - printf("Q"); - if (pos->castle & CASTLE_BK) - printf("k"); - if (pos->castle & CASTLE_BQ) - printf("q"); - - printf("\n50 half-moves-rule = %d\n", pos->clock_50); - printf("Current move = %d\n", pos->curmove); - printf("Squares controlled: W:%d B:%d\n", popcount64(pos->controlled[WHITE]), - popcount64(pos->controlled[BLACK])); - printf("Mobility: W:%u B:%u\n", pos->mobility[WHITE], - pos->mobility[BLACK]); -} - -/** - * pos_check() - extensive position consistenci check. - * @pos: &position - */ -void pos_check(pos_t *pos) -{ - int rank, file; - piece_t piece; - board_t *board = pos->board; - - /* check that board and bitboard reflect same information */ - for (rank = 7; rank >= 0; --rank) { - for (file = 0; file < 8; ++file) { - piece_list_t *ppiece; - printf("checking %c%c ", file+'a', rank+'1'); - - piece = board[SQ88(file, rank)].piece; - ppiece= board[SQ88(file, rank)].s_piece; - printf("piece=%s ", P_CSYM(piece)); - if (ppiece) - printf("ppiece=%s/sq=%#x ", P_CSYM(ppiece->piece), ppiece->square); - switch(PIECE(piece)) { - case PAWN: - printf("pawn" ); - break; - case KNIGHT: - printf("knight "); - break; - case BISHOP: - printf("bishop "); - break; - case ROOK: - printf("rook "); - break; - case QUEEN: - printf("queen "); - break; - case KING: - printf("king "); - break; - } - printf("\n"); - } - } -} - -pos_t *pos_clear(pos_t *pos) -{ - int file, rank; - board_t *board = pos->board; - - for (file = 0; file < 8; ++file) { - for (rank = 0; rank < 8; ++rank) { - /*printf("file = %d rank = %d SQ88 = %#2x = %d addr=%p\n", file, rank, - SQ88(file, rank), SQ88(file, rank), - &board[SQ88(file, rank)].piece); - */ - board[SQ88(file, rank)].piece = EMPTY; - } - } - - SET_WHITE(pos->turn); - pos->node_count = 0; - pos->castle = 0; - pos->clock_50 = 0; - pos->curmove = 0; - pos->eval = 0; - pos->en_passant = 0; - pos->occupied[WHITE] = 0; - pos->occupied[BLACK] = 0; - for (int color=0; color<2; ++color) - for (int piece = BB_ALL; piece < BB_END; ++piece) - pos->bb[color][piece] = 0; - pos->controlled[WHITE] = 0; - pos->controlled[BLACK] = 0; - pos->mobility[WHITE] = 0; - pos->mobility[BLACK] = 0; - pos->moves_generated = false; - pos->moves_counted = false; - /* remove pieces / moves */ - pieces_del(pos, WHITE); - pieces_del(pos, BLACK); - moves_del(pos); - - return pos; + *newpos = *pos; + return newpos; } /** @@ -231,93 +67,307 @@ pos_t *pos_clear(pos_t *pos) */ void pos_del(pos_t *pos) { - pieces_del(pos, WHITE); - pieces_del(pos, BLACK); - moves_del(pos); - pool_add(pos_pool, pos); + safe_free(pos); } -pos_t *pos_startpos(pos_t *pos) +/** + * pos_clear() - clear a position. + * @pos: &position. + * + * @return: @pos. + */ +pos_t *pos_clear(pos_t *pos) { - static char *startfen="rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"; +# ifdef DEBUG_POS + printf("size(pos_board=%lu elt=%lu\n", sizeof(pos->board), sizeof(int)); +# endif + pos->node_count = 0; + pos->turn = WHITE; - return fen2pos(pos, startfen); -} + /* move_do/undo position state */ + pos->en_passant = SQUARE_NONE; + pos->castle = 0; + pos->clock_50 = 0; + pos->plycount = 0; + pos->captured = NO_PIECE; -pos_t *pos_get() -{ - pos_t *pos = pool_get(pos_pool); - if (pos) { - INIT_LIST_HEAD(&pos->pieces[WHITE]); - INIT_LIST_HEAD(&pos->pieces[BLACK]); + for (square_t sq = A1; sq <= H8; ++sq) + pos->board[sq] = EMPTY; - INIT_LIST_HEAD(&pos->moves[WHITE]); - INIT_LIST_HEAD(&pos->moves[BLACK]); - pos_clear(pos); - } else { - fprintf(stderr, "zobaaa\n"); + for (color_t color = WHITE; color <= BLACK; ++color) { + for (piece_type_t piece = 0; piece <= KING; ++piece) + pos->bb[color][piece] = 0; + //pos->controlled[color] = 0; + pos->king[color] = SQUARE_NONE; } + + pos->checkers = 0; + pos->pinners = 0; + pos->blockers = 0; + + //pos->moves.curmove = 0; + pos->moves.nmoves = 0; return pos; } /** - * pos_dup() - duplicate a position. - * @pos: &position to duplicate. + * pos_cmp() - compare two positions.. + * @pos1, @pos2: The two &position. * - * New position is the same as source one (with duplicated pieces list), - * except: - * - moves list is empty - * - bestmove is NULL - * - nodecount is set to zero - * - eval is set to EVAL_INVALID - * - moves_generated ans moves_counted are unset - * - check is set to zero - * - * @return: The new position. - * - * TODO: merge with pos_get - NULL for init, non null for duplicate + * @return: true if equal, false otherwise. */ -pos_t *pos_dup(pos_t *pos) +bool pos_cmp(const pos_t *pos1, const pos_t *pos2) { - struct list_head *p_cur, *piece_list; - piece_list_t *oldpiece; - board_t *board; - pos_t *new = pool_get(pos_pool); +#define _cmpf(a) (pos1->a != pos2->a) + bool ret = false; + if (warn_on(_cmpf(node_count))) + goto end; + if (warn_on(_cmpf(turn))) + goto end; - if (new) { - board = new->board; - *new = *pos; - for (int color = 0; color < 2; ++color) { - INIT_LIST_HEAD(&new->pieces[color]); - INIT_LIST_HEAD(&new->moves[color]); - /* duplicate piece list */ - piece_list = &pos->pieces[color]; /* white/black piece list */ + /* move_do/undo position state */ + if (warn_on(_cmpf(en_passant))) + goto end; + if (warn_on(_cmpf(castle))) + goto end; + if (warn_on(_cmpf(clock_50))) + goto end; + if (warn_on(_cmpf(plycount))) + goto end; + if (warn_on(_cmpf(captured))) + goto end; - list_for_each(p_cur, piece_list) { - oldpiece = list_entry(p_cur, piece_list_t, list); - board[oldpiece->square].s_piece = - piece_add(new, oldpiece->piece, oldpiece->square); - } - } - new->bestmove = NULL; - new->node_count = 0; - new->eval = EVAL_INVALID; - new->moves_generated = false; - new->moves_counted = false; - new->check[WHITE] = new->check[BLACK] = 0; + for (square_t sq = A1; sq <= H8; ++sq) + if (warn_on(_cmpf(board[sq]))) + goto end; + + for (color_t color = WHITE; color <= BLACK; ++color) { + for (piece_type_t piece = 0; piece <= KING; ++piece) + if (warn_on(_cmpf(bb[color][piece]))) + goto end; + //pos->controlled[color] = 0; + if (warn_on(_cmpf(king[color]))) + goto end; } - return new; + + if (warn_on(_cmpf(checkers))) + goto end; + if (warn_on(_cmpf(pinners))) + goto end; + if (warn_on(_cmpf(blockers))) + goto end; + + if (warn_on(_cmpf(moves.nmoves))) + goto end; + for (int i = 0; i < pos1->moves.nmoves; ++i) + if (warn_on(_cmpf(moves.move[i]))) + goto end; + + ret = true; +end: + return ret; +#undef _cmpf } -pool_t *pos_pool_init() +/** + * pos_checkers() - find all checkers on a king. + * @pos: &position + * @color: king color + * + * Get a bitboard of all checkers on @color king. + * Just a wrapper over @sq_attackers(). + * + * @return: a bitboard of attackers. + */ +bitboard_t pos_checkers(const pos_t *pos, const color_t color) { - if (!pos_pool) - pos_pool = pool_create("positions", 128, sizeof(pos_t)); - return pos_pool; + bitboard_t occ = pos_occ(pos); + return sq_attackers(pos, occ, pos->king[color], OPPONENT(color)); } -void pos_pool_stats() +/** + * pos_king_pinners() - get the "pinners" on a king "pinners". + * @pos: &position + * @color: king color. + * + * get position "pinners" on @color king. Here, pinner means a piece separated from king + * by one piece (any color) only. + * This is just a wrapper over @sq_pinners(). + * + * @return: pinners bitboard. + */ +bitboard_t pos_king_pinners(const pos_t *pos, const color_t color) { - if (pos_pool) - pool_stats(pos_pool); + return sq_pinners(pos, pos->king[color], OPPONENT(pos->turn)); +} + +/** + * pos_king_blockers() - get the pin blockers on a king. + * @pos: &position + * @color: king color. + * @pinners: pinners bitboard. + * + * get @pinners blockers pieces on @color king. + * + * @return: blockers bitboard. + */ +bitboard_t pos_king_blockers(const pos_t *pos, const color_t color, const bitboard_t pinners) +{ + bitboard_t tmp, blockers = 0, occ = pos_occ(pos); + square_t pinner, king = pos->king[color]; + + bit_for_each64(pinner, tmp, pinners) { + bitboard_t blocker = bb_between_excl[pinner][king] & occ; + warn_on(popcount64(blocker) != 1); + if (popcount64(blocker) != 1) { + printf("n blockers = %d\n", popcount64(blocker)); + bb_print("blockers", blocker); + } + blockers |= blocker; + } + return blockers; +} + +/** + * pos_check() - extensive position consistency check. + * @pos: &position + * @strict: if true, call bug_on() on any error. + * + * Perform some validity check on position @pos: + * - pawns on 1st or 8th rank + * - number of pawns > 8 (per color) + * - total number of pieces > 16 or zero (per color) + * - number of kings != 1 (per color) + * - discrepancy between board and king (per color) + * - discrepancy between piece bitboards and ALL_PIECES bitboards (per color) + * - discrepancy between bitboards and board (per color) + * - side-to-move already checking opponent king + * - side-to-move in check more than twice + * - kings distance is 1 + * + * In case of errors, and @strict is true, @bug_on() is called, and program will + * be terminated. + * This function should be called with @strict == false during initialization phase + * (eg after fen parsing), and with @strict == true otherwise (as we have some data + * corruption). + * + * TODO: add more checks: + * - kings attacking each other + * + * @Return: Number of detected error (only if @strict is false). + */ +int pos_check(const pos_t *pos, const bool strict) +{ + int n, count = 0, bbcount = 0, error = 0; + bitboard_t tmp; + + /* pawns on 1st ot 8th rank */ + tmp = (pos->bb[WHITE][PAWN] | pos->bb[BLACK][PAWN]) & (RANK_1bb | RANK_8bb); + error += warn_on(tmp); + + for (color_t color = WHITE; color <= BLACK; ++color) { + /* pawn count */ + n = popcount64(pos->bb[color][PAWN]); + error += warn_on(n > 8); + /* king count */ + n = popcount64(pos->bb[color][KING]); + error += warn_on(n != 1); + /* king mismatch with board */ + error += warn_on(PIECE(pos->board[pos->king[color]]) != KING); + /* pieces count */ + n = popcount64(pos->bb[color][ALL_PIECES]); + error += warn_on(n == 0 || n > 16); + bbcount += n; + } + for (square_t sq = 0; sq < 64; ++sq) { + piece_t piece = pos->board[sq]; + bitboard_t match; + if (piece == EMPTY) + continue; + color_t c = COLOR(piece); + piece_type_t p = PIECE(piece); + match = pos->bb[c][p] & mask(sq); + error += warn_on(!match); + count++; + } + /* occupied occupation is different from bitboards */ + error += warn_on(count != bbcount); + /* is opponent already in check ? */ + error += warn_on(pos_checkers(pos, OPPONENT(pos->turn))); + /* is color to play in check more than twice ? */ + error += warn_on(popcount64(pos_checkers(pos, OPPONENT(pos->turn))) > 2); + /* kings distance is less than 2 */ + error += warn_on(sq_dist(pos->king[WHITE], pos->king[BLACK]) < 2); + + bug_on(strict && error); + return error; +} + +/** + * pos_print() - Print position and fen on stdout. + * @pos: &position + */ +void pos_print(const pos_t *pos) +{ + char str[128]; + + board_print(pos->board); + printf("fen %s\n", pos2fen(pos, str)); + printf("checkers: %s\n", pos_checkers2str(pos, str, sizeof(str))); + printf("pinners : %s\n", pos_pinners2str(pos, str, sizeof(str))); + printf("blockers: %s\n", pos_blockers2str(pos, str, sizeof(str))); +} + +/** + * pos_print_mask() - Print position and fen on stdout, with highlighted squares. + * @pos: &position + * @mask: mask of highlighted squares. + */ +void pos_print_mask(const pos_t *pos, const bitboard_t mask) +{ + char fen[92]; + + board_print_mask(pos->board, mask); + printf("fen %s\n", pos2fen(pos, fen)); +} + +/** + * pos_print_board_raw - print simple position board (octal/FEN symbol values) + * @bb: the bitboard + * @type: int, 0 for octal, 1 for fen symbol + */ +void pos_print_raw(const pos_t *pos, const int type) +{ + board_print_raw(pos->board, type); + return; +} + +/** + * pos_print_pieces() - Print position pieces + * @pos: &position + */ +void pos_print_pieces(const pos_t *pos) +{ + int sq, count, cur; + char *pname; + u64 tmp; + bitboard_t p; + for (int color = WHITE; color <= BLACK; ++color) { + for (int piece = KING; piece >= PAWN; --piece) { + p = pos->bb[color][piece]; + count = popcount64(p); + cur = 0; + pname = piece_to_char(p); + printf("%s(%d)%s", pname, count, count? ":": ""); + if (count) { + bit_for_each64(sq, tmp, p) { + // char cf = sq_file(bit), cr = sq_rank(bit); + printf("%s%s", cur? ",": "", sq_to_string(sq)); + cur++; + } + } + printf(" "); + } + printf("\n"); + } } diff --git a/src/position.h b/src/position.h index d41a0db..0de3539 100644 --- a/src/position.h +++ b/src/position.h @@ -1,6 +1,6 @@ /* position.h - position management definitions. * - * Copyright (C) 2021 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. * @@ -16,51 +16,163 @@ #include -#include "pool.h" -#include "list.h" +#include "brlib.h" #include "bitops.h" +#include "struct-group.h" -#include "board.h" #include "chessdefs.h" +#include "bitboard.h" +#include "piece.h" +#include "move.h" +#include "board.h" -typedef struct pos_s { +typedef struct __pos_s { u64 node_count; /* evaluated nodes */ - piece_t turn; /* we use only color bit */ - castle_t castle; - u16 clock_50; - u16 curmove; - eval_t eval; - int check[2]; - int eval_simple_phase; - eval_t eval_simple; - move_t *bestmove; - bool moves_generated; - bool moves_counted; - board_t board[BOARDSIZE]; + int turn; /* WHITE or BLACK */ - square_t en_passant; + /* data which cannot be recovered by move_undo + * following data can be accessed either directly, either via "movesave" + * structure name. + * For example, pos->en_passant and pos->state.en_passant are the same. + * This allows a memcpy on this data (to save/restore position state). + */ + struct_group_tagged(state_s, state, + square_t en_passant; + castle_rights_t castle; + u16 clock_50; + u16 plycount; /* plies so far, start from 1 */ + piece_t captured; /* only for move_undo */ + ); - bitboard_t bb[2][BB_END]; /* use: pieces[BLACK][BB_PAWN] */ - bitboard_t occupied[2]; /* OR of bb[COLOR][x] */ - bitboard_t controlled[2]; - u16 mobility[2]; - struct list_head pieces[2]; /* pieces list, King is first */ - struct list_head moves[2]; + piece_t board[BOARDSIZE]; + + bitboard_t bb[2][PIECE_TYPE_MAX]; /* bb[0][PAWN], bb[1][ALL_PIECES] */ + //bitboard_t controlled[2]; /* unsure */ + square_t king[2]; /* dup with bb, faster retrieval */ + bitboard_t checkers; /* opponent checkers */ + bitboard_t pinners; /* opponent pinners */ + bitboard_t blockers; /* pieces blocking pin */ + movelist_t moves; } pos_t; -void bitboard_print(bitboard_t bb); -void bitboard_print2(bitboard_t bb1, bitboard_t bb2); -void pos_pieces_print(pos_t *pos); -void pos_bitboards_print(pos_t *pos); -void pos_print(pos_t *pos); -pos_t *pos_clear(pos_t *pos); +typedef struct state_s state_t; + +#define pos_pinned(p) (p->blockers & p->bb[p->turn][ALL_PIECES]) + +/** + * pos_set_sq - unconditionally set a piece on a square + * @pos: position + * @square: square_t to set + * @piece: piece_t to add + * + * Both position board and bitboards are modified. + */ +static __always_inline void pos_set_sq(pos_t *pos, square_t square, piece_t piece) +{ + color_t color = COLOR(piece); + piece_type_t type = PIECE(piece); + pos->board[square] = piece; + pos->bb[color][type] |= mask(square); + pos->bb[color][ALL_PIECES] |= mask(square); + if (type == KING) + pos->king[color] = square; +} + +/** + * pos_clr_sq - unconditionally remove a piece from square + * @pos: position + * @square: square_t to clear + * + * Both position board and bitboards are modified. + */ +static __always_inline void pos_clr_sq(pos_t *pos, square_t square) +{ + piece_t piece = pos->board[square]; + piece_type_t type = PIECE(piece); + color_t color = COLOR(piece); + pos->board[square] = EMPTY; + pos->bb[color][type] &= ~mask(square); + pos->bb[color][ALL_PIECES] &= ~mask(square); + if (type == KING) + pos->king[color] = SQUARE_NONE; +} + +/** + * pos_occ() - get position occupation (all pieces) + * @pos: position + * + * @return: occupation bitboard. + */ +static __always_inline bitboard_t pos_occ(const pos_t *pos) +{ + return pos->bb[WHITE][ALL_PIECES] | pos->bb[BLACK][ALL_PIECES]; +} + +/** + * pos_between_occ() - find occupation between two squares. + * @pos: position + * @sq1: square 1 + * @sq2: square 2 + * + * @return: bitboard of @betw if between @sq1 and @sq2. + */ +static __always_inline bitboard_t pos_between_occ(const pos_t *pos, + const square_t sq1, const square_t sq2) +{ + return bb_between_excl[sq1][sq2] & pos_occ(pos); +} + +/** + * pos_between_count() - count occupied squares between two squares. + * @pos: position + * @sq1: square 1 + * @sq2: square 2 + * + * @return: bitboard of @betw if between @sq1 and @sq2. + */ +static __always_inline int pos_between_count(const pos_t *pos, + const square_t sq1, const square_t sq2) +{ + return popcount64(pos_between_occ(pos, sq1, sq2)); +} + +/** + * pos_checkers2str() - get of string of checkers. + * @p: position + * @str: destination string + * @len: max @str len. + * + * A wrapper over @bb_sq2str() for checkers bitmap. + * + * @return: @str. + */ +#define pos_checkers2str(p, str, len) bb_sq2str(p->checkers, str, len) +#define pos_pinners2str(p, str, len) bb_sq2str(p->pinners, str, len) +#define pos_blockers2str(p, str, len) bb_sq2str(p->blockers, str, len) + +//void bitboard_print(bitboard_t bb, char *title); +//void bitboard_print2(bitboard_t bb1, bitboard_t bb2, char *title); + +pos_t *pos_new(); +pos_t *pos_dup(const pos_t *pos); void pos_del(pos_t *pos); -pos_t *pos_startpos(pos_t *pos); -pos_t *pos_create(); -pool_t *pos_pool_init(); -void pos_pool_stats(); -pos_t *pos_get(); -pos_t *pos_dup(pos_t *pos); -void pos_check(pos_t *pos); +pos_t *pos_clear(pos_t *pos); +bool pos_cmp(const pos_t *pos1, const pos_t *pos2); + +bitboard_t pos_checkers(const pos_t *pos, const color_t color); +bitboard_t pos_king_pinners(const pos_t *pos, const color_t color); +bitboard_t pos_king_blockers(const pos_t *pos, const color_t color, const bitboard_t ); +//bitboard_t set_king_pinners_blockers(pos_t *pos); +//char *pos_checkers2str(const pos_t *pos, char *str); +//char *pos_pinners2str(const pos_t *pos, char *str); + +int pos_check(const pos_t *pos, const bool strict); + +void pos_print(const pos_t *pos); +void pos_print_mask(const pos_t *pos, const bitboard_t mask); +void pos_print_raw(const pos_t *pos, const int type); + +void pos_print_pieces(const pos_t *pos); + #endif /* POSITION_H */ diff --git a/src/temp-migration-bitboard/bitboard.c b/src/temp-migration-bitboard/bitboard.c new file mode 100644 index 0000000..7034183 --- /dev/null +++ b/src/temp-migration-bitboard/bitboard.c @@ -0,0 +1,42 @@ +/* bitboard.c - bitboard 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include "br.h" +#include "bitboard.h" + +/* maps are clockwise from N */ +static char knight_vector[8] = { + NORTH*2 + EAST, NORTH + EAST*2, SOUTH + EAST*2, SOUTH*2 + EAST, + SOUTH*2 + WEST, SOUTH + WEST*2, NORTH + WEST*2, NORTH*2 + WEST +}; +static char king_vector[8] = { + NORTH, NORTH_EAST, EAST, SOUTH_EAST, + SOUTH, SOUTH_WEST, WEST, NORTH_WEST +}; + +static u64 knight_attacks[64], king_attacks[64]; +static int zob=0; + +void bitboard_init(void) +{ + for (int sq = SQ_0; sq < SQ_N; ++sq) { + /* knight/king */ + for (int j = 0; j < 8; ++j) { + zob += *knight_attacks + *king_attacks + *knight_vector + + *king_vector; + //int dest_knight = sq + knight_vector[j]; + //if () + } + + } +} diff --git a/src/temp-migration-bitboard/bitboard.h b/src/temp-migration-bitboard/bitboard.h new file mode 100644 index 0000000..1533b93 --- /dev/null +++ b/src/temp-migration-bitboard/bitboard.h @@ -0,0 +1,105 @@ +/* bitboard.h - bitboard definitions. + * + * 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#ifndef BITBOARD_H +#define BITBOARD_H + +#include "br.h" +#include "chessdefs.h" +#include "piece.h" +#include "bitops.h" + +#define mask(s) ( 1ULL << (s) ) +#define C64(const_u64) const_u64##ULL + +typedef enum square { + A1, B1, C1, D1, E1, F1, G1, H1, + A2, B2, C2, D2, E2, F2, G2, H2, + A3, B3, C3, D3, E3, F3, G3, H3, + A4, B4, C4, D4, E4, F4, G4, H4, + A5, B5, C5, D5, E5, F5, G5, H5, + A6, B6, C6, D6, E6, F6, G6, H6, + A7, B7, C7, D7, E7, F7, G7, H7, + A8, B8, C8, D8, E8, F8, G8, H8, + SQ_N, + SQ_0 = 0 +} square; + +typedef enum file { + FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H, + FILE_N, + FILE_0 = 0 +} file; + +typedef enum rank { + RANK_1, RANK_2, RANK_3, RANK_4, RANK_5, RANK_6, RANK_7, RANK_8, + RANK_N, + RANK_0 = 0 +} rank; + +typedef enum sq_bb { + //A1 = 0x01ULL, B1 = 0x02ULL, C1 = 1UL << 2, D1 = 1UL << 3, + //E1 = 1UL << 4, F1 = 1UL << 5, G1 = 1UL << 6, H1 = 1UL << + A1bb = mask(A1), A2bb = mask(A2), A3bb = mask(A3), A4bb = mask(A4), + A5bb = mask(A5), A6bb = mask(A6), A7bb = mask(A7), A8bb = mask(A8), + B1bb = mask(B1), B2bb = mask(B2), B3bb = mask(B3), B4bb = mask(B4), + B5bb = mask(B5), B6bb = mask(B6), B7bb = mask(B7), B8bb = mask(B8), + C1bb = mask(C1), C2bb = mask(C2), C3bb = mask(C3), C4bb = mask(C4), + C5bb = mask(C5), C6bb = mask(C6), C7bb = mask(C7), C8bb = mask(C8), + D1bb = mask(D1), D2bb = mask(D2), D3bb = mask(D3), D4bb = mask(D4), + D5bb = mask(D5), D6bb = mask(D6), D7bb = mask(D7), D8bb = mask(D8), + E1bb = mask(E1), E2bb = mask(E2), E3bb = mask(E3), E4bb = mask(E4), + E5bb = mask(E5), E6bb = mask(E6), E7bb = mask(E7), E8bb = mask(E8), + F1bb = mask(F1), F2bb = mask(F2), F3bb = mask(F3), F4bb = mask(F4), + F5bb = mask(F5), F6bb = mask(F6), F7bb = mask(F7), F8bb = mask(F8), + G1bb = mask(G1), G2bb = mask(G2), G3bb = mask(G3), G4bb = mask(G4), + G5bb = mask(G5), G6bb = mask(G6), G7bb = mask(G7), G8bb = mask(G8), + H1bb = mask(H1), H2bb = mask(H2), H3bb = mask(H3), H4bb = mask(H4), + H5bb = mask(H5), H6bb = mask(H6), H7bb = mask(H7), H8bb = mask(H8), +} sq_bb; + +typedef enum file_bb { + FILE_Abb = 0x0101010101010101ULL, + FILE_Bbb = 0x0202020202020202ULL, + FILE_Cbb = 0x0404040404040404ULL, + FILE_Dbb = 0x0808080808080808ULL, + FILE_Ebb = 0x1010101010101010ULL, + FILE_Fbb = 0x2020202020202020ULL, + FILE_Gbb = 0x4040404040404040ULL, + FILE_Hbb = 0x8080808080808080ULL, +} file_bb; + +typedef enum rank_bb { + RANK_1bb = 0x00000000000000ffULL, + RANK_2bb = 0x000000000000ff00ULL, + RANK_3bb = 0x0000000000ff0000ULL, + RANK_4bb = 0x00000000ff000000ULL, + RANK_5bb = 0x000000ff00000000ULL, + RANK_6bb = 0x0000ff0000000000ULL, + RANK_7bb = 0x00ff000000000000ULL, + RANK_8bb = 0xff00000000000000ULL +} rank_bb; + +#define NORTH 8 +#define EAST 1 +#define SOUTH -NORTH +#define WEST -EAST + +#define NORTH_EAST (NORTH + EAST) +#define SOUTH_EAST (SOUTH + EAST) +#define SOUTH_WEST (SOUTH + WEST) +#define NORTH_WEST (NORTH + WEST) + +void bitboard_init(void); + +#endif /* BITBOARD_H */ diff --git a/src/temp-migration-bitboard/board.h b/src/temp-migration-bitboard/board.h new file mode 100644 index 0000000..6543eb2 --- /dev/null +++ b/src/temp-migration-bitboard/board.h @@ -0,0 +1,80 @@ +/* board.h - board definitions. + * + * Copyright (C) 2021 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#ifndef BOARD_H +#define BOARD_H + +#include +#include "chessdefs.h" +#include "piece.h" + +typedef struct board_s { + piece_t piece; + piece_list_t *s_piece; + //struct list_head *s_piece; +} board_t; /* 0x88 board */ +#define BOARDSIZE (8*8*2) + +/* definitions for 0x88 representation + */ +#define SQ88(f, r) (((r) << 4) | (f)) /* from rank,file to sq88 */ +#define F88(s) ((s) & 0x0f) /* from sq88 to file */ +#define R88(s) ((s) >> 4) /* from sq88 to rank */ + +#define SETF88(s, r) ((s) &= 0xf0, (s) |= (r)) +#define SETR88(s, f) ((s) &= 0x0f, (s) |= (f)<<4) + +#define SQ88_NOK(s) ((s) & 0x88) /* invalid square */ +#define SQ88_OK(s) (!SQ88_NOK(s)) + +/* definitions for bitboard representation + */ +#define BB(f, r) (1ULL << (8 * (r) + (f))) /* from rank,file to bitboard */ +#define SQ88_2_BB(s) (BB(F88(s), R88(s))) /* from sq88 to bitboard */ +#define FILEBB(b) ((b) % 8) /* from sq88 to file */ +#define RANKBB(b) ((b) / 8) /* from sq88 to rank */ + +#define SQ88_NOK(s) ((s) & 0x88) /* invalid square */ +#define SQ88_OK(s) (!SQ88_NOK(s)) + +/* piece human notation + */ +#define CHAR_EMPTY ' ' +#define CHAR_PAWN 'P' +#define CHAR_KNIGHT 'N' +#define CHAR_BISHOP 'B' +#define CHAR_ROOK 'R' +#define CHAR_QUEEN 'Q' +#define CHAR_KING 'K' + +/* from human to machine + */ +#define C2FILE(c) (tolower(c) - 'a') +#define C2RANK(c) (tolower(c) - '1') +/* from machine to human + */ +#define FILE2C(f) ((f) + 'a') +#define RANK2C(r) ((r) + '1') + +enum x88_square { + x88_A1=0x00, x88_B1, x88_C1, x88_D1, x88_E1, x88_F1, x88_G1, x88_H1, + x88_A2=0x10, x88_B2, x88_C2, x88_D2, x88_E2, x88_F2, x88_G2, x88_H2, + x88_A3=0x20, x88_B3, x88_C3, x88_D3, x88_E3, x88_F3, x88_G3, x88_H3, + x88_A4=0x30, x88_B4, x88_C4, x88_D4, x88_E4, x88_F4, x88_G4, x88_H4, + x88_A5=0x40, x88_B5, x88_C5, x88_D5, x88_E5, x88_F5, x88_G5, x88_H5, + x88_A6=0x50, x88_B6, x88_C6, x88_D6, x88_E6, x88_F6, x88_G6, x88_H6, + x88_A7=0x60, x88_B7, x88_C7, x88_D7, x88_E7, x88_F7, x88_G7, x88_H7, + x88_A8=0x70, x88_B8, x88_C8, x88_D8, x88_E8, x88_F8, x88_G8, x88_H8, +}; + +#endif /* BOARD_H */ diff --git a/src/temp-migration-bitboard/brchess.c b/src/temp-migration-bitboard/brchess.c new file mode 100644 index 0000000..2661fdf --- /dev/null +++ b/src/temp-migration-bitboard/brchess.c @@ -0,0 +1,522 @@ +/* brchess.c - main loop. + * + * 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + + +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "brchess.h" +#include "chessdefs.h" +#include "board.h" +#include "piece.h" +#include "move.h" +#include "fen.h" +#include "eval.h" +#include "eval-simple.h" +#include "search.h" + +struct command { + char *name; /* User printable name */ + int (*func)(pos_t *, char *); /* function doing the job */ + 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); +struct command *find_command (char *); +char *stripwhite (char *string); + +/* 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*); + +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)" }, + { NULL, (int(*)()) NULL, NULL } +}; + +static int done=0; +static int depth=1; + +int brchess(pos_t *pos) +{ + char *buffer, *s; + + rl_attempted_completion_function = commands_completion; + rl_completer_quote_characters = "'\""; + rl_completer_word_break_characters = " "; + rl_char_is_quoted_p = "e_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); + } + free(buffer); + } + + 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) +{ + 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); +} + +/* 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]; + + return (struct command *)NULL; +} + +/* Strip whitespace from the start and end of STRING. Return a pointer + into STRING. */ +char *stripwhite(char *string) +{ + register char *s, *t; + + for (s = string; whitespace(*s); s++) + ; + + 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_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_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; +} + +/* 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; + + 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++; + } + } + + 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; +} + +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, ""); + } + 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) + * + */ +static int usage(char *prg) +{ + fprintf(stderr, "Usage: %s [-ilw] [file...]\n", prg); + return 1; +} + +#include + +int main(int ac, char **av) +{ + pos_t *pos; + int opt; + + piece_pool_init(); + moves_pool_init(); + pos_pool_init(); + pos = pos_get(); + debug_init(1, stderr, true); + eval_simple_init(); + + while ((opt = getopt(ac, av, "d:f:")) != -1) { + switch (opt) { + case 'd': + debug_level_set(atoi(optarg)); + break; + case 'f': + fen2pos(pos, optarg); + break; + default: + return usage(*av); + } + } + if (optind < ac) + return usage(*av); + + return brchess(pos); +} diff --git a/src/temp-migration-bitboard/brchess.h b/src/temp-migration-bitboard/brchess.h new file mode 100644 index 0000000..e8863d3 --- /dev/null +++ b/src/temp-migration-bitboard/brchess.h @@ -0,0 +1,21 @@ +/* brchess.h - main loop. + * + * 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#ifndef BRCHESS_H +#define BRCHESS_H + +#include "position.h" + +int brchess(pos_t *pos); + +#endif /* BRCHESS_H */ diff --git a/src/temp-migration-bitboard/chessdefs.h b/src/temp-migration-bitboard/chessdefs.h new file mode 100644 index 0000000..889520e --- /dev/null +++ b/src/temp-migration-bitboard/chessdefs.h @@ -0,0 +1,129 @@ +/* chessdefs.h - generic chess definitions. + * + * Copyright (C) 2021 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#ifndef CHESSDEFS_H +#define CHESSDEFS_H + +#include "br.h" + +/* piece_t bits structure + * MSB 8 7 6 5 4 3 2 1 LSB + * 1: color (0 for white) + * 2-7: bit set for pawn (2), knight, bishop, rook, queen, king (7) + */ +typedef u8 piece_t; + +enum { + E_EMPTY = 0, + E_COLOR, /* LSB */ + E_PAWN, + E_KNIGHT, + E_BISHOP, + E_ROOK, + E_QUEEN, + E_KING, +}; + +/* pos_t bitboards tables + */ +enum { + BB_ALL = 0, /* OR of all bitboards */ + BB_UNUSED, /* future use ? */ + BB_PAWN = E_PAWN, + BB_KNIGHT, + BB_BISHOP, + BB_ROOK, + BB_QUEEN, + BB_KING, + BB_END +}; + +/* piece bitmask in piece_t + */ +enum { + EMPTY = 0, + PAWN = 1 << (E_PAWN - 1), /* 1<<(2-1) = 0x02 00000010 */ + KNIGHT = 1 << (E_KNIGHT - 1), /* 0x04 00000100 */ + BISHOP = 1 << (E_BISHOP - 1), /* 0x08 00001000 */ + ROOK = 1 << (E_ROOK - 1), /* 0x10 00010000 */ + QUEEN = 1 << (E_QUEEN - 1), /* 0x20 00100000 */ + KING = 1 << (E_KING - 1), /* 0x40 01000000 */ +}; + +#define PIECETOBB(p) (ffs64(PIECE(p))) /* from piece_t to bb piece array */ + +#define WHITE 0 /* 0x00 00000000 */ +#define BLACK 1 /* 0x01 00000001 */ +#define OPPONENT(p) !(p) + +#define MASK_COLOR 0x01 /* 00000001 */ +#define MASK_PIECE 0x7E /* 01111110 */ + +#define COLOR(p) ((p) & MASK_COLOR) /* bitmask */ +#define PIECE(p) ((p) & MASK_PIECE) +#define E_PIECE(p) (ffs64(PIECE(p))) /* convert mask to E_XX */ + +#define IS_WHITE(p) (!COLOR(p)) +#define IS_BLACK(p) (COLOR(p)) + +#define SET_WHITE(p) ((p) &= ~MASK_COLOR) +#define SET_BLACK(p) ((p) |= MASK_COLOR) +#define SET_COLOR(p, c) (!(c)? SET_WHITE(p): SET_BLACK(p)) + +/* flip a 0-63 square: + * Vertical: G8 (62) becomes G1 (6) + * Horizontal: G8 (62) becomes B8 (57) + */ +#define FLIP_V(sq) ((sq) ^ 56) +#define FLIP_H(sq) ((sq) ^ 7) +/* square_t bits structure : rrrrffff + * ffff: file + * rrrr: rank + */ +typedef uchar square_t; + +/* castle_t bits structure + */ +typedef unsigned char castle_t; + +#define CASTLE_WK (1 << 0) /* 0x01 00000001 */ +#define CASTLE_WQ (1 << 1) /* 0x02 00000010 */ +#define CASTLE_BK (1 << 2) /* 0x04 00000100 */ +#define CASTLE_BQ (1 << 3) /* 0x08 00001000 */ + +#define CASTLE_W (CASTLE_WK | CASTLE_WQ) /* 00000011 W castle mask */ +#define CASTLE_B (CASTLE_BK | CASTLE_BQ) /* 00001100 B castle mask */ + +/* game phases + */ +#define OPENING 0 +#define MIDDLEGAME 1 +#define ENDGAME 2 + +/* bitboard + */ +typedef u64 bitboard_t; + + +/* eval type + */ +typedef s32 eval_t; + +/* forward typedefs + */ +typedef struct piece_list_s piece_list_t; +typedef struct board_s board_t; +typedef struct pos_s pos_t; +typedef struct move_s move_t; + +#endif diff --git a/src/temp-migration-bitboard/eval-simple.c b/src/temp-migration-bitboard/eval-simple.c new file mode 100644 index 0000000..a56d599 --- /dev/null +++ b/src/temp-migration-bitboard/eval-simple.c @@ -0,0 +1,199 @@ +/* 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#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 + * + * 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]; +} diff --git a/src/temp-migration-bitboard/eval-simple.h b/src/temp-migration-bitboard/eval-simple.h new file mode 100644 index 0000000..3ca92ab --- /dev/null +++ b/src/temp-migration-bitboard/eval-simple.h @@ -0,0 +1,47 @@ +/* eval-simple.h - simple position evaluation. + * + * Copyright (C) 2021 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#ifndef EVAL_SIMPLE_H +#define EVAL_SIMPLE_H + + +#include "chessdefs.h" + +/* no queen on board */ +#define simple_no_queen(p, c) \ + ( !(p)->bb[c][BB_QUEEN] ) + +#define simple_one_queen(p, c) \ + ( popcount64((p)->bb[c][BB_QUEEN]) == 1 ) + +#define simple_no_rook(p, c) \ + (!(p)->bb[c][BB_ROOK]) + +#define simple_one_minor_piece(p, c) \ + (popcount64((p)->bb[c][BB_KNIGHT] | (p)->bb[c][BB_BISHOP]) == 1) + +#define simple_is_endgame(p) \ + ( (simple_no_queen(p, WHITE) || \ + (simple_one_queen(p, WHITE) && \ + simple_no_rook(p, WHITE) && \ + simple_one_minor_piece(p, WHITE))) \ + && \ + (simple_no_queen(p, BLACK) || \ + (simple_one_queen(p, BLACK) && \ + simple_no_rook(p, BLACK) && \ + simple_one_minor_piece(p, BLACK))) ) + +void eval_simple_init(void); +eval_t eval_simple(pos_t *pos); + +#endif /* EVAL_SIMPLE_H */ diff --git a/src/temp-migration-bitboard/eval.c b/src/temp-migration-bitboard/eval.c new file mode 100644 index 0000000..0462bd5 --- /dev/null +++ b/src/temp-migration-bitboard/eval.c @@ -0,0 +1,95 @@ +/* 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include + +#include +#include + +#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; +} diff --git a/src/temp-migration-bitboard/eval.h b/src/temp-migration-bitboard/eval.h new file mode 100644 index 0000000..de16353 --- /dev/null +++ b/src/temp-migration-bitboard/eval.h @@ -0,0 +1,37 @@ +/* eval.h - static position evaluation. + * + * Copyright (C) 2021 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#ifndef EVAL_H +#define EVAL_H + +#include + +#include "chessdefs.h" +#include "piece.h" + +/* max pieces eval is KING_VALUE + 9*QUEEN_VALUE + 2*ROOK_VALUE + 2*BISHOP_VALUE + * + 2*KNIGHT_VALUE which around 30000. + * We are on secure side with -50000/+50000 + */ +#define EVAL_MAX (50000) +#define EVAL_MIN (-EVAL_MAX) +#define EVAL_INVALID INT_MIN +#define EVAL_MATE EVAL_MAX + +eval_t eval_material(pos_t *pos, bool color); +eval_t eval_mobility(pos_t *pos, bool color); +eval_t eval_square_control(pos_t *pos, bool color); + +eval_t eval(pos_t *pos); + +#endif /* EVAL_H */ diff --git a/src/temp-migration-bitboard/fen.c b/src/temp-migration-bitboard/fen.c new file mode 100644 index 0000000..86d3206 --- /dev/null +++ b/src/temp-migration-bitboard/fen.c @@ -0,0 +1,175 @@ +/* fen.c - fen notation. + * + * Copyright (C) 2021 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include +#include +#include +#include +#include + +#include + +#include "chessdefs.h" +#include "position.h" +#include "board.h" +#include "fen.h" +#include "piece.h" + +/* Starting Position : + * rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1 + * After 1.e4 : + * rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1 + * After 1... c5 : + * rnbqkbnr/pp1ppppp/8/2p5/4P3/8/PPPP1PPP/RNBQKBNR w KQkq c6 0 2 + * After 2. Nf3: + * rnbqkbnr/pp1ppppp/8/2p5/4P3/5N2/PPPP1PPP/RNBQKB1R b KQkq - 1 2 + * + * 1 : White uppercase + * 2 : next move (w or b) + * 3 : Castling capabilities: "-" if none, KQ/kq if white/black can castle + * on K or Q side + * 4 : en-passant: if pawn just moved 2 squares, indicate target square (e.g. + * for e2-e4 this field is e3) + * 5 : half moves since last capture or pawn advance (for 50 moves rule) + * 6 : full moves, starts at 1, increments after black move + * + */ + +// warning, we expect a valid fen input +pos_t *fen2pos(pos_t *pos, char *fen) +{ + char *p = fen; + short rank, file, skip, color, bbpiece; + piece_t piece; + board_t *board = pos->board; +# define SKIP_BLANK(p) for(;*(p) == ' '; (p)++) + + pos_clear(pos); + /* 1) get piece placement information + */ + for (rank = 7, file = 0; *p && *p != ' '; ++p) { + color = isupper(*p)? WHITE: BLACK; + char cp = toupper(*p); + switch (cp) { + case CHAR_PAWN: + bbpiece = BB_PAWN; + piece = PAWN; + goto set_square; + case CHAR_KNIGHT: + bbpiece = BB_KNIGHT; + piece = KNIGHT; + goto set_square; + case CHAR_BISHOP: + bbpiece = BB_BISHOP; + piece = BISHOP; + goto set_square; + case CHAR_ROOK: + bbpiece = BB_ROOK; + piece = ROOK; + goto set_square; + case CHAR_QUEEN: + bbpiece = BB_QUEEN; + piece = QUEEN; + goto set_square; + case CHAR_KING: + bbpiece = BB_KING; + piece = KING; + //pos->bb[color][BB_KING] = BB(file, rank); + //goto set_square; + set_square: +# ifdef DEBUG_FEN + log_i(5, "f=%d r=%d *p=%c piece=%c color=%d\n", + file, rank, *p, cp, color); +# endif + pos->bb[color][bbpiece] |= BB(file, rank); + pos->occupied[color] |= BB(file, rank); + SET_COLOR(piece, color); + board[SQ88(file, rank)].piece = piece; + board[SQ88(file, rank)].s_piece = + piece_add(pos, piece, SQ88(file, rank)); + file++; + break; + case '/': + rank--; + file = 0; + break; + default: + skip = cp - '0'; + while (skip--) { + board[SQ88(file++, rank)].piece = EMPTY; + } + } + } +# ifdef DEBUG_FEN + for (rank = 7; rank >= 0; --rank) { + for (file = 0; file < 8; ++file) { + log(5, "%02x ", board[SQ88(file, rank)].piece); + } + log(5, "\n"); + } +# endif + + /* 2) next move color + */ + SKIP_BLANK(p); + SET_COLOR(pos->turn, *p == 'w' ? WHITE : BLACK); + p++; + + /* 3) castle status + */ + SKIP_BLANK(p); + pos->castle = 0; + if (*p != '-') { + for (; *p && *p != ' '; ++p) { + switch (*p) { + case 'K': + pos->castle |= CASTLE_WK; + break; + case 'k': + pos->castle |= CASTLE_BK; + break; + case 'Q': + pos->castle |= CASTLE_WQ; + break; + case 'q': + pos->castle |= CASTLE_BQ; + break; + } + } + } + p++; + + /* 4) en passant + */ + SKIP_BLANK(p); + pos->en_passant = 0; + if (*p != '-') { + //SET_F(pos->en_passant, C2FILE(*p++)); + //SET_R(pos->en_passant, C2RANK(*p++)); + pos->en_passant = SQ88(C2FILE(*p), C2RANK(*(p+1))); + pos += 2; + } else { + p++; + } + + /* 5) half moves since last capture or pawn move and + * 6) current move number + */ + SKIP_BLANK(p); + //log_i(5, "pos=%d\n", (int)(p-fen)); + sscanf(p, "%hd %hd", &pos->clock_50, &pos->curmove); +# ifdef DEBUG_FEN + log_i(5, "50 rule=%d current move=%d\n", pos->clock_50, pos->curmove); +# endif + return pos; +} diff --git a/src/temp-migration-bitboard/fen.h b/src/temp-migration-bitboard/fen.h new file mode 100644 index 0000000..a57b5a7 --- /dev/null +++ b/src/temp-migration-bitboard/fen.h @@ -0,0 +1,21 @@ +/* fen.h - fen notation. + * + * Copyright (C) 2021 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#ifndef FEN_H +#define FEN_H + +#include "position.h" + +pos_t *fen2pos(pos_t *pos, char *fen); + +#endif /* FEN_H */ diff --git a/src/temp-migration-bitboard/move.c b/src/temp-migration-bitboard/move.c new file mode 100644 index 0000000..7f1d23e --- /dev/null +++ b/src/temp-migration-bitboard/move.c @@ -0,0 +1,890 @@ +/* move.c - move management. + * + * Copyright (C) 2021 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include +#include + +#include +#include +#include +#include + +#include "chessdefs.h" +#include "board.h" +#include "bitboard.h" +#include "piece.h" +#include "move.h" +#include "eval.h" +#include "eval-simple.h" + +static pool_t *moves_pool; + +static struct vector { + unsigned char ndirs; + char slide; + char dir[8]; +} vectors[] = { + [KNIGHT] = { 8, 0, { -33, -31, -18, -14, 14, 18, 31, 33 }}, + [BISHOP] = { 4, 1, { -15, -17, 15, 17 }}, + [ROOK] = { 4, 1, { -1, -16, 1, 16 }}, + [QUEEN] = { 8, 1, { -1, -16, 1, 16, -15, -17, 15, 17 }}, + [KING] = { 8, 0, { -1, -16, 1, 16, -15, -17, 15, 17 }} +}; + + +/* squares needed to be empty & not controlled by opponent for castle. + * For black castle, same values 7 rows higher (>> 7*8) + */ +static struct can_castle { + bitboard_t controlled[2]; + bitboard_t occupied[2]; +} castle_squares[2] = { + /* Queen side King side Queen side King side */ + { { C1bb|D1bb|E1bb, E1bb|F1bb|G1bb }, { B1bb|C1bb|D1bb, F1bb|G1bb } }, + { { C8bb|D8bb|E8bb, E8bb|F8bb|G8bb }, { B8bb|C8bb|D8bb, F8bb|G8bb } } +}; + +pool_t *moves_pool_init() +{ + if (!moves_pool) + moves_pool = pool_create("moves", 128, sizeof(move_t)); + return moves_pool; +} + +void moves_pool_stats() +{ + if (moves_pool) + pool_stats(moves_pool); +} + +/** + * move_print() - print a move + * @movenum: move number + * @move: &move to display + * @flags: options to display + * + * Possible flags are: + * M_PR_CAPT: print move if capture + * M_PR_NCAPT: print move if non capture + * M_PR_NUM: print also move number + * M_PR_LONG: print long notation + * M_PR_NL: print a newline after move + * M_PR_EVAL: print move eval + * + * @return: 0 if nothing printed, 1 otherwise + */ +int move_print(int movenum, move_t *move, move_flags_t flags) +{ + if ((flags & M_PR_CAPT) && !(move->flags & M_CAPTURE)) { +# ifdef DEBUG_MOVE + log_i(9, "skipping capture & %#04x\n", move->flags); +# endif + return 0; + } + if ((flags & M_PR_NCAPT) && (move->flags & M_CAPTURE)) { +# ifdef DEBUG_MOVE + log_i(9, "skipping !capture & %#04x\n", move->flags); +# endif + return 0; + } + if (flags & M_PR_NUM) + log(1, "%d:", movenum); + if (move->flags & M_CASTLE_K) { + log(1, "O-O"); + goto end; + } else if (move->flags & M_CASTLE_Q) { + log(1, "O-O-O"); + goto end; + } else { + log(1, "%s%c%c", P_SYM(move->piece), + FILE2C(F88(move->from)), + RANK2C(R88(move->from))); + if (move->flags & M_CAPTURE) { + log(1, "x"); + if (flags & M_PR_LONG) + log(1, "%s", P_SYM(move->capture)); + } else { + log(1, "-"); + } + log(1, "%c%c", + FILE2C(F88(move->to)), + RANK2C(R88(move->to))); + if (flags & M_PR_LONG && move->flags & M_EN_PASSANT) + log(1, "e.p."); + if (move->promotion) + log(1, "=%s", P_SYM(move->promotion)); + if (flags & M_PR_EVAL) + log(1, "[ev:%d] ", move->eval); + end: + log(1, " "); + } + if (flags & M_PR_NL) + log(1, "\n"); + return 1; +} + +void moves_print(pos_t *pos, move_flags_t flags) +{ + struct list_head *p_cur, *tmp; + move_t *move; + int movenum; + + for (int color=WHITE; color <= BLACK; ++color) { + int verif = 0; + log(1, "%s pseudo-moves:\n\t", color == WHITE? "White": "Black"); + if (! (flags & M_PR_SEPARATE)) { + movenum = 1; + list_for_each_safe(p_cur, tmp, &pos->moves[color]) { + move = list_entry(p_cur, move_t, list); + verif += move_print(movenum++, move, flags); + } + } else { + log(1, "captures: "); + movenum = 1; + list_for_each_safe(p_cur, tmp, &pos->moves[color]) { + move = list_entry(p_cur, move_t, list); + verif += move_print(movenum++, move, flags | M_PR_CAPT); + } + movenum = 1; + log(1, "\n\tothers : "); + list_for_each_safe(p_cur, tmp, &pos->moves[color]) { + move = list_entry(p_cur, move_t, list); + verif += move_print(movenum++, move, flags | M_PR_NCAPT); + } + } + log(1, "\n\tTotal moves = %d mobility=%u\n", verif, pos->mobility[color]); + } +} + +static move_t *move_add(pos_t *pos, piece_t piece, square_t from, + square_t to) +{ + board_t *board = pos->board; + move_t *move; + int color = COLOR(pos->board[from].piece); + +# ifdef DEBUG_MOVE + log_i(3, "piece_color=%d turn=%d from=%c%c to=%c%c\n", + color, pos->turn, + FILE2C(F88(from)), + RANK2C(R88(from)), + FILE2C(F88(to)), + RANK2C(R88(to))); +# endif + /* invalid position if opponent king is attacked + */ + if (board[to].piece & KING) { +# ifdef DEBUG_MOVE + log_i(2, "invalid position: opponent king [%c%c] is in check.\n", + FILE2C(F88(to)), RANK2C(R88(to))); +# endif + return NULL; + } + if (!(move = pool_get(moves_pool))) + return NULL; + list_add(&move->list, &pos->moves[color]); + + move->piece = piece | color; + move->from = from; + move->to = to; + move->capture = board[to].piece; + if (PIECE(move->capture) == KING) + pos->check[color]++; + + move->flags = M_NORMAL; + if (move->capture) + move->flags |= M_CAPTURE; + move->pos = NULL; +# ifdef DEBUG_MOVE + log_i(3, "added %s %s move from %c%c to %c%c\n", + COLOR(move->piece)? "black": "white", + P_NAME(PIECE(move->piece)), + FILE2C(F88(move->from)), RANK2C(R88(move->from)), + FILE2C(F88(move->to)), RANK2C(R88(move->to))); +# endif + return move; +} + +/** + * move_del() - delete a move from list. + * @ptr: move &list_head + * + * Remove the move whose 'list' element address is @ptr. + */ +void move_del(struct list_head *ptr) +{ + move_t *move = list_entry(ptr, move_t, list); + +# ifdef DEBUG_MOVE + log_i(3, "delete move from %c%c to %c%c\n", + FILE2C(F88(move->from)), RANK2C(R88(move->from)), + FILE2C(F88(move->to)), RANK2C(R88(move->to))); +# endif + + if (move->pos) + pos_del(move->pos); + list_del(ptr); + pool_add(moves_pool, move); + return; +} + +/** + * move_del() - delete all position moves. + * @ppos: &position. + * + * Remove all generated moves from @pos structure. + */ +int moves_del(pos_t *pos) +{ + struct list_head *p_cur, *tmp, *head; + int count = 0; + + for (int color = WHITE; color <= BLACK; ++color) { + head = &pos->moves[color]; + + list_for_each_safe(p_cur, tmp, head) { + move_del(p_cur); + count++; + } + } +# ifdef DEBUG_PIECE + log_f(3, "%d moves removed\n", count); +# endif + return count; +} + +/* TODO: return nmoves */ +static move_t *move_pawn_add(pos_t *pos, piece_t piece, square_t from, + square_t to, unsigned char rank7) +{ + move_t *move; + piece_t promote; + unsigned char color = COLOR(piece); + + if (R88(from) == rank7) { /* promotion */ + for (promote = QUEEN; promote > PAWN; promote >>= 1) { + if ((move = move_add(pos, piece, from, to))) { + move->flags |= M_PROMOTION; + move->promotion = promote | color; + } + } + } else { + move = move_add(pos, piece, from, to); + } + return move; +} + +/** + * pseudo_moves_pawn() - generate moves for pawn. + * @pos: &position + * @ppiece: &piece_list pawn structure pointer + * @doit: add move to moves list + * + * Calculate all possible moves for @ppiece pawn. + * If @doit is true, add moves to @pos' moves list. + */ +int pseudo_moves_pawn(pos_t *pos, piece_list_t *ppiece, bool doit) +{ + piece_t piece = PIECE(ppiece->piece); + unsigned char color = COLOR(ppiece->piece); + square_t square = ppiece->square, new; + board_t *board = pos->board; + unsigned char rank2, rank7, rank5; + move_t *move = NULL; + char dir; + int count = 0; + + /* setup direction */ + if (IS_WHITE(color)) { + dir = 1; + rank2 = 1; + rank7 = 6; + rank5 = 4; + } else { + dir = -1; + rank2 = 6; + rank7 = 1; + rank5 = 3; + } + +# ifdef DEBUG_MOVE + log_f(2, "pos:%p turn:%s piece:%d [%s %s] dir:%d at %#04x[%c%c]\n", + pos, + IS_WHITE(pos->turn)? "white": "black", + piece, + IS_WHITE(color)? "white": "black", + P_NAME(piece), + dir, + square, + FILE2C(F88(square)), RANK2C(R88(square))); +# endif + + /* normal push. We do not test for valid destination square here, + * assuming position is valid. Is that correct ? + */ + new = square + dir * 16; + if (!board[new].piece) { +# ifdef DEBUG_MOVE + log_i(4, "pushing pawn %#04x\n", square); +# endif + pos->mobility[color]++; + count++; + if (doit) + move_pawn_add(pos, piece | color, square, new, rank7); + /* push 2 squares */ + log(4, "R88(%#x)=%d R2=%d \n", square, R88(square), rank2); + if (R88(square) == rank2) { + new += dir * 16; + if (SQ88_OK(new) && !board[new].piece) { +# ifdef DEBUG_MOVE + log_i(4, "pushing pawn %#04x 2 squares\n", square); +# endif + //log_f(2, "pawn move2 mobility\n"); + pos->mobility[color]++; + count++; + if (doit) + move_pawn_add(pos, piece | color, square, new, rank7); + } + } + } + + /* en passant - not accounted for mobility. Correct ? */ + if (pos->en_passant && R88(square) == rank5) { + unsigned char ep_file = F88(pos->en_passant); + unsigned char sq_file = F88(square); + +# ifdef DEBUG_MOVE + log_i(4, "possible en passant on rank %#x (current = %#0x)\n", ep_file, + sq_file); +# endif + if (sq_file == ep_file - 1 || sq_file == ep_file + 1) { + square_t t_square = SQ88(ep_file, rank5); /* taken pawn square */ + piece_t captured = board[t_square].piece; + move = move_pawn_add(pos, piece | color , square, pos->en_passant, rank7); + move->flags |= M_EN_PASSANT | M_CAPTURE; + move->capture = captured; + pos->mobility[color]++; + count++; + } + + } + + /* capture */ + int two=0; + for (new = square + dir * 15; two < 2; new = square + dir * 17, two++) { +# ifdef DEBUG_MOVE + log_i(4, "pawn capture %#04x %#04x\n", square, new); +# endif + if (SQ88_NOK(new)) + continue; + pos->controlled[color] |= SQ88_2_BB(new); + if (board[new].piece && COLOR(board[new].piece) != color) { + if (PIECE(board[new].piece) == KING) + pos->check[color]++; + //log_f(2, "pawn capture mobility\n"); + pos->mobility[color]++; + count++; + if (doit) + move_pawn_add(pos, piece | color, square, new, rank7); + } + } +# ifdef DEBUG_MOVE + log_f(2, "pos:%p turn:%s piece:%d [%s %s] dir:%d at %#04x[%c%c] count=%d\n", + pos, + IS_WHITE(pos->turn)? "white": "black", + piece, + IS_WHITE(color)? "white": "black", + P_NAME(piece), + dir, + square, + FILE2C(F88(square)), RANK2C(R88(square)), count); +# endif + return count; +} + +/** + * pseudo_moves_castle() - generate castle moves. + * @pos: &position + * @color: side for which to generate moves + * @doit: add move to moves list + * @do_king: count king moves in mobility + * + * Calculate the possible castle moves for @color side. + * If @doit is true, add moves to @pos' moves list. + * If @do_king is true, account king moves (incl. castle) to mobility. + * + * @return: The number of possible king moves. + */ +int pseudo_moves_castle(pos_t *pos, bool color, bool doit, bool do_king) +{ + board_t *board = pos->board; + unsigned char rank1, castle_K, castle_Q; + move_t *move = NULL; + unsigned short count=0; + struct can_castle *can_castle; + bitboard_t controlled; + bitboard_t occupied = pos->occupied[WHITE] | pos->occupied[BLACK]; + //pos_t *newpos; + +# ifdef DEBUG_MOVE + log_f(2, "pos:%p turn:%s color:%s\n", + pos, + IS_WHITE(pos->turn)? "white": "black", + IS_WHITE(color)? "white": "black"); +# endif + + if (IS_WHITE(color)) { + rank1 = 0; + castle_K = pos->castle & CASTLE_WK; + castle_Q = pos->castle & CASTLE_WQ; + can_castle = castle_squares+WHITE; + controlled = pos->controlled[BLACK]; + } else { + rank1 = 7; + castle_K = pos->castle & CASTLE_BK; + castle_Q = pos->castle & CASTLE_BQ; + can_castle = castle_squares+BLACK; + controlled = pos->controlled[WHITE]; + } + if (castle_K) { + if (occupied & can_castle->occupied[1]) { +# ifdef DEBUG_MOVE + log(5, "Cannot castle K side: occupied\n"); +# endif + goto next; + } + if (controlled & can_castle->controlled[1]) { +# ifdef DEBUG_MOVE + log(5, "Cannot castle K side: controlled\n"); +# endif + goto next; + } + if (do_king) { + pos->mobility[color]++; + count++; + } + if (doit) { + move = move_add(pos, board[SQ88(4, rank1)].piece, + SQ88(4, rank1), SQ88(6, rank1)); + if (move) + move->flags |= M_CASTLE_K; + } + } + +next: + if (castle_Q) { + if (occupied & can_castle->occupied[0]) { +# ifdef DEBUG_MOVE + log(5, "Cannot castle Q side: occupied\n"); +# endif + goto end; + } + if (controlled & can_castle->controlled[0]) { +# ifdef DEBUG_MOVE + log(5, "Cannot castle Q side: controlled\n"); +# endif + goto end; + } + if (do_king) { + pos->mobility[color]++; + count++; + } + if (doit) { + move = move_add(pos, board[SQ88(4, rank1)].piece, + SQ88(4, rank1), SQ88(2, rank1)); + if (move) + move->flags |= M_CASTLE_Q; + } + } +end: + return count; +} + +/** + * pseudo_moves_gen() - general move generation for non pawn pieces + * @pos: &position + * @ppiece: &piece_list structure pointer + * @doit: add move to moves list + * @do_king: count king moves + * + * Calculate all possible moves for @ppiece. + * If @doit is true, add moves to @pos' moves list. + * If @do_king is true, account king moves (incl. castle) to mobility. + */ +int pseudo_moves_gen(pos_t *pos, piece_list_t *ppiece, bool doit, bool do_king) +{ + piece_t piece = PIECE(ppiece->piece); + unsigned char color = COLOR(ppiece->piece); + struct vector *vector = vectors+piece; + square_t square = ppiece->square; + unsigned char ndirs = vector->ndirs; + char slide = vector->slide; + board_t *board = pos->board; + //move_t *move; + int count = 0; + u64 bb_new; + +# ifdef DEBUG_MOVE + log_f(2, "pos:%p turn:%s piece:%d [%s %s] at %#04x[%c%c]\n", + pos, + IS_WHITE(pos->turn)? "white": "black", + piece, + IS_WHITE(color)? "white": "black", + P_NAME(piece), + square, + FILE2C(F88(square)), RANK2C(R88(square))); + log_i(5, "vector=%ld ndirs=%d slide=%d\n", vector-vectors, ndirs, slide); +# endif + + for (int curdir = 0; curdir < ndirs; ++curdir) { + char dir = vector->dir[curdir]; + for (square_t new = square + dir; ; new = new + dir) { + /* outside board */ + if (SQ88_NOK(new)) { +# ifdef DEBUG_MOVE + log_i(4,"skipping %04x (invalid square)\n", new); +# endif + break; + } + bb_new = SQ88_2_BB(new); +# ifdef DEBUG_MOVE + log_i(2, "trying %#x=%c%c bb=%#lx\n", + new, FILE2C(F88(new)), RANK2C(R88(new)), + bb_new); + //bitboard_print(new_bitboard); +# endif + + pos->controlled[color] |= bb_new;; + + /* king: do not move to opponent controlled square */ + if (piece == KING && pos->controlled[OPPONENT(color)] & bb_new) { +# ifdef DEBUG_MOVE + log_i(2, "%s king cannot move to %c%c\n", + IS_WHITE(color)? "white": "black", + FILE2C(F88(new)), RANK2C(R88(new))); +# endif + break; + } + + if (bb_new & pos->occupied[color]) { + //bitboard_print(pos->occupied[color]); + //bitboard_print(pos->occupied[OPPONENT(color)]); +# ifdef DEBUG_MOVE + log_i(2, "BB: skipping %#lx [%c%c] (same color piece)\n", + bb_new, FILE2C(F88(new)), RANK2C(R88(new))); +# endif + break; + } + + /* we are sure the move is valid : we create move */ + if (piece != KING || do_king) { + pos->mobility[color]++; + count++; + } + if (doit) + move_add(pos, ppiece->piece, square, new); + if (board[new].piece) { /* stopper move */ + break; + } + if (!slide) + break; + } + } +# ifdef DEBUG_MOVE + log_f(2, "pos:%p turn:%s piece:%d [%s %s] at %#04x[%c%c] count=%d\n", + pos, + IS_WHITE(pos->turn)? "white": "black", + piece, + IS_WHITE(color)? "white": "black", + P_NAME(piece), + square, + FILE2C(F88(square)), RANK2C(R88(square)), count); +# endif + return count; +} + +/** + * moves_gen() - move generation for one color + * @pos: &position + * @color: side + * @doit: add move to moves list + * @do_king: count king moves + * + * Calculate all possible moves for @color. + * If @doit is true, add moves to @pos' moves list. + * If @do_king is true, account king moves (incl. castle) to mobility. + */ +int moves_gen(pos_t *pos, bool color, bool doit, bool do_king) +{ + struct list_head *p_cur, *tmp, *piece_list; + piece_list_t *piece; + int count = 0; + +# ifdef DEBUG_MOVE + log_f(2, "color:%s doit:%d\n", color? "Black": "White", doit); +# endif + + /* do not generate moves if already done for color */ + if (!list_empty(&pos->moves[color])) + doit = false; + + piece_list = &pos->pieces[color]; + pos->mobility[color] = 0; + pos->controlled[color] = 0; + count += pseudo_moves_castle(pos, color, doit, do_king); + list_for_each_safe(p_cur, tmp, piece_list) { + piece = list_entry(p_cur, piece_list_t, list); + if (PIECE(piece->piece) != PAWN) + count += pseudo_moves_gen(pos, piece, doit, do_king); + else + count += pseudo_moves_pawn(pos, piece, doit); + + count++; + } + return count; +} + +/** + * moves_gen_king_moves() - adjust king mobility + * @pos: &position + * @color: king color + * @doit: add move to moves list + * + * Compute the number of king moves (incl. castle), after opponent controlled + * are known. + * If @doit is true, add moves to @pos' moves list. + * + * @return: The number of possible king moves. + */ +int moves_gen_king_moves(pos_t *pos, bool color, bool doit) +{ + int count = 0; + piece_list_t *king = list_first_entry(&pos->pieces[color], piece_list_t, list); + count = pseudo_moves_castle(pos, king, doit, true); + count += pseudo_moves_gen(pos, king, doit, true); + return count; +} + +static int moves_cmp_eval(__unused void *data, const struct list_head *h1, const struct list_head *h2) +{ + move_t *m1 = list_entry(h1, move_t, list); + move_t *m2 = list_entry(h2, move_t, list); + return m2->eval_simple - m1->eval_simple; +} + +/** + * moves_sort() sort - sort moves list, best eval first. + * @pos: &position. + */ +void moves_sort(pos_t *pos) +{ + list_sort(NULL, &pos->moves[pos->turn], moves_cmp_eval); +} + +/** + * moves_gen_all_eval_sort() - calculate/generate/sort moves for side to play. + * @pos: &position + * + * Generate positions for each move for player to move. + * For each of them generate opponents moves, calculate eval, and sort the moves list. + */ +void moves_gen_eval_sort(pos_t *pos) +{ + move_t *move; + pos_t *newpos; + + moves_gen_all(pos); + + list_for_each_entry(move, &pos->moves[pos->turn], list) { + newpos = move_do(pos, move); + move->pos = newpos; + //move_print(0, move, 0); + move->eval_simple = eval_simple(newpos); + newpos->eval_simple = move->eval_simple; + } + moves_sort(pos); + //moves_print(pos, 0); +} + +/** + * moves_gen_all() - calculate all moves, and generate moves for side to play. + * @pos: &position + * + * Compute pseudo moves for both sides, and generate moves for player to move. + */ +void moves_gen_all(pos_t *pos) +{ + //log_f(1, "turn=%d opponent=%d\n", pos->turn, OPPONENT(pos->turn)); + if (!pos->moves_generated) { + if (!pos->moves_counted) {} + moves_gen(pos, OPPONENT(pos->turn), false, false); + moves_gen(pos, pos->turn, true, true); + if (!pos->moves_counted) + moves_gen_king_moves(pos, OPPONENT(pos->turn), false); + pos->moves_counted = true; + pos->moves_generated = true; + } +} + +/** + * moves_gen_all_nomoves() - calculate number of moves for each player. + * @pos: &position + */ +void moves_gen_all_nomoves(pos_t *pos) +{ + //log_f(1, "turn=%d opponent=%d\n", pos->turn, OPPONENT(pos->turn)); + if (!pos->moves_counted) { + moves_gen(pos, OPPONENT(pos->turn), false, false); + moves_gen(pos, pos->turn, false, true); + moves_gen_king_moves(pos, OPPONENT(pos->turn), false); + pos->moves_counted = true; + } +} + +/** + * move_do() - execute move in a duplicated position. + * @pos: &pos_t struct on which move will be applied + * @move: &move_t struct to apply + * + * @return: &new position + */ +pos_t *move_do(pos_t *pos, move_t *move) +{ +# ifdef DEBUG_MOVE + //log(1, "new move: "); + //move_print(0, move, M_PR_NL | M_PR_LONG); +# endif + + pos_t *new = pos_dup(pos); + piece_t piece = PIECE(move->piece), newpiece = piece, captured = move->capture; + int color = COLOR(move->piece); + square_t from = move->from, to = move->to; + u64 bb_from = SQ88_2_BB(from), bb_to = SQ88_2_BB(to); + + if (move->capture || piece == PAWN) /* 50 moves */ + new->clock_50 = 0; + else + new->clock_50++; + + if (move->flags & M_CAPTURE) { /* capture */ + if (move->flags & M_EN_PASSANT) { + uchar ep_file = F88(pos->en_passant); + square_t ep_grab = color == WHITE ? SQ88(ep_file, 4): SQ88(ep_file, 3); + u64 bb_ep_grab = SQ88_2_BB(ep_grab); + + log_f(5, "en-passant=%d,%d\n", ep_file, color == WHITE ? 4 : 3); + piece_del(&new->board[ep_grab].s_piece->list); + new->board[ep_grab].piece = 0; + new->occupied[OPPONENT(color)] &= ~bb_ep_grab; + new->bb[OPPONENT(color)][BB_PAWN] &= ~bb_ep_grab; + + } else { + piece_del(&new->board[to].s_piece->list); + new->board[to].piece = 0; + new->occupied[OPPONENT(color)] &= ~bb_to; + new->bb[OPPONENT(color)][PIECETOBB(captured)] &= ~bb_to; + } + + } else if (move->flags & M_CASTLE_Q) { + uchar row = R88(from); + square_t rook_from = SQ88(0, row); + square_t rook_to = SQ88(3, row); + u64 bb_rook_from = SQ88_2_BB(rook_from); + u64 bb_rook_to = SQ88_2_BB(rook_to); + + new->board[rook_to] = new->board[rook_from]; + new->board[rook_to].s_piece->square = rook_to; + new->occupied[color] &= ~bb_rook_from; + new->occupied[color] |= bb_rook_to; + new->bb[color][PIECETOBB(BB_ROOK)] &= ~bb_rook_from; + new->bb[color][PIECETOBB(BB_ROOK)] |= bb_rook_to; + new->board[rook_from].piece = 0; + new->board[rook_from].s_piece = NULL; + //new->castle &= color == WHITE? ~CASTLE_W: ~CASTLE_B; + + } else if (move->flags & M_CASTLE_K) { + uchar row = R88(from); + square_t rook_from = SQ88(7, row); + square_t rook_to = SQ88(5, row); + u64 bb_rook_from = SQ88_2_BB(rook_from); + u64 bb_rook_to = SQ88_2_BB(rook_to); + + new->board[rook_to] = new->board[rook_from]; + new->board[rook_to].s_piece->square = rook_to; + new->occupied[color] &= ~bb_rook_from; + new->occupied[color] |= bb_rook_to; + new->bb[color][PIECETOBB(BB_ROOK)] &= ~bb_rook_from; + new->bb[color][PIECETOBB(BB_ROOK)] |= bb_rook_to; + new->board[rook_from].piece = 0; + new->board[rook_from].s_piece = NULL; + // new->castle &= color == WHITE? ~CASTLE_W: ~CASTLE_B; + } + + new->board[to] = new->board[from]; + /* fix dest square */ + new->board[to].s_piece->square = to; + if (move->flags & M_PROMOTION) { + log_f(5, "promotion to %s\n", P_SYM(move->promotion)); + log_f(5, "newpiece=%#x p=%#x\n", move->promotion, PIECE(move->promotion)); + newpiece = PIECE(move->promotion); + new->board[to].piece = move->promotion; + new->board[to].s_piece->piece = move->promotion; + } + /* replace old occupied bitboard by new one */ + new->occupied[color] &= ~bb_from; + new->occupied[color] |= bb_to; + new->bb[color][PIECETOBB(piece)] &= ~bb_from; + new->bb[color][PIECETOBB(newpiece)] |= bb_to; + if (move->flags & M_PROMOTION) { + log_f(5, "promotion color=%d bbpiece=%d\n", color, PIECETOBB(newpiece)); + //bitboard_print(new->bb[color][PIECETOBB(newpiece)]); + } + /* set en_passant */ + new->en_passant = 0; + if (piece == PAWN) { + if (R88(from) == 1 && R88(to) == 3) + pos->en_passant = SQ88(F88(from), 2); + else if (R88(from) == 6 && R88(to) == 4) + pos->en_passant = SQ88(F88(from), 5); + } + + /* always make "from" square empty */ + new->board[from].piece = 0; + new->board[from].s_piece = NULL; + + //printf("old turn=%d ", color); + //printf("new turn=%d\n", new->turn); + //fflush(stdout); + /* adjust castling flags */ + if ((bb_from | bb_to) & E1bb) + new->castle &= ~(CASTLE_WQ | CASTLE_WK); + else if ((bb_from | bb_to) & A1bb) + new->castle &= ~CASTLE_WQ; + else if ((bb_from | bb_to) & H1bb) + new->castle &= ~CASTLE_WK; + + if ((bb_from | bb_to) & E8bb) + new->castle &= ~(CASTLE_BQ | CASTLE_BK); + else if ((bb_from | bb_to) & A8bb) + new->castle &= ~CASTLE_BQ; + else if ((bb_from | bb_to) & H8bb) + new->castle &= ~CASTLE_BK; + + SET_COLOR(new->turn, OPPONENT(color)); /* pos color */ + return new; +} + +void move_undo(pos_t *pos, __unused move_t *move) +{ + pos_del(pos); +} diff --git a/src/temp-migration-bitboard/move.h b/src/temp-migration-bitboard/move.h new file mode 100644 index 0000000..2e706e2 --- /dev/null +++ b/src/temp-migration-bitboard/move.h @@ -0,0 +1,79 @@ +/* move.h - move management. + * + * Copyright (C) 2021 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#ifndef MOVE_H +#define MOVE_H + +#include "chessdefs.h" +#include "position.h" +#include "pool.h" +#include "piece.h" + +/* move flags + */ +typedef unsigned char move_flags_t; +#define M_NORMAL 0x00 +#define M_CHECK 0x01 /* unsure if we know */ +#define M_CAPTURE 0x02 +#define M_EN_PASSANT 0x04 +#define M_PROMOTION 0x08 +#define M_CASTLE_K 0x10 +#define M_CASTLE_Q 0x20 + +/* moves_print flags + */ +#define M_PR_CAPT 0x01 +#define M_PR_NCAPT 0x02 +#define M_PR_NUM 0x04 +#define M_PR_NL 0x08 +#define M_PR_EVAL 0x20 /* separate captures */ +#define M_PR_SEPARATE 0x40 /* separate captures */ +#define M_PR_LONG 0x80 + +typedef struct move_s { + piece_t piece; + square_t from, to; + piece_t capture; /* captured piece */ + piece_t promotion; /* promoted piece */ + move_flags_t flags; + eval_t negamax; + eval_t eval; + eval_t eval_simple; + pos_t *pos; + struct list_head list; /* next move */ +} move_t; + +pool_t *moves_pool_init(); +void moves_pool_stats(); +int move_print(int movenum, move_t *move, move_flags_t flags); +void moves_print(pos_t *move, move_flags_t flags); + +void move_del(struct list_head *ptr); +int moves_del(pos_t *pos); + +int pseudo_moves_castle(pos_t *pos, bool color, bool doit, bool do_king); +int pseudo_moves_gen(pos_t *pos, piece_list_t *piece, bool doit, bool do_king); +int pseudo_moves_pawn(pos_t *pos, piece_list_t *piece, bool doit); +int moves_gen(pos_t *pos, bool color, bool doit, bool do_king); +int moves_gen_king_moves(pos_t *pos, bool color, bool doit); + +void moves_sort(pos_t *pos); +void moves_gen_eval_sort(pos_t *pos); + +void moves_gen_all(pos_t *pos); +void moves_gen_all_nomoves(pos_t *pos); + +pos_t *move_do(pos_t *pos, move_t *move); +void move_undo(pos_t *pos, move_t *move); + +#endif /* MOVE_H */ diff --git a/src/temp-migration-bitboard/piece.c b/src/temp-migration-bitboard/piece.c new file mode 100644 index 0000000..b6e4eeb --- /dev/null +++ b/src/temp-migration-bitboard/piece.c @@ -0,0 +1,118 @@ +/* piece.c - piece list management. + * + * Copyright (C) 2021 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include +#include + +#include +#include +#include + +#include "chessdefs.h" +#include "piece.h" +#include "board.h" +#include "bitboard.h" +#include "position.h" + +static pool_t *pieces_pool; + +struct piece_details piece_details[] = { + [E_EMPTY] = { ' ', ' ', " ", " ", "", 0 }, + [E_PAWN] = { 'P', 'p', "♙", "♟", "Pawn", PAWN_VALUE }, + [E_KNIGHT] = { 'N', 'n', "♘", "♞", "Knight", KNIGHT_VALUE }, + [E_BISHOP] = { 'B', 'b', "♗", "♝", "Bishop", BISHOP_VALUE }, + [E_ROOK] = { 'R', 'r', "♖", "♜", "Rook", ROOK_VALUE }, + [E_QUEEN] = { 'Q', 'q', "♕", "♛", "Queen", QUEEN_VALUE }, + [E_KING] = { 'K', 'k', "♔", "♚", "King", KING_VALUE } +}; + +void piece_list_print(struct list_head *list) +{ + struct list_head *p_cur, *tmp; + piece_list_t *piece; + + list_for_each_safe(p_cur, tmp, list) { + piece = list_entry(p_cur, piece_list_t, list); + + printf("%s%c%c ", P_SYM(piece->piece), + FILE2C(F88(piece->square)), + RANK2C(R88(piece->square))); + } + printf("\n"); +} + +pool_t *piece_pool_init() +{ + if (!pieces_pool) + pieces_pool = pool_create("pieces", 128, sizeof(piece_list_t)); + return pieces_pool; +} + +void piece_pool_stats() +{ + if (pieces_pool) + pool_stats(pieces_pool); +} + +piece_list_t *piece_add(pos_t *pos, piece_t piece, square_t square) +{ + piece_list_t *new; + short color = COLOR(piece); + +# ifdef DEBUG_PIECE + log_f(3, "piece=%02x square=%02x\n", piece, square); + log_f(5, "Adding %s %s on %c%c\n", color? "Black": "White", + P_NAME(piece), FILE2C(F88(square)), RANK2C(R88(square))); +# endif + if ((new = pool_get(pieces_pool))) { + /* first piece is always king */ + if (PIECE(piece) == KING) + list_add(&new->list, &pos->pieces[color]); + else + list_add_tail(&new->list, &pos->pieces[color]); + new->piece = piece; + new->square = square; + new->castle = 0; + new-> value = piece_details[PIECE(piece)].value; + } + + return new; +} + +void piece_del(struct list_head *ptr) +{ + piece_list_t *piece = list_entry(ptr, piece_list_t, list); +# ifdef DEBUG_PIECE + log_f(3, "piece=%02x square=%02x\n", piece->piece, piece->square); +# endif + list_del(ptr); + pool_add(pieces_pool, piece); + return; +} + +int pieces_del(pos_t *pos, short color) +{ + struct list_head *p_cur, *tmp, *head; + int count = 0; + + head = &pos->pieces[color]; + + list_for_each_safe(p_cur, tmp, head) { + piece_del(p_cur); + count++; + } +# ifdef DEBUG_PIECE + log_f(3, "color=%d removed=%d\n", color, count); +# endif + return count; +} diff --git a/src/temp-migration-bitboard/piece.h b/src/temp-migration-bitboard/piece.h new file mode 100644 index 0000000..48e3462 --- /dev/null +++ b/src/temp-migration-bitboard/piece.h @@ -0,0 +1,71 @@ +/* piece.h - piece definitions. + * + * Copyright (C) 2021 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#ifndef PIECE_H +#define PIECE_H + +#include + +#include "chessdefs.h" +#include "list.h" +#include "pool.h" + +#define PIECE_DEFAULT_VALUE 0 + +/* initial default values */ +#define PAWN_VALUE 100 +#define KNIGHT_VALUE 300 +#define BISHOP_VALUE 300 +#define ROOK_VALUE 500 +#define QUEEN_VALUE 900 +#define KING_VALUE 20000 + +typedef struct piece_list_s { + piece_t piece; + square_t square; + short castle; + s64 value; + struct list_head list; +} piece_list_t; + +/* some default values for pieces + */ +extern struct piece_details { + char abbrev_w; /* used for game notation */ + char abbrev_b; + char *symbol_w; + char *symbol_b; /* used for game notation */ + char *name; + s64 value; +} piece_details[]; + +#define P_NAME(p) piece_details[E_PIECE(p)].name +#define P_LETTER(p) piece_details[E_PIECE(p)].abbrev_w +#define P_SYM(p) piece_details[E_PIECE(p)].symbol_b +#define P_CSHORT(p) (IS_WHITE(p)? piece_details[E_PIECE(p)].abbrev_w: \ + piece_details[E_PIECE(p)].abbrev_b) +#define P_CSYM(p) (IS_WHITE(p)? piece_details[E_PIECE(p)].symbol_w: \ + piece_details[E_PIECE(p)].symbol_b) +#define P_VALUE(p) (piece_details[E_PIECE(p)].value) +/* use short name or symbol - no effect + */ +#define P_USE_UTF 1 + +void piece_list_print(struct list_head *list); +pool_t *piece_pool_init(); +void piece_pool_stats(); +piece_list_t *piece_add(pos_t *pos, piece_t piece, square_t square); +void piece_del(struct list_head *ptr); +int pieces_del(pos_t *pos, short color); + +#endif diff --git a/src/temp-migration-bitboard/position.c b/src/temp-migration-bitboard/position.c new file mode 100644 index 0000000..051d174 --- /dev/null +++ b/src/temp-migration-bitboard/position.c @@ -0,0 +1,323 @@ +/* position.c - position management. + * + * Copyright (C) 2021 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include +#include +#include +#include +#include + +#include "chessdefs.h" +#include "position.h" +#include "move.h" +#include "fen.h" +#include "piece.h" +#include "eval.h" + +static pool_t *pos_pool; + +#define BYTE_PRINT "%c%c%c%c%c%c%c%c" +#define BYTE2BIN(b) ((b) & 0x01 ? '1' : '0'), \ + ((b) & 0x02 ? '1' : '0'), \ + ((b) & 0x04 ? '1' : '0'), \ + ((b) & 0x08 ? '1' : '0'), \ + ((b) & 0x10 ? '1' : '0'), \ + ((b) & 0x20 ? '1' : '0'), \ + ((b) & 0x40 ? '1' : '0'), \ + ((b) & 0x80 ? '1' : '0') + +inline void bitboard_print(bitboard_t bb) +{ + int i; + printf("%#018lx\n", bb); + for (i=56; i>=0; i-=8) + printf("\t"BYTE_PRINT"\n", + BYTE2BIN(bb>>i)); +} + +inline void bitboard_print2(bitboard_t bb1, bitboard_t bb2) +{ + int i; + printf("\tW: %#018lx\tB: %#018lx\n", bb1, bb2); + for (i=56; i>=0; i-=8) + printf("\t"BYTE_PRINT"\t\t"BYTE_PRINT"\n", + BYTE2BIN(bb1>>i), + BYTE2BIN(bb2>>i)); +} + +/** + * pos_pieces_print() - Print position pieces + * @pos: &position + */ +void pos_pieces_print(pos_t *pos) +{ + printf("White pieces (%d): \t", popcount64(pos->occupied[WHITE])); + piece_list_print(&pos->pieces[WHITE]); + printf("Black pieces (%d): \t", popcount64(pos->occupied[BLACK])); + piece_list_print(&pos->pieces[BLACK]); +} + +/** + * pos_bitboards_print() - Print position bitboards + * @pos: &position + */ +void pos_bitboards_print(pos_t *pos) +{ + printf("Bitboards occupied :\n"); + bitboard_print2(pos->occupied[WHITE], pos->occupied[BLACK]); + printf("Bitboards controlled :\n"); + bitboard_print2(pos->controlled[WHITE], pos->controlled[BLACK]); + +} + +/** + * pos_print() - Print position on stdout. + * @pos: &position + */ +void pos_print(pos_t *pos) +{ + int rank, file; + piece_t piece; + board_t *board = pos->board; + piece_list_t *wk = list_first_entry(&pos->pieces[WHITE], piece_list_t, list), + *bk = list_first_entry(&pos->pieces[BLACK], piece_list_t, list); + + + printf(" +---+---+---+---+---+---+---+---+\n"); + for (rank = 7; rank >= 0; --rank) { + printf("%c |", rank + '1'); + for (file = 0; file < 8; ++file) { + piece = board[SQ88(file, rank)].piece; + printf(" %s |", P_CSYM(piece)); + } + printf("\n +---+---+---+---+---+---+---+---+\n"); + } + printf(" A B C D E F G H\n\n"); + printf("Turn: %s.\n", IS_WHITE(pos->turn) ? "white" : "black"); + printf("Kings: W:%c%c B:%c%c\n", + FILE2C(F88(wk->square)), + RANK2C(R88(wk->square)), + FILE2C(F88(bk->square)), + RANK2C(R88(bk->square))); + printf("Possible en-passant: [%#x] ", pos->en_passant); + if (pos->en_passant == 0) + printf("None.\n"); + else + printf("%d %d = %c%c\n", + F88(pos->en_passant), + R88(pos->en_passant), + FILE2C(F88(pos->en_passant)), + RANK2C(R88(pos->en_passant))); + + printf("castle [%#x] : ", pos->castle); + + if (pos->castle & CASTLE_WK) + printf("K"); + if (pos->castle & CASTLE_WQ) + printf("Q"); + if (pos->castle & CASTLE_BK) + printf("k"); + if (pos->castle & CASTLE_BQ) + printf("q"); + + printf("\n50 half-moves-rule = %d\n", pos->clock_50); + printf("Current move = %d\n", pos->curmove); + printf("Squares controlled: W:%d B:%d\n", popcount64(pos->controlled[WHITE]), + popcount64(pos->controlled[BLACK])); + printf("Mobility: W:%u B:%u\n", pos->mobility[WHITE], + pos->mobility[BLACK]); +} + +/** + * pos_check() - extensive position consistenci check. + * @pos: &position + */ +void pos_check(pos_t *pos) +{ + int rank, file; + piece_t piece; + board_t *board = pos->board; + + /* check that board and bitboard reflect same information */ + for (rank = 7; rank >= 0; --rank) { + for (file = 0; file < 8; ++file) { + piece_list_t *ppiece; + printf("checking %c%c ", file+'a', rank+'1'); + + piece = board[SQ88(file, rank)].piece; + ppiece= board[SQ88(file, rank)].s_piece; + printf("piece=%s ", P_CSYM(piece)); + if (ppiece) + printf("ppiece=%s/sq=%#x ", P_CSYM(ppiece->piece), ppiece->square); + switch(PIECE(piece)) { + case PAWN: + printf("pawn" ); + break; + case KNIGHT: + printf("knight "); + break; + case BISHOP: + printf("bishop "); + break; + case ROOK: + printf("rook "); + break; + case QUEEN: + printf("queen "); + break; + case KING: + printf("king "); + break; + } + printf("\n"); + } + } +} + +pos_t *pos_clear(pos_t *pos) +{ + int file, rank; + board_t *board = pos->board; + + for (file = 0; file < 8; ++file) { + for (rank = 0; rank < 8; ++rank) { + /*printf("file = %d rank = %d SQ88 = %#2x = %d addr=%p\n", file, rank, + SQ88(file, rank), SQ88(file, rank), + &board[SQ88(file, rank)].piece); + */ + board[SQ88(file, rank)].piece = EMPTY; + } + } + + SET_WHITE(pos->turn); + pos->node_count = 0; + pos->castle = 0; + pos->clock_50 = 0; + pos->curmove = 0; + pos->eval = 0; + pos->en_passant = 0; + pos->occupied[WHITE] = 0; + pos->occupied[BLACK] = 0; + for (int color=0; color<2; ++color) + for (int piece = BB_ALL; piece < BB_END; ++piece) + pos->bb[color][piece] = 0; + pos->controlled[WHITE] = 0; + pos->controlled[BLACK] = 0; + pos->mobility[WHITE] = 0; + pos->mobility[BLACK] = 0; + pos->moves_generated = false; + pos->moves_counted = false; + /* remove pieces / moves */ + pieces_del(pos, WHITE); + pieces_del(pos, BLACK); + moves_del(pos); + + return pos; +} + +/** + * pos_del() - delete a position. + * @pos: &position. + */ +void pos_del(pos_t *pos) +{ + pieces_del(pos, WHITE); + pieces_del(pos, BLACK); + moves_del(pos); + pool_add(pos_pool, pos); +} + +pos_t *pos_startpos(pos_t *pos) +{ + static char *startfen="rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"; + + return fen2pos(pos, startfen); +} + +pos_t *pos_get() +{ + pos_t *pos = pool_get(pos_pool); + if (pos) { + INIT_LIST_HEAD(&pos->pieces[WHITE]); + INIT_LIST_HEAD(&pos->pieces[BLACK]); + + INIT_LIST_HEAD(&pos->moves[WHITE]); + INIT_LIST_HEAD(&pos->moves[BLACK]); + pos_clear(pos); + } else { + fprintf(stderr, "zobaaa\n"); + } + return pos; +} + +/** + * pos_dup() - duplicate a position. + * @pos: &position to duplicate. + * + * New position is the same as source one (with duplicated pieces list), + * except: + * - moves list is empty + * - bestmove is NULL + * - nodecount is set to zero + * - eval is set to EVAL_INVALID + * - moves_generated ans moves_counted are unset + * - check is set to zero + * + * @return: The new position. + * + * TODO: merge with pos_get - NULL for init, non null for duplicate + */ +pos_t *pos_dup(pos_t *pos) +{ + struct list_head *p_cur, *piece_list; + piece_list_t *oldpiece; + board_t *board; + pos_t *new = pool_get(pos_pool); + + if (new) { + board = new->board; + *new = *pos; + for (int color = 0; color < 2; ++color) { + INIT_LIST_HEAD(&new->pieces[color]); + INIT_LIST_HEAD(&new->moves[color]); + /* duplicate piece list */ + piece_list = &pos->pieces[color]; /* white/black piece list */ + + list_for_each(p_cur, piece_list) { + oldpiece = list_entry(p_cur, piece_list_t, list); + board[oldpiece->square].s_piece = + piece_add(new, oldpiece->piece, oldpiece->square); + } + } + new->bestmove = NULL; + new->node_count = 0; + new->eval = EVAL_INVALID; + new->moves_generated = false; + new->moves_counted = false; + new->check[WHITE] = new->check[BLACK] = 0; + } + return new; +} + +pool_t *pos_pool_init() +{ + if (!pos_pool) + pos_pool = pool_create("positions", 128, sizeof(pos_t)); + return pos_pool; +} + +void pos_pool_stats() +{ + if (pos_pool) + pool_stats(pos_pool); +} diff --git a/src/temp-migration-bitboard/position.h b/src/temp-migration-bitboard/position.h new file mode 100644 index 0000000..d41a0db --- /dev/null +++ b/src/temp-migration-bitboard/position.h @@ -0,0 +1,66 @@ +/* position.h - position management definitions. + * + * Copyright (C) 2021 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#ifndef POSITION_H +#define POSITION_H + +#include + +#include "pool.h" +#include "list.h" +#include "bitops.h" + +#include "board.h" +#include "chessdefs.h" + +typedef struct pos_s { + u64 node_count; /* evaluated nodes */ + piece_t turn; /* we use only color bit */ + castle_t castle; + u16 clock_50; + u16 curmove; + eval_t eval; + int check[2]; + int eval_simple_phase; + eval_t eval_simple; + move_t *bestmove; + bool moves_generated; + bool moves_counted; + board_t board[BOARDSIZE]; + + square_t en_passant; + + bitboard_t bb[2][BB_END]; /* use: pieces[BLACK][BB_PAWN] */ + bitboard_t occupied[2]; /* OR of bb[COLOR][x] */ + bitboard_t controlled[2]; + u16 mobility[2]; + struct list_head pieces[2]; /* pieces list, King is first */ + struct list_head moves[2]; +} pos_t; + +void bitboard_print(bitboard_t bb); +void bitboard_print2(bitboard_t bb1, bitboard_t bb2); +void pos_pieces_print(pos_t *pos); +void pos_bitboards_print(pos_t *pos); +void pos_print(pos_t *pos); +pos_t *pos_clear(pos_t *pos); +void pos_del(pos_t *pos); +pos_t *pos_startpos(pos_t *pos); +pos_t *pos_create(); +pool_t *pos_pool_init(); +void pos_pool_stats(); +pos_t *pos_get(); +pos_t *pos_dup(pos_t *pos); +void pos_check(pos_t *pos); + +#endif /* POSITION_H */ diff --git a/src/temp-migration-bitboard/search.c b/src/temp-migration-bitboard/search.c new file mode 100644 index 0000000..bb0dd78 --- /dev/null +++ b/src/temp-migration-bitboard/search.c @@ -0,0 +1,237 @@ +/* search.c - search good moves. + * + * 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + + +#include +#include +#include "debug.h" + +#include "move.h" +#include "eval.h" +#include "search.h" + +/** + * negamax() - search position negamax. + * @pos: &position to search + * @depth: Wanted depth. + * @color: 1 for white, -1 for black. + * + * Calculate the negamax value of @pos. This is an extensive search, with + * absolutely no cutoff. + * + * @return: The @pos negamax evaluation. + */ +eval_t negamax(pos_t *pos, int depth, int color) +{ + move_t *move; + pos_t *newpos; + eval_t best = EVAL_MIN, score; + + pos->node_count++; + if (depth == 0) { + moves_gen_all_nomoves(pos); + score = eval(pos) * color; + return score; + } + moves_gen_all(pos); + list_for_each_entry(move, &pos->moves[pos->turn], list) { + newpos = move_do(pos, move); + score = -negamax(newpos, depth - 1, -color); + pos->node_count += newpos->node_count; + move->negamax = score; + if (score > best) { + best = score; + pos->bestmove = move; + } + move_undo(newpos, move); + } + return best; +} + + +/** + * pvs() - Principal Variation Search. + * @pos: &position to search + * @depth: wanted depth. + * @alpha: alpha value. + * @beta: beta value. + * @color: 1 for white, -1 for black. + * + * Calculate the PVS value of @pos. + * See https://en.wikipedia.org/wiki/Principal_variation_search + * + * Moves list should be first generated and evaluated/sorted. + * + * @return: The @pos PVS evaluation. + */ +eval_t pvs(pos_t *pos, int depth, int alpha, int beta, int color) +{ + move_t *move; + pos_t *newpos; + eval_t score = EVAL_INVALID; + bool firstchild = true; + + pos->node_count++; + + if (depth == 0) { + //return quiesce(p, alpha, beta); /* leaf node */ + moves_gen_all_nomoves(pos); + score = eval(pos) * color; + log_f(2, "Terminal: depth=%d ", depth); + log_f(2, "score=%d alpha=%d beta=%d\n", score, alpha, beta); + return score; + } + + moves_gen_all(pos); + //moves_print(pos, M_PR_EVAL); + /* do the full search for first child */ + //move = list_first_entry_or_null(&pos->moves[pos->turn], move_t, list); + + list_for_each_entry(move, &pos->moves[pos->turn], list) { + newpos = move_do(pos, move); + log(2, "%.*s", 5 - depth, " "); + if (firstchild) { /* first child */ + score = -pvs(newpos, depth - 1, -beta, -alpha, -color); + log_f(2, "First child depth=%d move=", depth); + //move_print(0, move, 0); + log(2, "score=%d alpha=%d beta=%d\n", score, alpha, beta); + pos->bestmove = move; + } else { + /* search with a null window */ + score = -pvs(newpos, depth - 1, -alpha - 1, -alpha, -color); + log_f(2, "Other child depth=%d move=", depth); + //move_print(0, move, 0); + log_f(2, "score=%d alpha=%d beta=%d ", score, alpha, beta); + /* for fail-soft: if (score > alpha && score < beta) */ + if (score > alpha) { + /* if failed high, do a full re-search */ + log_f(2, "doing full search."); + score = -pvs(newpos, depth - 1, -beta, -alpha, -color); + } + log(2, "\n"); + } + pos->node_count += newpos->node_count; + move_undo(newpos, move); + if (score >= beta) { /* fail-hard hard beta cut-off */ + log(2, "%.*s", 5 - depth, " "); + log_f(2, "depth=%d score=%d alpha=%d beta=%d beta cut-off.\n", + depth, score, alpha, beta); + return beta; + } + if (score > alpha) { + log(2, "%.*s", 5 - depth, " "); + log_f(2, "depth=%d setting new alpha from %d to %d\n", + depth, alpha, score); + alpha = score; + pos->bestmove = move; + } + move->pos = NULL; + move->negamax = score; + firstchild = false; + } + + return alpha; +} + +/* + * int negascout (pos_t *pos, int depth, int alpha, int beta ) + * { /\* compute minimax value of position p *\/ + * move_t *move; + * pos_t *newpos; + * eval_t best = EVAL_MIN, score; + * + * int a, b, t, i; + * + * if (depth == 0) { + * //return quiesce(p, alpha, beta); /\* leaf node *\/ + * moves_gen_all_nomoves(pos); + * score = eval(pos) * color; + * return score; + * } + * moves_gen_all(pos); + * a = alpha; + * b = beta; + * list_for_each_entry(move, &pos->moves[pos->turn], list) { + * log(1, "%.*s", 5 - depth, " "); + * newpos = move_do(pos, move); + * // for ( i = 1; i <= w; i++ ) { + * t = -negascout (newpos, depth - 1, -b, -alpha); + * if ( (t > a) && (t < beta) && (i > 1) ) + * t = -NegaScout ( p_i, -beta, -alpha ); /\* re-search *\/ + * alpha = max( alpha, t ); + * if ( alpha >= beta ) + * return alpha; /\* cut-off *\/ + * b = alpha + 1; /\* set new null window *\/ + * } + * return alpha; + * } + */ + +/* + * int quiesce(pos_t *pos, int alpha, int beta) + * { + * int stand_pat = eval(pos); + * + * if( stand_pat >= beta ) + * return beta; + * if( alpha < stand_pat ) + * alpha = stand_pat; + * + * /\* + * * until( every_capture_has_been_examined ) { + * * MakeCapture(); + * * score = -Quiesce( -beta, -alpha ); + * * TakeBackMove(); + * * + * * if( score >= beta ) + * * return beta; + * * if( score > alpha ) + * * alpha = score; + * * } + * *\/ + * return alpha; + * } + */ + +/** + * ab_negamax() - search position negamax with alpha-beta cutoff. + * @pos: &position to search + * @depth: Wanted depth. + * @color: 1 for white, -1 for black. + * + * Calculate the negamax value of @pos, with alpha-beta pruning. + * + * @return: The @pos negamax evaluation. + */ +/*int ab_negamax(pos_t *pos, int alpha, int beta, int depth) +{ + move_t *move; + pos_t *newpos; + eval_t best = EVAL_MIN, score; + + if(depth == 0) { + //return quiesce( alpha, beta ); + moves_gen_all_nomoves(pos); + score = eval(pos) * color; + return score; + } + for ( all moves) { + score = -alphaBeta( -beta, -alpha, depthleft - 1 ); + if( score >= beta ) + return beta; // fail hard beta-cutoff + if( score > alpha ) + alpha = score; // alpha acts like max in MiniMax + } + return alpha; +} +*/ diff --git a/src/temp-migration-bitboard/search.h b/src/temp-migration-bitboard/search.h new file mode 100644 index 0000000..b76e6c2 --- /dev/null +++ b/src/temp-migration-bitboard/search.h @@ -0,0 +1,22 @@ +/* search.h - search for perfect move. + * + * Copyright (C) 2021 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#ifndef SEARCH_H +#define SEARCH_H + +#include "position.h" + +eval_t negamax(pos_t *pos, int depth, int color); +eval_t pvs(pos_t *pos, int depth, int alpha, int beta, int color); + +#endif /* SEARCH_H */ diff --git a/src/util.c b/src/util.c new file mode 100644 index 0000000..6751b28 --- /dev/null +++ b/src/util.c @@ -0,0 +1,18 @@ +/* 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include +#include + +#include "util.h" +#include "bitboard.h" diff --git a/src/util.h b/src/util.h new file mode 100644 index 0000000..2036366 --- /dev/null +++ b/src/util.h @@ -0,0 +1,38 @@ +/* util.h - 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#ifndef _UTIL_H +#define _UTIL_H + +#include +#include + +#include "bug.h" + +#include "chessdefs.h" + +#undef safe_malloc +#undef safe_free + +#define safe_malloc(size) ({ \ + void *_ret = malloc(size); \ + bug_on(_ret == NULL); \ + _ret; \ + }) + +#define safe_free(ptr) do { \ + bug_on(ptr == NULL); \ + free(ptr); \ + } while (0) + +#endif /* UTIL_H */ diff --git a/test/attack-test.c b/test/attack-test.c new file mode 100644 index 0000000..10b8e29 --- /dev/null +++ b/test/attack-test.c @@ -0,0 +1,50 @@ +/* attack-test.c - basic square attack tests. + * + * 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include +#include +#include + +#include "chessdefs.h" +#include "fen.h" +#include "position.h" +#include "move-gen.h" +#include "attack.h" + +#include "common-test.h" + +int main(int __unused ac, __unused char**av) +{ + int i = 0; + char *fen; + pos_t *pos;//, *fishpos = pos_new(); + + setlinebuf(stdout); /* line-buffered stdout */ + + bitboard_init(); + hyperbola_init(); + + while ((fen = next_fen(ATTACK))) { + //printf(">>>>> %s\n", test[i]); + printf("original fen %d: [%p][%s]\n", i, fen, fen); + if (!(pos = fen2pos(NULL, fen))) { + printf("wrong fen %d: [%s]\n", i, fen); + continue; + } + pos_print(pos); + + pos_del(pos); + i++; + } + return 0; +} diff --git a/test/bitboard-test.c b/test/bitboard-test.c new file mode 100644 index 0000000..762056d --- /dev/null +++ b/test/bitboard-test.c @@ -0,0 +1,61 @@ +/* bitboard-test.c - basic bitboard/hyperbola tests. + * + * 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include +#include + +#include "bug.h" + +#include "chessdefs.h" +#include "bitboard.h" +#include "hyperbola-quintessence.h" + +int main(int __unused ac, __unused char**av) +{ + char str[256]; + bitboard_init(); + hyperbola_init(); + for (int i = 0; i < 64; ++i) { + sprintf(str, "\n%#x:\n %-22s%-22s%-22s%-22s%-22s%-22s%-22s", i, + "sliding", "diagonal", "antidiagonal", "file", "rank", "knight", + "king" + ); + bb_print_multi(str, 7, + bb_sqfile[i] | bb_sqrank[i] | + bb_sqdiag[i] | bb_sqanti[i], + bb_sqdiag[i], bb_sqanti[i], + bb_sqfile[i], bb_sqrank[i], + bb_knight[i], bb_king[i]); + } + sprintf(str, "between: %-22s%-22s%-22s%-22s%-22s%-22s", + "a1-a8", "a1-h8", "a1-h1", "a2-a7", "a2-g7", "a2-g2"); + bb_print_multi(str, 6, + bb_between[A1][A8], bb_between[A1][H8], + bb_between[A1][H1], bb_between[A2][A7], + bb_between[A2][G7], bb_between[A2][G2]); + sprintf(str, "between: %-22s%-22s%-22s%-22s%-22s%-22s%-22s%-22s", + "c3-c6", "c3-f6", "c3-f3", "c3-e1", "c3-c1", "c3-a1", "c3-a3", "c3-a5"); + bb_print_multi(str, 8, + bb_between[C3][C6], bb_between[C3][F6], + bb_between[C3][F3], bb_between[C3][E1], + bb_between[C3][C1], bb_between[C3][A1], + bb_between[C3][A3], bb_between[C3][A5]); + sprintf(str, "between: %-22s%-22s%-22s%-22s%-22s%-22s%-22s%-22s", + "c4-c6", "c4-f6", "c4-f3", "c4-e1", "c4-c1", "c4-a1", "c4-a3", "c4-a5"); + bb_print_multi(str, 8, + bb_between[C4][C6], bb_between[C4][F6], + bb_between[C4][F3], bb_between[C4][E1], + bb_between[C4][C1], bb_between[C4][A1], + bb_between[C4][A3], bb_between[C4][A5]); + return 0; +} diff --git a/test/common-test.h b/test/common-test.h new file mode 100644 index 0000000..9486ca5 --- /dev/null +++ b/test/common-test.h @@ -0,0 +1,398 @@ +/* common-test.h - common static vars/funcs test + * + * 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include +#include "chessdefs.h" +/* when below FENs are in a struct with selection per test */ +#define NOTEST 0 +#define FEN 1 +#define BITBOARD 2 +#define MOVEGEN 4 +#define ATTACK 8 +#define MOVEDO 16 + +struct fentest { + uint modules; + char *comment; + char *fen; +} fentest[] = { + /* + { ATTACK, + "checkers: ", + "" + }, + */ + /* tests rank movegen bug - FIXED + */ + //"4k3/pppppppp/8/8/8/8/PPPPPPPP/2BRK3 w - - 0 1", + //"4k3/pppppppp/8/8/8/8/PPPPPPPP/1B1R1K2 w - - 0 1", + { MOVEGEN, + "illegal white e.p.", + "3k4/8/8/2qpPK2/8/8/8/8 w - d6 0 1", + }, + { MOVEGEN, + "illegal black e.p.", + "8/8/8/8/2QPpk2/8/8/3K4 b - d3 0 1", + }, + + { MOVEGEN, + "illegal white e.p.", + "3k4/8/5K2/3pP3/8/2b5/8/8 w - d6 0 1", + }, + { MOVEGEN, + "illegal black e.p.", + "8/8/2B5/8/3Pp3/5k2/8/3K4 b - d3 0 1", + }, + + { MOVEGEN, + "legal white e.p.", + "1K1k4/8/8/3pP3/8/6b1/8/8 w - d6 0 1", + }, + { MOVEGEN, + "legal black e.p.", + "8/8/6B1/8/3Pp3/8/8/1k1K4 b - d3 0 1", + }, + + { MOVEGEN, + "white mate.", + "1nbqkbn1/ppp1pppp/8/r1rpP1K1/8/8/PPPP1PPP/RNBQ1BNR w - d6 0 1", + }, + { MOVEGEN, + "illegal e.p.", + "1nbqkbn1/ppp1pppp/8/r1rpP1K1/8/8/PPPP1PPP/RNBQ1BNR w - d6 0 1", + }, + { ATTACK, + "checkers: a1 h1", + "1k6/8/8/8/8/8/8/r2K3r w - - 1 1" + }, + { ATTACK, + "checkers: a8 h8", + "R2k3R/8/8/8/8/8/8/1K6 b - - 1 1" + }, + { ATTACK, + "checkers: b3 g3", + "1k6/8/8/8/8/1r1K2r1/8/8 w - - 1 1" + }, + + { ATTACK, + "checkers: b6 g6", + "8/8/1R1k2R1/8/8/8/8/1K6 b - - 1 1" + }, + + { ATTACK, + "checkers: g2 g7", + "8/k5r1/8/8/6K1/8/6r1/8 w - - 1 1" + }, + { ATTACK, + "checkers: g2 g7", + "8/6R1/8/6k1/8/8/K5R1/8 b - - 1 1" + }, + { ATTACK, + "checkers: d5 e3, pinners: none (2 pieces between attacker & K)", + "3k4/8/8/3r3b/b7/1N2nn2/2n1B3/rNBK1Rbr w - - 1 1" + }, + + { ATTACK, + "checkers: d4 e6 pinners: h4 a5 a8 h8", + "Rn1k1r1R/4b3/1n2N3/B7/3R3B/8/8/3K4 b - - 1 1" + }, + { ATTACK, + "checkers: d5 e3, pinners: a1 h1 a4 h5", + "3k4/8/8/3r3b/b7/1N2n3/4B3/rN1K1R1r w - - 1 0" + }, + + { MOVEGEN, + "only pawn captures", + "4k3/8/2p1p3/2PpP3/8/pp4pp/PP4PP/4K3 w - d6 0 1" + }, + + { FEN | ATTACK, + "checker: h4", + "4k3/8/8/8/7b/8/8/4K3 w - - 0 1" + }, +// First game moves + { FEN | MOVEGEN, + "initial pos", + "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1" + }, + { FEN | MOVEGEN, + "1.e4", + "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq - 0 1" + }, + { FEN | MOVEGEN, + "1.Nh3", + "rnbqkbnr/pppppppp/8/8/8/7N/PPPPPPPP/RNBQKB1R b KQkq - 1 1" + }, + { FEN | MOVEGEN, + "1.e4 e5 2.Nf3 Nc6", + "r1bqkbnr/pp1ppppp/2n5/2p5/4P3/5N2/PPPP1PPP/RNBQKB1R w KQkq - 0 1" + }, + + // castling test + // both can castle queen only + { FEN | MOVEGEN, + "", + "r3k2r/8/3B4/8/8/3b4/8/R3K2R w KQkq - 0 1" + }, + { FEN | MOVEGEN, + "", + "r3k2r/8/3BB3/8/8/3bb3/8/R3K2R w KQkq - 0 1" + }, + { FEN | MOVEGEN, + "", + "r2bkb1r/8/8/8/8/3bb3/8/R2BKB1R w KQkq - 0 1" + }, + // + { FEN | MOVEGEN, + "4 castle possible, only K+R", + "r3k2r/8/8/8/8/8/8/R3K2R w KQkq - 0 1" + }, + // + { FEN | MOVEGEN, + "only kings on A1/A8, white to play", + "k7/8/8/8/8/8/8/K7 w - - 0 1" + }, + // + { FEN | MOVEGEN, + "only one move possible (Pf2xBg3)", + "k7/8/8/1p1p4/pPpPp3/P1PpPpb1/NBNP1P2/KBB1B3 w - - 0 1" + }, + // + { FEN | MOVEGEN, + "only 2 moves possible (Ph5xg6 e.p., Ph5-h6)", + "k7/8/8/1p1p2pP/pPpPp3/P1PpPp2/NBNP1P2/KBB1B3 w - g6 0 1" + }, + // + { FEN | MOVEGEN, + "2 Kings, W/B/ pawns on 7th for promotion", + "k4n2/4P3/8/8/8/8/4p3/K4N2 w - - 0 1" + }, + // white castled, and can e.p. on c6 black can castle + // white is a pawn down + // white has 36 moves: P=11 + 1 e.p. N=6+3 B=5+5 R=1 Q=3 K=1 + 1 e.p. + // black has 33 moves: P=11 N=2+7 B=5 R=3 Q=3 K=1 + castle + { FEN | MOVEGEN, + "", + "rnbqk2r/pp1pbpp1/7p/2pPp3/4n3/3B1N2/PPP2PPP/RNBQ1RK1 w kq c6 0 7" + }, + + { FEN | MOVEGEN, + "", + "4k3/4p3/8/b7/1BR1p2p/1Q3P2/5N2/4K3 w - - 0 1" + }, + { FEN | MOVEGEN, + "", + "r1bq1rk1/pppp1ppp/2n2n2/4p3/2B1P3/3PPN2/PPP3PP/RN1QK2R b KQ - 1 7" + }, + { FEN | MOVEGEN, + "", + "6k1/6pp/R2p4/p1p5/8/1P1r3P/6P1/6K1 b - - 3 3" + }, + + // some of tests below are from: + // - Rodent IV + // - https://www.chessprogramming.net/perfect-perft/ + { FEN | MOVEGEN, + "", + "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1" + }, + { FEN | MOVEGEN, + "", + "8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - - 0 1" + }, + { FEN | MOVEGEN, + "", + "8/2p5/3p4/Kp5r/1R3p1k/8/4P1P1/8 w - - 0 1" + }, + { FEN | MOVEGEN, + "", + "4rrk1/pp1n3p/3q2pQ/2p1pb2/2PP4/2P3N1/P2B2PP/4RRK1 b - - 7 19" + }, + { FEN | MOVEGEN, + "", + "rq3rk1/ppp2ppp/1bnpb3/3N2B1/3NP3/7P/PPPQ1PP1/2KR3R w - - 7 14" + }, + { FEN | MOVEGEN, + "", + "r1bq1r1k/1pp1n1pp/1p1p4/4p2Q/4Pp2/1BNP4/PPP2PPP/3R1RK1 w - - 2 14" + }, + { FEN | MOVEGEN, + "", + "r3r1k1/2p2ppp/p1p1bn2/8/1q2P3/2NPQN2/PPP3PP/R4RK1 b - - 2 15" + }, + { FEN | MOVEGEN, + "", + "1rbqk1nr/p3ppbp/2np2p1/2p5/1p2PP2/3PB1P1/PPPQ2BP/R2NK1NR b KQk - 0 1" + }, + { FEN | MOVEGEN, + "", + "r1bqk2r/pp1p1ppp/2n1pn2/2p5/1bPP4/2NBP3/PP2NPPP/R1BQK2R b KQkq - 0 1" + }, + { FEN | MOVEGEN, + "", + "rnb1kb1r/ppp2ppp/1q2p3/4P3/2P1Q3/5N2/PP1P1PPP/R1B1KB1R b KQkq - 0 1" + }, + { FEN | MOVEGEN, + "", + "r1b2rk1/pp2nppp/1b2p3/3p4/3N1P2/2P2NP1/PP3PBP/R3R1K1 b - - 0 1" + }, + { FEN | MOVEGEN, + "", + "n1q1r1k1/3b3n/p2p1bp1/P1pPp2p/2P1P3/2NBB2P/3Q1PK1/1R4N1 b - - 0 1" + }, + { FEN | MOVEGEN, + "", + "r1bq1r1k/b1p1npp1/p2p3p/1p6/3PP3/1B2NN2/PP3PPP/R2Q1RK1 w - - 1 16" + }, + { FEN | MOVEGEN, + "", + "3r1rk1/p5pp/bpp1pp2/8/q1PP1P2/b3P3/P2NQRPP/1R2B1K1 b - - 6 22" + }, + { FEN | MOVEGEN, + "", + "r1q2rk1/2p1bppp/2Pp4/p6b/Q1PNp3/4B3/PP1R1PPP/2K4R w - - 2 18" + }, + { FEN | MOVEGEN, + "", + "4k2r/1pb2ppp/1p2p3/1R1p4/3P4/2r1PN2/P4PPP/1R4K1 b - - 3 22" + }, + { FEN | MOVEGEN, + "", + "3q2k1/pb3p1p/4pbp1/2r5/PpN2N2/1P2P2P/5PP1/Q2R2K1 b - - 4 26" + }, + { FEN | MOVEGEN, + "", + "2r5/8/1n6/1P1p1pkp/p2P4/R1P1PKP1/8/1R6 w - - 0 1" + }, + { FEN | MOVEGEN, + "", + "r2q1rk1/1b1nbppp/4p3/3pP3/p1pP4/PpP2N1P/1P3PP1/R1BQRNK1 b - - 0 1" + }, + { FEN | MOVEGEN, + "", + "6k1/5pp1/7p/p1p2n1P/P4N2/6P1/1P3P1K/8 w - - 0 35" + }, + { FEN | MOVEGEN, + "", + "r4rk1/1pp1q1pp/p2p4/3Pn3/1PP1Pp2/P7/3QB1PP/2R2RK1 b - - 0 1" + }, + + { FEN | MOVEGEN, + "", + "r3k2r/Pppp1ppp/1b3nbN/nP6/BBP1P3/q4N2/Pp1P2PP/R2Q1RK1 w kq - 0 1" + }, + { FEN | MOVEGEN, + "", + "1k6/1b6/8/8/7R/8/8/4K2R b K - 0 1" + }, + { FEN | MOVEGEN, + "Illegal ep move #1", + "3k4/3p4/8/K1P4r/8/8/8/8 b - - 0 1" + }, + { FEN | MOVEGEN, + "Illegal ep move #2", + "8/8/4k3/8/2p5/8/B2P2K1/8 w - - 0 1" + }, + { FEN | MOVEGEN, + "EP Capture Checks Opponent", + "8/8/1k6/2b5/2pP4/8/5K2/8 b - d3 0 1" + }, + { FEN | MOVEGEN, + "Short Castling Gives Check", + "5k2/8/8/8/8/8/8/4K2R w K - 0 1" + }, + { FEN | MOVEGEN, + "Long Castling Gives Check", + "3k4/8/8/8/8/8/8/R3K3 w Q - 0 1" + }, + { FEN | MOVEGEN, + "Castle Rights", + "r3k2r/1b4bq/8/8/8/8/7B/R3K2R w KQkq - 0 1" + }, + { FEN | MOVEGEN, + "Castling Prevented", + "r3k2r/8/3Q4/8/8/5q2/8/R3K2R b KQkq - 0 1" + }, + { FEN | MOVEGEN, + "Promote out of Check", + "2K2r2/4P3/8/8/8/8/8/3k4 w - - 0 1" + }, + { FEN | MOVEGEN, + "Discovered Check", + "8/8/1P2K3/8/2n5/1q6/8/5k2 b - - 0 1" + }, + { FEN | MOVEGEN, + "Promote to give check", + "4k3/1P6/8/8/8/8/K7/8 w - - 0 1" + }, + { FEN | MOVEGEN, + "Under Promote to give check", + "8/P1k5/K7/8/8/8/8/8 w - - 0 1" + }, + { FEN | MOVEGEN, + "Self Stalemate", + "K1k5/8/P7/8/8/8/8/8 w - - 0 1" + }, + { FEN | MOVEGEN, + "Stalemate & Checkmate", + "8/k1P5/8/1K6/8/8/8/8 w - - 0 1" + }, + { FEN | MOVEGEN, + "Stalemate & Checkmate", + "8/8/2k5/5q2/5n2/8/5K2/8 b - - 0 1" + }, + + { FEN, + "illegal EP and castle flags, fix-able by fen parser, SF crash", + "4k3/8/8/8/7B/8/8/4K3 w KQkq e6 0 1" + }, + { FEN, + "illegal, SF crash", + "4k3/8/8/8/7b/8/8/4K3 b - - 0 1" + }, + { FEN, + "illegal, SF crash", + "2r1k3/3B4/8/8/8/8/8/4K3 w - - 0 1" + }, + { FEN, + "illegal, SF crash", + "2r1k3/3P4/8/8/8/8/8/4K3 w - - 0 1" + }, + { MOVEDO, + "simple movedo/undo: only 2 W knights", + "8/1k6/8/8/8/8/6K1/1NN5 w - - 0 1" + }, + { MOVEDO, + "simple movedo/undo: only 2 W knights", + "8/1k6/8/8/8/8/6K1/1NN5 w - - 0 1" + }, + { MOVEDO, + "simple movedo/undo: only 2 W knights", + "5n2/1k6/8/8/5K2/8/P7/1N6 w - - 0 1" + }, + { 0, NULL, NULL } +}; + +static int cur = 0; + +static char *next_fen(uint module) +{ + while (fentest[cur].fen && !(fentest[cur].modules & module)) + cur++; + return fentest[cur].fen ? fentest[cur++].fen: NULL; +} + +static __unused char* cur_comment() +{ + return fentest[cur].comment; +} diff --git a/test/eval.c b/test/eval-test.c similarity index 100% rename from test/eval.c rename to test/eval-test.c diff --git a/test/fen-test.c b/test/fen-test.c new file mode 100644 index 0000000..f395c45 --- /dev/null +++ b/test/fen-test.c @@ -0,0 +1,51 @@ +/* fen-test.c - basic fen tests. + * + * 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include + +#include "chessdefs.h" +#include "bitboard.h" +#include "position.h" +#include "fen.h" + +#include "common-test.h" + +int main(__unused int ac, __unused char**av) +{ + pos_t *pos; + const char *fen; + char revfen[128]; + + setlinebuf(stdout); /* line-buffered stdout */ + + bitboard_init(); + + while ((fen = next_fen(FEN))) { + printf("***** [%s] ", fen); + fflush(stdout); + if (!(pos = fen2pos(NULL, fen))) { + printf("**INVALID\n"); + } else { + //pos_print(pos); + pos2fen(pos, revfen); + if (!strcmp(fen, revfen)) { + printf("OK\n"); + } else { + //printf("fen = [%s]\nrev = [%s]", fen, revfen); + printf("-> [%s] **FIXED\n",revfen); + pos_print_raw(pos, 1); + } + pos_del(pos); + } + } +} diff --git a/test/fen.c b/test/fen.c deleted file mode 100644 index cb19846..0000000 --- a/test/fen.c +++ /dev/null @@ -1,20 +0,0 @@ -#include "debug.h" -#include "pool.h" -#include "../src/position.h" -#include "../src/fen.h" - -int main(int ac, char**av) -{ - pos_t *pos; - - debug_init(5, stderr, true); - piece_pool_init(); - pos_pool_init(); - pos = pos_get(); - if (ac == 1) { - pos_startpos(pos); - } else { - fen2pos(pos, av[1]); - } - pos_print(pos); -} diff --git a/test/move.c b/test/move-test.c similarity index 100% rename from test/move.c rename to test/move-test.c diff --git a/test/movedo-test.c b/test/movedo-test.c new file mode 100644 index 0000000..c498514 --- /dev/null +++ b/test/movedo-test.c @@ -0,0 +1,80 @@ +/* movedo-test.c - basic movedo/undo tests. + * + * 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include +#include +#include + +#include "chessdefs.h" +#include "fen.h" +#include "position.h" +#include "move.h" +#include "move-do.h" +#include "move-gen.h" + +#include "common-test.h" + +int main(int __unused ac, __unused char**av) +{ + int i = 1; + char *fen, movebuf[8];; + pos_t *pos, *savepos; + move_t move; + + setlinebuf(stdout); /* line-buffered stdout */ + + bitboard_init(); + hyperbola_init(); + + while ((fen = next_fen(MOVEGEN | MOVEDO))) { + if (!(pos = fen2pos(NULL, fen))) { + printf("wrong fen %d: [%s]\n", i, fen); + continue; + } + pos_gen_pseudomoves(pos); + savepos = pos_dup(pos); + if (pos_cmp(pos, savepos) != true) { + printf("*** positions differ 1\n"); + exit(0); + } + int tmp = 0, j = 1; + while ((move = pos_next_legal(pos, &tmp)) != MOVE_NONE) { + state_t state; + + pos_print(pos); + printf("i=%d j=%d turn=%d move=[%s]\n", i, j, pos->turn, + move_str(movebuf, move, 0)); + //move_p + move_do(pos, move, &state); + pos_print(pos); + fflush(stdout); + pos_check(pos, true); + printf("%d/%d move_do check ok\n", i, j); + move_undo(pos, move, &state); + if (pos_cmp(pos, savepos) != true) { + printf("*** positions differ 2\n"); + exit(0); + } + fflush(stdout); + pos_check(pos, true); + printf("%d/%d move_undo check ok\n", i, j); + + if (j++ == 1000) + exit(0); + } + pos_del(savepos); + pos_del(pos); + i++; + } + return 0; +} diff --git a/test/movegen-test.c b/test/movegen-test.c new file mode 100644 index 0000000..08a0e09 --- /dev/null +++ b/test/movegen-test.c @@ -0,0 +1,282 @@ +/* movegen-test.c - basic movegen tests. + * + * 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 . + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include +#include +#include + +#include "chessdefs.h" +#include "fen.h" +#include "move-gen.h" +#include "position.h" + +#include "common-test.h" + +#define RD 0 +#define WR 1 + +/** + * return write pipd fd + */ +static FILE *open_stockfish() +{ + int rpipe[2], wpipe[2]; + FILE *out_desc; + pid_t pid; + + if ((pipe(rpipe) < 0) || (pipe(wpipe) < 0)) { + perror("pipe"); + return NULL; + } + if ((pid = fork()) < 0) { + perror("fork"); + return NULL; + } + + if (!pid) { /* stockfish */ + setvbuf(stdin, NULL, _IOLBF, 0); + setvbuf(stdout, NULL, _IOLBF, 0); + setvbuf(stderr, NULL, _IOLBF, 0); + + dup2(wpipe[RD], STDIN_FILENO); + dup2(rpipe[WR], STDOUT_FILENO); + dup2(rpipe[WR], STDERR_FILENO); + + close(wpipe[RD]); + close(wpipe[WR]); + close(rpipe[RD]); + close(rpipe[WR]); + if (execlp("stockfish", "stockfish", NULL) == -1) { + perror("execlp"); + return NULL; + } + return 0; /* not reached */ + } + /* us */ + dup2(rpipe[RD], STDIN_FILENO); + setvbuf(stdin, NULL, _IOLBF, 0); + + close(wpipe[RD]); + close(rpipe[RD]); + close(rpipe[WR]); + + out_desc = fdopen(wpipe[WR], "w"); + setvbuf(out_desc, NULL, _IOLBF, 0); + + return out_desc; +} + +static void send_stockfish_fen(FILE *desc, pos_t *pos, char *fen) +{ + char *buf = NULL; + int count, __unused mycount = 0, fishcount; + size_t alloc = 0; + ssize_t buflen; + + pos_clear(pos); + + move_t *moves = pos->moves.move; + int nmoves = pos->moves.nmoves; + //char nodescount[] = "Nodes searched"; + //printf("nmoves = %d\n", nmoves); + fflush(stdout); + //sprintf(str, "stockfish \"position fen %s\ngo perft depth\n\"", fen); + fprintf(desc, "position fen %s\ngo perft 1\n", fen); + //fflush(desc); + while ((buflen = getline(&buf, &alloc, stdin)) > 0) { + buf[--buflen] = 0; + if (buflen == 0) + continue; + if (sscanf(buf, "Nodes searched: %d", &fishcount) == 1) { + break; + } + //printf("%d: %s\n", line++, buf); + if (sscanf(buf, "%*4s: %d", &count) == 1) { + square_t from = sq_from_string(buf); + square_t to = sq_from_string(buf + 2); + mycount += count; + //printf("move found: %c%c->%c%c %s->%s count=%d\n", + // buf[0], buf[1], buf[2], buf[3], + // sq_to_string(from), sq_to_string(to), + // count); + moves[nmoves++] = move_make(from, to); + + } else if (sscanf(buf, "%*5s: %d", &count) == 1) { + square_t from = sq_from_string(buf); + square_t to = sq_from_string(buf + 2); + piece_type_t promoted = piece_t_from_char(*(buf + 4)); + mycount += count; + //printf("move found: %c%c->%c%c %s->%s count=%d\n", + // buf[0], buf[1], buf[2], buf[3], + // sq_to_string(from), sq_to_string(to), + // count); + moves[nmoves++] = move_make_promote(from, to, promoted); + } + } + pos->moves.nmoves = nmoves; + // printf("fishcount=%d mycount=%d\n", fishcount, mycount); + free(buf); +} + +static __unused bool movelists_equal(movelist_t *fish, movelist_t *me) +{ + move_t *m1 = fish->move, *m2 = me->move; + int n1 = fish->nmoves, n2 = me->nmoves; + int mask = 077777; + + if (n1 != n2) + return false; + for (int cur = 0; cur < n1; ++cur) { + if ((m1[cur] & mask) != (m2[cur] & mask)) + return false; + } + return true; +} + +static __unused void compare_moves(movelist_t *fish, movelist_t *me) +{ + char str1[1024] = {0}, str2[1024] = {0}, tmpstr[1024]; + char *skip = " "; + move_t *m1 = fish->move; + move_t *m2 = me->move; + int n1 = fish->nmoves; + int n2 = me->nmoves; + +#define f(c) move_from(c) +#define t(c) move_to(c) + + for (move_t *c1 = m1, *c2 = m2; (c1 - m1 < n1) || (c2 - m2 < n2);) { + // square_t f1 = move_from(*c1); square_t t1 = move_to(*c1); + // square_t f2 = move_from(*c2); square_t t2 = move_to(*c2); + + /* no more move in c2 */ + if (c2 - m2 >= n2) { + while (c1 - m1 < n1) { + sprintf(tmpstr, " %s-%s", sq_to_string(f(*c1)), sq_to_string(t(*c1))); + strcat (str1, tmpstr); + c1++; + } + break; + } + if (c1 - m1 >= n1) { + while (c2 - m2 < n2) { + sprintf(tmpstr, " %s-%s", sq_to_string(f(*c2)), sq_to_string(t(*c2))); + strcat (str2, tmpstr); + c2++; + } + break; + } + + /* missing move in c2 */ + if (f(*c1) < f(*c2) || + (f(*c1) == f(*c2) && t(*c1) < t(*c2))) { + strcat(str2, skip); + sprintf(tmpstr, " %s-%s", sq_to_string(f(*c1)), sq_to_string(t(*c1))); + strcat (str1, tmpstr); + while ((c1 - m1 < n1) && (f(*c1) < f(*c2) || + (f(*c1) == f(*c2) && t(*c1) < t(*c2)))) { + c1++; + } + continue; + } + /* missing move in c1 */ + if (f(*c1) > f(*c2) || + (f(*c1) == f(*c2) && t(*c1) > t(*c2))) { + strcat(str1, skip); + sprintf(tmpstr, " %s-%s", sq_to_string(f(*c2)), sq_to_string(t(*c2))); + strcat (str2, tmpstr); + while ((c2 - m2 < n2) && (f(*c1) > f(*c2) || + (f(*c1) == f(*c2) && t(*c1) > t(*c2)))) { + c2++; + } + continue; + } + sprintf(tmpstr, " %s-%s", sq_to_string(f(*c1)), sq_to_string(t(*c1))); + strcat(str1, tmpstr); + strcat(str2, tmpstr); + c1++, c2++; + } + printf("F(%2d): %s\nM(%2d): %s\n", n1, str1, n2, str2); +} + +int main(int __unused ac, __unused char**av) +{ + int i = 0; + FILE *outfd; + char *fen; + pos_t *pos, *fishpos = pos_new(); + movelist_t legal; + //bitboard_t wrong = 0x5088000040, tmp, loop; + //bit_for_each64(loop, tmp, ) + //printf("fishpos 1=%p\n", fishpos); + + setlinebuf(stdout); /* line-buffered stdout */ + + bitboard_init(); + hyperbola_init(); + outfd = open_stockfish(); + + while ((fen = next_fen(MOVEGEN))) { + //printf(">>>>> %s\n", test[i]); + //printf("fishpos 2=%p\n", fishpos); + //printf("original fen %d: [%p][%s]\n", i, fen, fen); + if (!(pos = fen2pos(NULL, fen))) { + printf("wrong fen %d: [%s]\n", i, fen); + continue; + } + /* print movelists */ + send_stockfish_fen(outfd, fishpos, fen); + pos_gen_pseudomoves(pos); + pos_all_legal(pos, &legal); + //printf("Fu "); + //moves_print(fishpos, 0); + //fflush(stdout); + //printf("Mu "); + //moves_print(pos, 0); + //fflush(stdout); + + /* sort and print movelists */ + move_sort_by_sq(&fishpos->moves); + move_sort_by_sq(&legal); + // printf("\nFs "); + // moves_print(fishpos, 0); + // fflush(stdout); + // printf("Ms "); + // moves_print(pos, 0); + // fflush(stdout); + + /* compare movelists */ + if (!movelists_equal(&fishpos->moves, &legal)) { + pos_print(pos); + printf("F: "); + moves_print(&fishpos->moves, 0); + printf("M: "); + moves_print(&legal, 0); + } else { + printf("[%s]: OK (%d Moves)\n", fen, legal.nmoves); + //moves_print(&fishpos->moves, 0); + } + //compare_moves(&fishpos->moves, &legal); + //} else { + //printf("fen %d: [%s] - OK (%d moves)\n", i, fen, legal.nmoves); + //} + //pos_print_board_raw(pos, 1); + //printf("%s\n", pos2fen(pos, str)); + //get_stockfish_moves(test[i]); + //exit(0); + pos_del(pos); + i++; + } + fclose(outfd); + return 0; +} diff --git a/test/piece-test.c b/test/piece-test.c new file mode 100644 index 0000000..d8f7f27 --- /dev/null +++ b/test/piece-test.c @@ -0,0 +1,20 @@ +#include + +#include "brlib.h" + +#include "piece.h" + +int main(__unused int ac, __unused char**av) +{ + + piece_t p; + char *test="PNBRQKpnbrqk"; + + for (u64 i = 0; i < sizeof(test); ++i) { + char c1 = test[i], *c2; + p = piece_from_fen(c1); + c2 = piece_to_fen(p); + printf("c1=%c c2=%c\n", c1, *c2); + } + return 0; +} diff --git a/test/piece.c b/test/piece.c deleted file mode 100644 index dbb6b65..0000000 --- a/test/piece.c +++ /dev/null @@ -1,55 +0,0 @@ -#include - -#include "debug.h" - -#include "../src/fen.h" -#include "../src/position.h" -#include "../src/bitboard.h" - -int main(int ac, char**av) -{ - pos_t *pos; - printf("zobi\n");fflush(stdout); - debug_init(6, stderr, true); - log_f(5, "kfsjdhg\n"); - pos_pool_init(); - pos = pos_get(); - piece_pool_init(); - - if (ac == 1) { - printf("zoba\n");fflush(stdout); - pos_startpos(pos); - } else { - fen2pos(pos, av[1]); - } - pos_print(pos); - pos_pieces_print(pos); - - printf("0x1c = 11100 = C1-E1:\n"); - bitboard_print(0x1c); - - printf("0x70 = 111 = A1-C1\n"); - bitboard_print(0x70); - - printf("0x0e = 1110 = B1-D1\n"); - bitboard_print(0x0e); - - printf("0x60 = 1100000 = F1-G1\n"); - bitboard_print(0x60); - - printf("A1:\n"); - bitboard_print(A1); - - printf("1:\n"); - bitboard_print(1L); - printf("H1:\n"); - bitboard_print(H1); - printf("C1:\n"); - bitboard_print(C1); - printf("D1:\n"); - bitboard_print(D1); - printf("C1|D1:\n"); - bitboard_print(C1|D1); - printf("H8:\n"); - bitboard_print(H8); -}