// board.cpp
#include "common.h"
// initial position of a chess game :
//
// +-----------------+
// 8| R K B Q K B K R | - black
// 7| P P P P P P P P |
// 6| |
// 5| |
// 4| |
// 3| |
// 2| P P P P P P P P |
// 1| R K B Q K B K R | - white
// +-----------------+
// a b c d e f g h
bool Board_Init (board_t *board, int white_playertype, int black_playertype, wchar_t *game_rules, wchar_t *fen_string)
{
// this function initializes a new chess game
bool is_success;
// initialize the moves array and blank out the first move's structure
board->moves = (boardmove_t *) SAFE_malloc (1, sizeof (boardmove_t), false);
memset (&board->moves[0], 0, sizeof (boardmove_t));
board->viewed_move = 0;
board->move_count = 1;
board->game_state = STATE_UNKNOWN; // game has not started yet
board->lastmove_time = 0.0f;
// initialize this board's players
Player_Init (&board->players[COLOR_WHITE], COLOR_WHITE, white_playertype);
Player_Init (&board->players[COLOR_BLACK], COLOR_BLACK, black_playertype);
// can we NOT successfully initialize from the given FEN string ?
is_success = Move_SetupFromFEN (&board->moves[0], fen_string);
if (!is_success)
Move_SetupFromFEN (&board->moves[0], FENSTARTUP_STANDARDCHESS); // if so, fallback to standard chess table
// reset all selection and hovering information
Board_SetSelectedAndHovered (board, -1, -1, -1, -1);
// set the game rules to the specified one
wcscpy_s (board->game_rules, WCHAR_SIZEOF (board->game_rules), game_rules);
// if white is human AND black is computer AND white prefers to play black, swap sides
if ((white_playertype == PLAYER_HUMAN) && (black_playertype == PLAYER_COMPUTER) && options.want_playblackside)
board->want_playerswap = true; // remember to swap sides
// notify that board was just set up
board->was_setup = true;
board->players[COLOR_WHITE].should_wakeup = true;
board->players[COLOR_BLACK].should_wakeup = true;
board->reevaluate = true;
return (is_success); // finished
}
void Board_Shutdown (board_t *board)
{
// this function ends a chess game
boardmove_t *move;
int move_index;
// reset the moves array
for (move_index = 0; move_index < board->move_count; move_index++)
{
move = &board->moves[move_index]; // quick access to move
SAFE_free ((void **) &move->sides[COLOR_WHITE].takenparts); // free white's taken parts
SAFE_free ((void **) &move->sides[COLOR_BLACK].takenparts); // free black's taken parts
SAFE_free ((void **) &move->comment); // free each move comment
}
SAFE_free ((void **) &board->moves); // and the moves array itself
board->viewed_move = -1;
board->move_count = 0;
// release players
Player_Shutdown (&board->players[COLOR_WHITE]);
Player_Shutdown (&board->players[COLOR_BLACK]);
// game has not started yet
board->game_state = STATE_UNKNOWN;
return; // that's all there is
}
bool Board_Reset (board_t *board, wchar_t *fen_string)
{
// this function initializes a chess game according to a FEN string, WITHOUT changing the players
boardmove_t *move;
int move_index;
bool is_success;
// reset the moves array
for (move_index = 0; move_index < board->move_count; move_index++)
{
move = &board->moves[move_index]; // quick access to move
SAFE_free ((void **) &move->sides[COLOR_WHITE].takenparts); // free white's taken parts
SAFE_free ((void **) &move->sides[COLOR_BLACK].takenparts); // free black's taken parts
SAFE_free ((void **) &move->comment); // free each move comment
}
// resize the moves array and blank out the first move's structure
board->moves = (boardmove_t *) SAFE_realloc (board->moves, board->move_count, 1, sizeof (boardmove_t), false);
memset (&board->moves[0], 0, sizeof (boardmove_t));
board->viewed_move = 0;
board->move_count = 1;
board->game_state = STATE_UNKNOWN; // game has not started yet
board->lastmove_time = 0.0f;
// reset the players' view angles
Player_ResetView (&board->players[COLOR_BLACK]);
Player_ResetView (&board->players[COLOR_WHITE]);
// can we NOT successfully initialize from the given FEN string ?
is_success = Move_SetupFromFEN (&board->moves[0], fen_string);
if (!is_success)
Move_SetupFromFEN (&board->moves[0], FENSTARTUP_STANDARDCHESS); // if so, fallback to standard chess table
// reset all selection and hovering information
Board_SetSelectedAndHovered (board, -1, -1, -1, -1);
// notify that board was just set up
board->was_setup = true;
board->players[COLOR_WHITE].should_wakeup = true;
board->players[COLOR_BLACK].should_wakeup = true;
return (is_success); // finished
}
bool Board_Think (board_t *board)
{
// helper function to make both a board's players think
bool do_update;
do_update = false; // don't update scene until told otherwise
do_update |= Player_Think (&board->players[COLOR_WHITE]); // make white player think
do_update |= Player_Think (&board->players[COLOR_BLACK]); // make black player think
// do the board sides need to be swapped ?
if (board->want_playerswap)
{
Board_SwapSides (board); // if so, swap board sides
board->want_playerswap = false; // don't do this all day long
do_update |= true; // and update the scene
}
// clear board setup notification
board->was_setup = false;
return (do_update); // finished, return whether we update the scene or not
}
void Board_SwapSides (board_t *board)
{
// helper function to swap a board's sides
player_t player_to_swap;
// THREAD-SAFE: wait until all buffers are unlocked
while (board->players[COLOR_BLACK].sendbuffer_locked
|| board->players[COLOR_WHITE].sendbuffer_locked)
Sleep (10); // test again in 10 milliseconds
// lock all the buffers at once
board->players[COLOR_BLACK].sendbuffer_locked = true;
board->players[COLOR_WHITE].sendbuffer_locked = true;
// swap players structures
memcpy (&player_to_swap, &board->players[COLOR_BLACK], sizeof (player_t));
memcpy (&board->players[COLOR_BLACK], &board->players[COLOR_WHITE], sizeof (player_t));
memcpy (&board->players[COLOR_WHITE], &player_to_swap, sizeof (player_t));
// restore correct colors
board->players[COLOR_BLACK].color = COLOR_BLACK;
board->players[COLOR_WHITE].color = COLOR_WHITE;
// turn their point of view 180 degrees
board->players[COLOR_BLACK].view_yaw = WrapAngle (board->players[COLOR_BLACK].view_yaw + 180.0f);
board->players[COLOR_WHITE].view_yaw = WrapAngle (board->players[COLOR_WHITE].view_yaw + 180.0f);
// now unlock all the players' buffers and have them sleep for 2 seconds
board->players[COLOR_BLACK].sendbuffer_locked = false;
board->players[COLOR_WHITE].sendbuffer_locked = false;
board->players[COLOR_BLACK].sleep_time = current_time + 2.0f;
board->players[COLOR_WHITE].sleep_time = current_time + 2.0f;
board->reevaluate = true; // remember to reevaluate this board
return; // finished
}
void Board_EnterSetupPosition (board_t *board)
{
// helper function to switch to board setup position mode
memset (&board->moves[0].slots, 0, sizeof (board->moves[0].slots)); // erase all of start move's slots
the_board.game_state = STATE_SETUPPOSITION; // game not started yet, enter board setup mode
the_board.reevaluate = true; // evaluate board again
// display the "please choose start position" phrase in the middle of the screen
Scene_UpdateText (&the_scene.gui.central_text, RGBA_TO_RGBACOLOR (255, 255, 255, 191), DURATION_INFINITE, true, L"\n\n\n\n\n\n%s", LOCALIZE (L"SetupMode"));
the_scene.gui.partspick_selectedpart = ' '; // no selected part yet
the_scene.update = true; // and update the 3D scene
return; // finished
}
void Board_SetSelectedAndHovered (board_t *board, int selected_line, int selected_column, int hovered_line, int hovered_column)
{
// helper function to forcibly set a board's selected and hovered slots (respectively move source and destination)
board->selected_position[0] = selected_line;
board->selected_position[1] = selected_column;
board->hovered_position[0] = hovered_line;
board->hovered_position[1] = hovered_column;
return; // finished
}
char Board_ColorToMove (board_t *board)
{
// helper function that returns the current color to move for the given board
// NOTE: since the return value may be used to address an array, DO NOT return an invalid value !
if ((board->moves == NULL) || (board->move_count < 1))
return (COLOR_WHITE); // consistency check
return (1 - board->moves[the_board.move_count - 1].color); // return the opposite color of the last move's color
}
void Board_AppendMove (board_t *board, int from_line, int from_column, int to_line, int to_column, char promotion_type, wchar_t *comment)
{
// this function processes a part movement on the specified board.
boardmove_t *last_move;
boardmove_t new_move;
int side_index;
boardside_t *playing_side;
boardside_t *opposing_side;
// get a quick access to board's last move
last_move = &board->moves[board->move_count - 1];
// prepare the new move
memset (&new_move, 0, sizeof (new_move));
new_move.color = 1 - last_move->color; // switch colors
new_move.part = last_move->slots[from_line][from_column].part; // save the move part type
new_move.promotion_type = promotion_type; // save the promotion type
new_move.has_captured = false; // assume there's no capture until told otherwise
new_move.is_enpassant = false; // assume no en passant coup is played until told otherwise
new_move.is_check = false; // assume no check until told otherwise
new_move.is_stalemate = false; // assume no stalemate until told otherwise
new_move.source[0] = from_line; // save the move source line and column
new_move.source[1] = from_column;
new_move.target[0] = to_line; // save the move target line and column
new_move.target[1] = to_column;
new_move.pgntext[0] = 0; // will be evaluated at the end of this function
new_move.comment = NULL; // assume no comment until told otherwise
new_move.comment_size = 0;
for (side_index = 0; side_index < 2; side_index++)
{
new_move.sides[side_index].takenparts = (unsigned char *) SAFE_malloc (last_move->sides[side_index].takenpart_count, sizeof (unsigned char), false);
memcpy (new_move.sides[side_index].takenparts, last_move->sides[side_index].takenparts, last_move->sides[side_index].takenpart_count * sizeof (unsigned char));
new_move.sides[side_index].takenpart_count = last_move->sides[side_index].takenpart_count; // copy side's taken parts
new_move.sides[side_index].shortcastle_allowed = last_move->sides[side_index].shortcastle_allowed; // copy whether side can castle short
new_move.sides[side_index].longcastle_allowed = last_move->sides[side_index].longcastle_allowed; // copy whether side can castle long
}
memcpy (&new_move.slots, last_move->slots, sizeof (last_move->slots)); // copy table disposition
new_move.fen_string[0] = 0; // will be evaluated at the end of this function
// get a quick access to current and opposing sides
playing_side = &new_move.sides[new_move.color];
opposing_side = &new_move.sides[1 - new_move.color];
// is a piece being taken ?
if (new_move.slots[to_line][to_column].part != PART_NONE)
{
// was the piece being taken a rook ?
if (new_move.slots[to_line][to_column].part == PART_ROOK)
{
// was it a white tower in A1, a white tower in A7, a black tower in H1 or a black tower in H7 ?
if ((new_move.slots[to_line][to_column].color == COLOR_WHITE) && (to_line == 0) && (to_column == 0))
new_move.sides[COLOR_WHITE].longcastle_allowed = false; // our opponent can no longer castle queenside
else if ((new_move.slots[to_line][to_column].color == COLOR_WHITE) && (to_line == 0) && (to_column == 7))
new_move.sides[COLOR_WHITE].shortcastle_allowed = false; // our opponent can no longer castle bishopside
else if ((new_move.slots[to_line][to_column].color == COLOR_BLACK) && (to_line == 7) && (to_column == 0))
new_move.sides[COLOR_BLACK].longcastle_allowed = false; // our opponent can no longer castle queenside
else if ((new_move.slots[to_line][to_column].color == COLOR_BLACK) && (to_line == 7) && (to_column == 7))
new_move.sides[COLOR_BLACK].shortcastle_allowed = false; // our opponent can no longer castle bishopside
}
// resize this players' taken parts array and move the taken piece in it
playing_side->takenparts = (unsigned char *) SAFE_realloc (playing_side->takenparts, playing_side->takenpart_count, playing_side->takenpart_count + 1, sizeof (unsigned char), true);
playing_side->takenparts[playing_side->takenpart_count] = new_move.slots[to_line][to_column].part;
playing_side->takenpart_count++; // player has now taken one piece more
new_move.has_captured = true; // remember a part has just been captured
}
// else is it an "en passant" coup ?
else if ((new_move.slots[from_line][from_column].part == PART_PAWN) // we're a pawn
&& (abs (to_column - from_column) == 1) // we moved diagonally
&& (new_move.slots[to_line][to_column].part == PART_NONE) // no part on destination
&& (new_move.slots[from_line][to_column].part == PART_PAWN)) // but a pawn next to us
{
// resize this players' taken parts array and move the taken piece in it
playing_side->takenparts = (unsigned char *) SAFE_realloc (playing_side->takenparts, playing_side->takenpart_count, playing_side->takenpart_count + 1, sizeof (unsigned char), true);
playing_side->takenparts[playing_side->takenpart_count] = new_move.slots[from_line][to_column].part;
memset (&new_move.slots[from_line][to_column], 0, sizeof (boardslot_t)); // "en passant" coup
playing_side->takenpart_count++; // player has now taken one piece more
new_move.has_captured = true; // remember a part has just been captured
new_move.is_enpassant = true; // and that it's an en passant coup
}
// has a promotion been specified ?
if (promotion_type != PART_NONE)
Move_SetSlot (&new_move, from_line, from_column, new_move.color, promotion_type); // promote the pawn to the desired type
// was the moved part the king ? if so, player can't castle anymore
if (new_move.slots[from_line][from_column].part == PART_KING)
{
// did the king castle queenside ? or did it castle bishopside ?
if ((from_column == 4) && (to_column == 2))
{
// move the rook from A to D (0 -> 3) and wipe its previous location
memcpy (&new_move.slots[to_line][3], &new_move.slots[from_line][0], sizeof (boardslot_t));
memset (&new_move.slots[from_line][0], 0, sizeof (boardslot_t));
}
else if ((from_column == 4) && (to_column == 6))
{
// move the rook from H to F (7 -> 5) and wipe its previous location
memcpy (&new_move.slots[to_line][5], &new_move.slots[from_line][7], sizeof (boardslot_t));
memset (&new_move.slots[from_line][7], 0, sizeof (boardslot_t));
}
// no matter whether it castled or not, remember this king cannot castle anymore
playing_side->shortcastle_allowed = false;
playing_side->longcastle_allowed = false;
}
// else was it the rook ?
else if (new_move.slots[from_line][from_column].part == PART_ROOK)
{
// was the tower in A ? or was it in H ?
if (from_column == 0)
playing_side->longcastle_allowed = false; // player can no longer castle queenside
else if (from_column == 7)
playing_side->shortcastle_allowed = false; // player can no longer castle bishopside
}
// move the part and erase the starting slot
memcpy (&new_move.slots[to_line][to_column], &new_move.slots[from_line][from_column], sizeof (boardslot_t));
memset (&new_move.slots[from_line][from_column], 0, sizeof (boardslot_t));
// does the new move have a comment ? if so, save it
if ((comment != NULL) && (comment[0] != 0))
{
new_move.comment_size = wcslen (comment) + 1; // save this move's comment and the size of the mallocated space
new_move.comment = (wchar_t *) SAFE_malloc (new_move.comment_size, sizeof (wchar_t), false);
wcscpy_s (new_move.comment, new_move.comment_size, comment); // copy comment
}
// evaluate check and stalemate status
new_move.is_check = Move_IsCheck (&new_move, 1 - new_move.color); // save whether opponent is in check or not
new_move.is_stalemate = Move_IsStaleMate (&new_move, 1 - new_move.color); // save whether opponent is stalemate
// describe our move in Standard Abbreviated Notation and describe the resulting table in Forsyth-Edwards Notation
Move_DescribeInSAN (&new_move, last_move, new_move.pgntext, WCHAR_SIZEOF (new_move.pgntext), false); // don't use the localized part abbreviations
Move_DescribeInFEN (&new_move);
// resize the previous moves array and insert our new move at the end of it
board->moves = (boardmove_t *) SAFE_realloc (board->moves, board->move_count, board->move_count + 1, sizeof (boardmove_t), false);
memcpy (&board->moves[board->move_count], &new_move, sizeof (boardmove_t));
board->move_count++; // we know now one previous move more
board->viewed_move = board->move_count - 1; // set the move to be viewed to be the last move
// if the game hadn't started yet, remember it has now
if (board->game_state == STATE_UNKNOWN)
board->game_state = STATE_PLAYING;
// remember the last move time
board->lastmove_time = current_time;
// reset stoppage time
stoppage_time = 0;
// remember the game state should be reevaluated
board->reevaluate = true;
return; // finished
}