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

Merge branch 'bitboard-switch'

Browse Source
This commit is contained in:
Bruno Raoult
2024-03-23 17:26:26 +01:00
parent f0d6f57dd1 856e3e52da
commit 798047b84d
62 changed files with 7490 additions and 1775 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.dir-locals.el
View File

@@ -1,3 +1,3 @@
((nil . ((compile-command . (concat "make -C "
(vc-root-dir)
" -k -j2")))))
" -k -j2 testing")))))

4
.gitignore vendored
View File

@@ -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

2
MEMO.org Normal file
View File

@@ -0,0 +1,2 @@
** Some current ideas
- helpers for square, pieces, etc: validity, conversions

215
Makefile
View File

@@ -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

3
README.org
View File

@@ -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

2
brlib

Submodule brlib updated: e55ac95301...8ff163dcf5

157
src/attack.c Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include <stdio.h>
#include <stdarg.h>
#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);
}

23
src/attack.h Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#ifndef _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

330
src/bitboard.c Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include <stdio.h>
#include <stdarg.h>
#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;
}

306
src/bitboard.h
View File

@@ -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 */

128
src/board.c Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include <stdio.h>
#include <ctype.h>
#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");
}
}

119
src/board.h
View File

@@ -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 <stdint.h>
#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 */

2
src/brchess.c
View File

@@ -18,7 +18,7 @@
#include <readline/readline.h>
#include <readline/history.h>
#include <br.h>
#include <brlib.h>
#include <list.h>
#include <debug.h>

4
src/brchess.h
View File

@@ -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.
*

195
src/chessdefs.h
View File

@@ -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 */

429
src/fen.c
View File

@@ -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 <ctype.h>
#include <debug.h>
#include <bug.h>
#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;
}

12
src/fen.h
View File

@@ -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 */

210
src/hyperbola-quintessence.c Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include <stdio.h>
#include <stdarg.h>
#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);
}

33
src/hyperbola-quintessence.h Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#ifndef _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 */

172
src/move-do.c Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include <malloc.h>
#include <ctype.h>
#include <stdlib.h>
#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;
}

20
src/move-do.h Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#ifndef 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 */

345
src/move-gen.c Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include <stdio.h>
#include "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);
}

29
src/move-gen.h Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#ifndef 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 */

962
src/move.c
View File

@@ -13,65 +13,86 @@
#include <malloc.h>
#include <ctype.h>
#include <br.h>
#include <list.h>
#include <list_sort.h>
#include <debug.h>
#include <stdlib.h>
#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);
}

163
src/move.h
View File

@@ -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 */

137
src/piece.c
View File

@@ -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 <malloc.h>
#include <ctype.h>
#include <string.h>
#include <assert.h>
#include <debug.h>
#include <pool.h>
#include <list.h>
#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);
}

151
src/piece.h
View File

@@ -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 <ctype.h>
#include <string.h>
#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

572
src/position.c
View File

@@ -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 <stdbool.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#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");
}
}

186
src/position.h
View File

@@ -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 <stdint.h>
#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 */

42
src/temp-migration-bitboard/bitboard.c Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include "br.h"
#include "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 ()
}
}
}

105
src/temp-migration-bitboard/bitboard.h Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#ifndef 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 */

80
src/temp-migration-bitboard/board.h Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#ifndef BOARD_H
#define BOARD_H
#include <stdint.h>
#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 */

522
src/temp-migration-bitboard/brchess.c Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include <err.h>
#include <stdlib.h>
#include <string.h>
#include <readline/readline.h>
#include <readline/history.h>
#include <br.h>
#include <list.h>
#include <debug.h>
#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 = &quote_detector;
while (!done) {
buffer = readline("chess> ");
if (!buffer)
break;
/* Remove leading and trailing whitespace from the line.
* Then, if there is anything left, add it to the history list
* and execute it.
*/
s = stripwhite(buffer);
if (*s) {
add_history(s);
execute_line(pos, s);
}
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, "<no-best-move>");
}
printf("Depth:%d Nodes:%luK time:%.02fs (%.0f kn/s)\n", depth,
pos->node_count / 1000, (timer2 - timer1)/NANOSEC, nodes_sec/1000);
return 1;
}
/** main()
* options:
int brchess(pos_t *pos)
*
*/
static int usage(char *prg)
{
fprintf(stderr, "Usage: %s [-ilw] [file...]\n", prg);
return 1;
}
#include <unistd.h>
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);
}

21
src/temp-migration-bitboard/brchess.h Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#ifndef BRCHESS_H
#define BRCHESS_H
#include "position.h"
int brchess(pos_t *pos);
#endif /* BRCHESS_H */

129
src/temp-migration-bitboard/chessdefs.h Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#ifndef 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

199
src/temp-migration-bitboard/eval-simple.c Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include "br.h"
#include "debug.h"
#include "piece.h"
#include "eval-simple.h"
#include "position.h"
/*
* Tables are from https://www.chessprogramming.org/Simplified_Evaluation_Function
*
* 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];
}

47
src/temp-migration-bitboard/eval-simple.h Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#ifndef 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 */

95
src/temp-migration-bitboard/eval.c Normal file
View File

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

37
src/temp-migration-bitboard/eval.h Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#ifndef EVAL_H
#define EVAL_H
#include <limits.h>
#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 */

175
src/temp-migration-bitboard/fen.c Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <ctype.h>
#include <debug.h>
#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;
}

21
src/temp-migration-bitboard/fen.h Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#ifndef FEN_H
#define FEN_H
#include "position.h"
pos_t *fen2pos(pos_t *pos, char *fen);
#endif /* FEN_H */

890
src/temp-migration-bitboard/move.c Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include <malloc.h>
#include <ctype.h>
#include <br.h>
#include <list.h>
#include <list_sort.h>
#include <debug.h>
#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);
}

79
src/temp-migration-bitboard/move.h Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#ifndef 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 */

118
src/temp-migration-bitboard/piece.c Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include <malloc.h>
#include <ctype.h>
#include <debug.h>
#include <pool.h>
#include <list.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 }
};
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;
}

71
src/temp-migration-bitboard/piece.h Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#ifndef PIECE_H
#define PIECE_H
#include <ctype.h>
#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

323
src/temp-migration-bitboard/position.c Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <ctype.h>
#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);
}

66
src/temp-migration-bitboard/position.h Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#ifndef POSITION_H
#define POSITION_H
#include <stdint.h>
#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 */

237
src/temp-migration-bitboard/search.c Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include <br.h>
#include <list.h>
#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;
}
*/

22
src/temp-migration-bitboard/search.h Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#ifndef 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 */

18
src/util.c Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include <stdio.h>
#include <stdlib.h>
#include "util.h"
#include "bitboard.h"

38
src/util.h Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#ifndef _UTIL_H
#define _UTIL_H
#include <stdio.h>
#include <stdlib.h>
#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 */

50
test/attack-test.c Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "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;
}

61
test/bitboard-test.c Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include <stdio.h>
#include <string.h>
#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;
}

398
test/common-test.h Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include <stdio.h>
#include "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;
}

0
test/eval.c → test/eval-test.c
View File

51
test/fen-test.c Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include <stdio.h>
#include "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);
}
}
}

20
test/fen.c
View File

@@ -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);
}

0
test/move.c → test/move-test.c
View File

80
test/movedo-test.c Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "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;
}

282
test/movegen-test.c Normal file
View File

@@ -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 <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "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;
}

20
test/piece-test.c Normal file
View File

@@ -0,0 +1,20 @@
#include <stdio.h>
#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;
}

55
test/piece.c
View File

@@ -1,55 +0,0 @@
#include <stdio.h>
#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);
}