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

Add move_do (dup position), remove &board in move struct

Browse Source
This commit is contained in:
Bruno Raoult
2023-07-06 12:22:26 +02:00
parent a08b006b98
commit 6f7a04cc89
4 changed files with 125 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
src/brchess.c
View File

@@ -55,7 +55,7 @@ int do_init(pos_t *, char*);
int do_pos(pos_t *, char*); int do_pos(pos_t *, char*);
int do_genmoves(pos_t *, char*); int do_genmoves(pos_t *, char*);
int do_prmoves(pos_t *, char*); int do_prmoves(pos_t *, char*);
int do_prmovepos(pos_t *pos, char *arg); //int do_prmovepos(pos_t *pos, char *arg);
int do_prpieces(pos_t *pos, char *arg); int do_prpieces(pos_t *pos, char *arg);
int do_memstats(pos_t *, char*); int do_memstats(pos_t *, char*);
int do_eval(pos_t *, char*); int do_eval(pos_t *, char*);
@@ -72,7 +72,7 @@ COMMAND commands[] = {
{ "quit", do_quit, "Quit" }, { "quit", do_quit, "Quit" },
{ "genmove", do_genmoves, "Generate move list for " }, { "genmove", do_genmoves, "Generate move list for " },
{ "prmoves", do_prmoves, "Print position move list" }, { "prmoves", do_prmoves, "Print position move list" },
{ "prmovepos", do_prmovepos, "Print Nth move resulting position" }, // { "prmovepos", do_prmovepos, "Print Nth move resulting position" },
{ "prpieces", do_prpieces, "Print Pieces (from pieces lists)" }, { "prpieces", do_prpieces, "Print Pieces (from pieces lists)" },
{ "memstats", do_memstats, "Generate next move list" }, { "memstats", do_memstats, "Generate next move list" },
{ "eval", do_eval, "Eval current position" }, { "eval", do_eval, "Eval current position" },
@@ -304,23 +304,25 @@ int do_prmoves(pos_t *pos, __unused char *arg)
return 1; return 1;
} }
int do_prmovepos(pos_t *pos, char *arg) /*
{ * int do_prmovepos(pos_t *pos, char *arg)
struct list_head *p_cur, *tmp; * {
int movenum = atoi(arg), cur = 0; /* starts with 0 */ * struct list_head *p_cur, *tmp;
move_t *move; * 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]) { * log_f(1, "%s\n", arg);
move = list_entry(p_cur, move_t, list); * list_for_each_safe(p_cur, tmp, &pos->moves[pos->turn]) {
if (cur++ == movenum) { * move = list_entry(p_cur, move_t, list);
pos_print(move->newpos); * if (cur++ == movenum) {
break; * pos_print(move->newpos);
} * break;
} * }
* }
return 1; *
} * return 1;
* }
*/
int do_prpieces(pos_t *pos, __unused char *arg) int do_prpieces(pos_t *pos, __unused char *arg)
{ {
@@ -339,6 +341,25 @@ int do_memstats(__unused pos_t *pos,__unused char *arg)
int do_move(__unused pos_t *pos, __unused char *arg) 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; return 1;
} }

106
src/move.c
View File

@@ -172,7 +172,7 @@ static move_t *move_add(pos_t *pos, piece_t piece, square_t from,
move->to = to; move->to = to;
move->taken = board[to].piece; move->taken = board[to].piece;
move->flags = M_NORMAL; move->flags = M_NORMAL;
move->newpos = pos_dup(pos); //move->newpos = pos_dup(pos);
//newpos = move->newpos; //newpos = move->newpos;
//SET_COLOR(newpos->turn, OPPONENT(move->piece)); //SET_COLOR(newpos->turn, OPPONENT(move->piece));
//newpos->turn = OPPONENT(newpos->turn); //newpos->turn = OPPONENT(newpos->turn);
@@ -216,9 +216,9 @@ void move_del(struct list_head *ptr)
# endif # endif
/* TODO: remove move->pos if non null */ /* TODO: remove move->pos if non null */
if (move->newpos) { //if (move->newpos) {
pos_clear(move->newpos); // pos_clear(move->newpos);
} // }
list_del(ptr); list_del(ptr);
pool_add(moves_pool, move); pool_add(moves_pool, move);
return; return;
@@ -250,7 +250,7 @@ static move_t *move_pawn_add(pos_t *pos, piece_t piece, square_t from,
move_t *move; move_t *move;
piece_t promote; piece_t promote;
unsigned char color = COLOR(piece); unsigned char color = COLOR(piece);
pos_t *newpos; //pos_t *newpos;
//if (color != pos->turn) //if (color != pos->turn)
// return NULL; // return NULL;
@@ -260,17 +260,17 @@ static move_t *move_pawn_add(pos_t *pos, piece_t piece, square_t from,
move->flags |= M_PROMOTION; move->flags |= M_PROMOTION;
move->promotion = promote | color; move->promotion = promote | color;
/* fix piece on board and piece list */ /* fix piece on board and piece list */
newpos = move->newpos; //newpos = move->newpos;
newpos->board[to].piece = promote|color; //newpos->board[to].piece = promote|color;
newpos->board[to].s_piece->piece = piece|color; //newpos->board[to].s_piece->piece = piece|color;
newpos->board[to].s_piece->value = piece_details[PIECE(piece)].value; //newpos->board[to].s_piece->value = piece_details[PIECE(piece)].value;
//piece_del(&newpos->board[from].s_piece); //piece_del(&newpos->board[from].s_piece);
} }
} }
} else { } else {
move = move_add(pos, piece, from, to); move = move_add(pos, piece, from, to);
newpos = move->newpos; //newpos = move->newpos;
} }
return move; return move;
@@ -362,9 +362,9 @@ int pseudo_moves_pawn(pos_t *pos, piece_list_t *ppiece, bool doit)
move->taken = taken; move->taken = taken;
/* remove taken pawn from board */ /* remove taken pawn from board */
piece_del(&move->newpos->board[t_square].s_piece->list); //piece_del(&move->newpos->board[t_square].s_piece->list);
move->newpos->board[t_square].piece = 0; //move->newpos->board[t_square].piece = 0;
move->newpos->board[t_square].s_piece = NULL; //move->newpos->board[t_square].s_piece = NULL;
pos->mobility[color]++; pos->mobility[color]++;
count++; count++;
@@ -413,7 +413,7 @@ int pseudo_moves_castle(pos_t *pos, bool color, bool doit)
struct can_castle *can_castle; struct can_castle *can_castle;
bitboard_t controlled; bitboard_t controlled;
bitboard_t occupied = pos->occupied[WHITE] | pos->occupied[BLACK]; bitboard_t occupied = pos->occupied[WHITE] | pos->occupied[BLACK];
pos_t *newpos; //pos_t *newpos;
# ifdef DEBUG_MOVE # ifdef DEBUG_MOVE
log_f(2, "pos:%p turn:%s color:%s\n", log_f(2, "pos:%p turn:%s color:%s\n",
@@ -454,14 +454,14 @@ int pseudo_moves_castle(pos_t *pos, bool color, bool doit)
move = move_add(pos, board[SQ88(4, rank1)].piece, move = move_add(pos, board[SQ88(4, rank1)].piece,
SQ88(4, rank1), SQ88(6, rank1)); SQ88(4, rank1), SQ88(6, rank1));
if (move) { if (move) {
newpos = move->newpos; //newpos = move->newpos;
move->flags |= M_CASTLE_K; move->flags |= M_CASTLE_K;
/* move King rook to column F */ /* move King rook to column F */
newpos->board[SQ88(5, rank1)] = newpos->board[SQ88(7, rank1)]; //newpos->board[SQ88(5, rank1)] = newpos->board[SQ88(7, rank1)];
SETF88(newpos->board[SQ88(5, rank1)].s_piece->square, 5); //SETF88(newpos->board[SQ88(5, rank1)].s_piece->square, 5);
newpos->board[SQ88(7, rank1)].piece = 0; //newpos->board[SQ88(7, rank1)].piece = 0;
newpos->board[SQ88(7, rank1)].s_piece = NULL; //newpos->board[SQ88(7, rank1)].s_piece = NULL;
} }
} }
@@ -487,13 +487,13 @@ next:
move = move_add(pos, board[SQ88(4, rank1)].piece, move = move_add(pos, board[SQ88(4, rank1)].piece,
SQ88(4, rank1), SQ88(2, rank1)); SQ88(4, rank1), SQ88(2, rank1));
if (move) { if (move) {
newpos = move->newpos; //newpos = move->newpos;
move->flags |= M_CASTLE_Q; move->flags |= M_CASTLE_Q;
/* move King rook to column F */ /* move King rook to column F */
newpos->board[SQ88(3, rank1)] = newpos->board[SQ88(0, rank1)]; //newpos->board[SQ88(3, rank1)] = newpos->board[SQ88(0, rank1)];
SETF88(newpos->board[SQ88(3, rank1)].s_piece->square, 3); //SETF88(newpos->board[SQ88(3, rank1)].s_piece->square, 3);
newpos->board[SQ88(0, rank1)].piece = 0; //newpos->board[SQ88(0, rank1)].piece = 0;
newpos->board[SQ88(0, rank1)].s_piece = NULL; //newpos->board[SQ88(0, rank1)].s_piece = NULL;
} }
} }
} }
@@ -622,42 +622,66 @@ int moves_gen(pos_t *pos, bool color, bool doit)
return count; return count;
} }
/* note: for now, a new pos is generated */ /**
struct pos *move_do(pos_t *pos, move_t *move) * move_do() - execute move in a duplicated position.
* @pos: &pos_t struct on which move will be applied
* @move: &move_t struct to apply
*
*/
pos_t *move_do(pos_t *pos, move_t *move)
{ {
# ifdef DEBUG_MOVE # ifdef DEBUG_MOVE
log_f(3, "++++++++++"); log_f(3, "++++++++++");
move_print(move, 0); move_print(move, 0);
log(3, "\n");
# endif # endif
pos_t *newpos = pos_dup(pos);
pos_t *new = pos_dup(pos);
piece_t piece = move->piece; piece_t piece = move->piece;
int color = COLOR(piece); int color = COLOR(piece);
square_t from = move->from, to = move->to; square_t from = move->from, to = move->to;
/* todo: en passant /* todo: en passant, castle
*/ */
SET_COLOR(pos->turn, OPPONENT(color)); /* pos color */ SET_COLOR(new->turn, OPPONENT(color)); /* pos color */
if (move->taken || PIECE(piece) == PAWN) /* 50 moves */ if (move->taken || PIECE(piece) == PAWN) /* 50 moves */
newpos->clock_50 = 0; new->clock_50 = 0;
else else
newpos->clock_50++; new->clock_50++;
if (move->taken) { /* */
piece_del(&newpos->board[to].s_piece->list); if (move->taken) { /* capture */
newpos->occupied[OPPONENT(color)] ^= SQ88_2_BB(to); if (!(move->flags & M_EN_PASSANT)) {
piece_del(&new->board[to].s_piece->list);
new->board[to].piece = 0;
new->occupied[OPPONENT(color)] ^= SQ88_2_BB(to);
new->bb[OPPONENT(color)][PIECETOBB(piece)] ^= SQ88_2_BB(to);
} else {
unsigned char ep_file = F88(pos->en_passant);
square_t ep_grab = color == WHITE ? SQ88(ep_file, 4): SQ88(ep_file, 3);
log_f(1, "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)] ^= SQ88_2_BB(ep_grab);
new->bb[OPPONENT(color)][PIECETOBB(piece)] ^= SQ88_2_BB(ep_grab);
} }
newpos->board[to] = newpos->board[from];
}
new->board[to] = new->board[from];
/* fix dest square */ /* fix dest square */
newpos->board[to].s_piece->square = to; new->board[to].s_piece->square = to;
/* replace old occupied bitboard by new one */ /* replace old occupied bitboard by new one */
newpos->occupied[color] ^= SQ88_2_BB(from); new->occupied[color] ^= SQ88_2_BB(from);
newpos->occupied[color] |= SQ88_2_BB(to); new->occupied[color] |= SQ88_2_BB(to);
new->bb[color][PIECETOBB(piece)] ^= SQ88_2_BB(from);
new->bb[color][PIECETOBB(piece)] |= SQ88_2_BB(to);
/* always make "from" square empty */ /* always make "from" square empty */
newpos->board[from].piece = 0; new->board[from].piece = 0;
newpos->board[from].s_piece = NULL; new->board[from].s_piece = NULL;
return 0; return new;
} }
void move_undo(pos_t *pos, __unused move_t *move) void move_undo(pos_t *pos, __unused move_t *move)

6
src/move.h
View File

@@ -40,11 +40,11 @@ typedef unsigned char move_flags_t;
typedef struct move_s { typedef struct move_s {
piece_t piece; piece_t piece;
square_t from, to; square_t from, to;
piece_t taken; /* removed piece */ piece_t taken; /* captured piece */
piece_t promotion; /* promoted piece */ piece_t promotion; /* promoted piece */
move_flags_t flags; move_flags_t flags;
struct list_head list; /* next move */ struct list_head list; /* next move */
struct pos_s *newpos; /* resulting position */ //struct pos_s *newpos; /* resulting position */
} move_t; } move_t;
pool_t *moves_pool_init(); pool_t *moves_pool_init();
@@ -60,7 +60,7 @@ int pseudo_moves_gen(pos_t *pos, piece_list_t *piece, bool doit);
int pseudo_moves_pawn(pos_t *pos, piece_list_t *piece, bool doit); int pseudo_moves_pawn(pos_t *pos, piece_list_t *piece, bool doit);
int moves_gen(pos_t *pos, bool color, bool doit); int moves_gen(pos_t *pos, bool color, bool doit);
struct pos *move_do(pos_t *pos, move_t *move); pos_t *move_do(pos_t *pos, move_t *move);
void move_undo(pos_t *pos, move_t *move); void move_undo(pos_t *pos, move_t *move);
#endif /* MODE_H */ #endif /* MODE_H */

25
src/position.c
View File

@@ -185,10 +185,20 @@ pos_t *pos_get()
return pos; return pos;
} }
/* TODO: merge with pos_get - NULL for init, non null for duplicate */ /**
* pos_dup() - duplicate a position.
* @pos: &position to duplicate.
*
* New position is the same as source one, with duplicated pieces list
* and empty moves list.
*
* @return: The new position.
*
* TODO: merge with pos_get - NULL for init, non null for duplicate
*/
pos_t *pos_dup(pos_t *pos) pos_t *pos_dup(pos_t *pos)
{ {
struct list_head *p_cur, *tmp, *piece_list; struct list_head *p_cur, *piece_list;
piece_list_t *oldpiece; piece_list_t *oldpiece;
board_t *board; board_t *board;
pos_t *new = pool_get(pos_pool); pos_t *new = pool_get(pos_pool);
@@ -196,20 +206,17 @@ pos_t *pos_dup(pos_t *pos)
if (new) { if (new) {
board = new->board; board = new->board;
*new = *pos; *new = *pos;
INIT_LIST_HEAD(&new->pieces[WHITE]); for (int color=0; color<2; ++color) {
INIT_LIST_HEAD(&new->pieces[BLACK]); INIT_LIST_HEAD(&new->pieces[color]);
INIT_LIST_HEAD(&new->moves[WHITE]); INIT_LIST_HEAD(&new->moves[color]);
INIT_LIST_HEAD(&new->moves[BLACK]);
/* duplicate piece list */ /* duplicate piece list */
for (int color=0; color<2; ++color) {
piece_list = &pos->pieces[color]; /* white/black piece list */ piece_list = &pos->pieces[color]; /* white/black piece list */
list_for_each_safe(p_cur, tmp, piece_list) { list_for_each(p_cur, piece_list) {
oldpiece = list_entry(p_cur, piece_list_t, list); oldpiece = list_entry(p_cur, piece_list_t, list);
board[oldpiece->square].s_piece = board[oldpiece->square].s_piece =
piece_add(new, oldpiece->piece, oldpiece->square); piece_add(new, oldpiece->piece, oldpiece->square);
} }
} }
} }