336 lines
12 KiB
C
336 lines
12 KiB
C
|
#include "game_state.h"
|
||
|
|
#include "stdio.h"
|
||
|
|
#include <string.h>
|
||
|
|
#include "pawn.h"
|
||
|
|
#include "king.h"
|
||
|
|
#include "piece_logic.h"
|
||
|
|
|
||
|
|
static uint8_t Saved_Binary_Board[8] = {0};
|
||
|
|
static Game_State_t Game_State = {
|
||
|
|
.game_over = false,
|
||
|
|
.error_detected = false,
|
||
|
|
.player_turn = WHITE_TURN,
|
||
|
|
.turn_state = BEGINNING,
|
||
|
|
.board_state = {0},
|
||
|
|
.board_pieces = {0},
|
||
|
|
.selected_peice = SQUARE_EMPTY,
|
||
|
|
.castling_allowed = {{true, true},{true, true}},
|
||
|
|
};
|
||
|
|
static uint8_t Error_Count = 0u;
|
||
|
|
static bool Check[2u] = {false, false};
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Function for clearing all of the lights on the board. Except for error moves.
|
||
|
|
* @retval None
|
||
|
|
*/
|
||
|
|
void clear_board_state(void)
|
||
|
|
{
|
||
|
|
for (size_t i = 0; i < 8; i++)
|
||
|
|
{
|
||
|
|
for (size_t j = 0; j < 8; j++)
|
||
|
|
{
|
||
|
|
if(Game_State.board_state[i*8+j] != ERROR_MOVE)
|
||
|
|
{
|
||
|
|
Game_State.board_state[i*8+j] = LIGHT_OFF;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
bool Set_Light(uint8_t piece, uint8_t row, uint8_t column, uint8_t state)
|
||
|
|
{
|
||
|
|
bool ret_val = false;
|
||
|
|
if (!Check_If_Move_Caused_Check(piece, row, column, &Game_State))
|
||
|
|
{
|
||
|
|
Game_State.board_state[row*8+column] = state;
|
||
|
|
ret_val = true;
|
||
|
|
}
|
||
|
|
return ret_val;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Function for switching the players turn. Incharge of handling the state machine reset.
|
||
|
|
*/
|
||
|
|
static void Switch_Turns(void)
|
||
|
|
{
|
||
|
|
Game_State.turn_state = BEGINNING;
|
||
|
|
Game_State.player_turn = !Game_State.player_turn;
|
||
|
|
// Square is safe assumes the other team is trying to attack the square so for example at the end of
|
||
|
|
// White's turn we want to see if the black king is now in check, so we will switch teams and then
|
||
|
|
// Check if the current kings locations is safe. If it is safe then check is false, if it isnt safe then check is true.
|
||
|
|
uint8_t white_black_idx = Game_State.player_turn ? 0u : 1u;
|
||
|
|
|
||
|
|
Check[white_black_idx] = Check_Current_Players_Check_Status(&Game_State);
|
||
|
|
|
||
|
|
//Last thing we need to check before switching turns is to check if the game is over.
|
||
|
|
bool player_can_play = Check_If_Player_Can_Move(Game_State.player_turn, &Game_State);
|
||
|
|
if(!player_can_play)
|
||
|
|
{
|
||
|
|
Game_State.game_over = true;
|
||
|
|
Game_State.player_turn = !Game_State.player_turn;
|
||
|
|
Game_State.error_detected = !Check[white_black_idx];
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Function for toggeling a square's state.
|
||
|
|
* @param row_idx: row location that was toggled.
|
||
|
|
* @param column_idx: column location that was toggled.
|
||
|
|
* @retval None
|
||
|
|
*/
|
||
|
|
static void Board_Square_Was_Toggled(uint8_t row_idx, uint8_t col_idx)
|
||
|
|
{
|
||
|
|
if (Game_State.error_detected)
|
||
|
|
{
|
||
|
|
if (Game_State.board_state[row_idx*8+col_idx] == PIECE_ORIGIN)
|
||
|
|
{
|
||
|
|
Game_State.board_pieces[row_idx*8+col_idx] = Game_State.selected_peice;
|
||
|
|
Game_State.selected_peice = SQUARE_EMPTY;
|
||
|
|
clear_board_state();
|
||
|
|
Game_State.turn_state = BEGINNING;
|
||
|
|
}
|
||
|
|
else if (Game_State.board_state[row_idx*8+col_idx] == PIECE_NEEDS_TO_BE_HERE)
|
||
|
|
{
|
||
|
|
Game_State.board_pieces[row_idx*8+col_idx] = Game_State.selected_peice;
|
||
|
|
Game_State.selected_peice = SQUARE_EMPTY;
|
||
|
|
Game_State.board_state[row_idx*8+col_idx] = LIGHT_OFF;
|
||
|
|
|
||
|
|
if (Game_State.selected_peice == SQUARE_EMPTY)
|
||
|
|
{
|
||
|
|
Game_State.turn_state = BEGINNING;
|
||
|
|
Game_State.player_turn = !Game_State.player_turn;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (Game_State.board_state[row_idx*8+col_idx] == ERROR_MOVE)
|
||
|
|
{
|
||
|
|
Error_Count--;
|
||
|
|
Game_State.board_state[row_idx*8+col_idx] = LIGHT_OFF;
|
||
|
|
/* All Errors have been rectified so we can go back to where we were.*/
|
||
|
|
if(Error_Count == 0u)
|
||
|
|
{
|
||
|
|
Game_State.error_detected = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Error_Count++;
|
||
|
|
Game_State.board_state[row_idx*8+col_idx] = ERROR_MOVE;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
switch (Game_State.turn_state)
|
||
|
|
{
|
||
|
|
/* We are waiting till the player who's turn it is picks up a piece that is on their team */
|
||
|
|
case BEGINNING:
|
||
|
|
{
|
||
|
|
if ((Game_State.board_pieces[row_idx*8+col_idx] != SQUARE_EMPTY) && (white_team(Game_State.board_pieces[row_idx*8+col_idx]) == Game_State.player_turn))
|
||
|
|
{
|
||
|
|
Game_State.selected_peice = Game_State.board_pieces[row_idx*8+col_idx];
|
||
|
|
Game_State.board_pieces[row_idx*8+col_idx] = SQUARE_EMPTY;
|
||
|
|
(void)Mark_Potential_Moves(Game_State.selected_peice, col_idx, row_idx, &Game_State);
|
||
|
|
Game_State.board_state[row_idx*8+col_idx] = PIECE_ORIGIN;
|
||
|
|
Game_State.turn_state = IN_PROGRESS;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if(!Converting_Pawn_If_Applicable(row_idx, col_idx, &Game_State))
|
||
|
|
{
|
||
|
|
Game_State.error_detected = true;
|
||
|
|
Game_State.board_state[row_idx*8+col_idx] = ERROR_MOVE;
|
||
|
|
Error_Count++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
/* Person is in the middle of taking a turn for example they might already have a piece in the hand*/
|
||
|
|
case IN_PROGRESS:
|
||
|
|
{
|
||
|
|
if (Game_State.board_state[row_idx*8+col_idx] == POTENTIAL_MOVE)
|
||
|
|
{
|
||
|
|
Check_If_Moving_King(row_idx, col_idx, &Game_State);
|
||
|
|
Check_If_Converting_Pawn(row_idx, col_idx, &Game_State);
|
||
|
|
Game_State.board_pieces[row_idx*8+col_idx] = Game_State.selected_peice;
|
||
|
|
Game_State.selected_peice = SQUARE_EMPTY;
|
||
|
|
clear_board_state();
|
||
|
|
Switch_Turns();
|
||
|
|
}
|
||
|
|
else if (Game_State.board_state[row_idx*8+col_idx] == POTENTIAL_TAKE)
|
||
|
|
{
|
||
|
|
Game_State.board_pieces[row_idx*8+col_idx] = SQUARE_EMPTY;
|
||
|
|
Game_State.turn_state = FINALIZING;
|
||
|
|
clear_board_state();
|
||
|
|
Game_State.board_state[row_idx*8+col_idx] = PIECE_NEEDS_TO_BE_HERE;
|
||
|
|
}
|
||
|
|
else if (Game_State.board_state[row_idx*8+col_idx] == PIECE_ORIGIN)
|
||
|
|
{
|
||
|
|
Game_State.board_pieces[row_idx*8+col_idx] = Game_State.selected_peice;
|
||
|
|
Game_State.selected_peice = SQUARE_EMPTY;
|
||
|
|
clear_board_state();
|
||
|
|
Game_State.turn_state = BEGINNING;
|
||
|
|
}
|
||
|
|
else if (Game_State.board_state[row_idx*8+col_idx] == POTENTIAL_CASTLE)
|
||
|
|
{
|
||
|
|
Check_If_Moving_King(row_idx, col_idx, &Game_State);
|
||
|
|
Game_State.board_pieces[row_idx*8+col_idx] = Game_State.selected_peice;
|
||
|
|
Game_State.selected_peice = SQUARE_EMPTY;
|
||
|
|
clear_board_state();
|
||
|
|
if(col_idx == 2u)
|
||
|
|
{
|
||
|
|
Game_State.board_state[row_idx*8+3u] = PIECE_NEEDS_TO_BE_HERE;
|
||
|
|
Game_State.board_state[row_idx*8+0u] = PIECE_NEEDS_TO_BE_REMOVED;
|
||
|
|
}
|
||
|
|
else if(col_idx == 6u)
|
||
|
|
{
|
||
|
|
Game_State.board_state[row_idx*8+5u] = PIECE_NEEDS_TO_BE_HERE;
|
||
|
|
Game_State.board_state[row_idx*8+7u] = PIECE_NEEDS_TO_BE_REMOVED;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
/* Do nothing. */
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
else if (Game_State.board_state[row_idx*8+col_idx] == PIECE_NEEDS_TO_BE_REMOVED)
|
||
|
|
{
|
||
|
|
Game_State.selected_peice = Game_State.board_pieces[row_idx*8+col_idx];
|
||
|
|
Game_State.board_pieces[row_idx*8+col_idx] = SQUARE_EMPTY;
|
||
|
|
Game_State.board_state[row_idx*8+col_idx] = LIGHT_OFF;
|
||
|
|
Game_State.turn_state = FINALIZING;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Game_State.error_detected = true;
|
||
|
|
Game_State.board_state[row_idx*8+col_idx] = ERROR_MOVE;
|
||
|
|
Error_Count++;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
/* Player still needs to do something to complete their turn, like complete castle, en pessant, or converting a pawn*/
|
||
|
|
case FINALIZING:
|
||
|
|
{
|
||
|
|
if (Game_State.board_state[row_idx*8+col_idx] == PIECE_NEEDS_TO_BE_HERE)
|
||
|
|
{
|
||
|
|
Check_If_Moving_King(row_idx, col_idx, &Game_State);
|
||
|
|
Check_If_Converting_Pawn(row_idx, col_idx, &Game_State);
|
||
|
|
Game_State.board_pieces[row_idx*8+col_idx] = Game_State.selected_peice;
|
||
|
|
Game_State.selected_peice = SQUARE_EMPTY;
|
||
|
|
Game_State.board_state[row_idx*8+col_idx] = LIGHT_OFF;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if(!Converting_Pawn_If_Applicable(row_idx, col_idx, &Game_State))
|
||
|
|
{
|
||
|
|
Game_State.error_detected = true;
|
||
|
|
Game_State.board_state[row_idx*8+col_idx] = ERROR_MOVE;
|
||
|
|
Error_Count++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (Game_State.selected_peice == SQUARE_EMPTY)
|
||
|
|
{
|
||
|
|
Switch_Turns();
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default:
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void Board_get_lights_and_state(uint8_t * board_state, uint8_t * board_pieces)
|
||
|
|
{
|
||
|
|
memcpy(board_state, Game_State.board_state, sizeof(Game_State.board_state));
|
||
|
|
memcpy(board_pieces, Game_State.board_pieces, sizeof(Game_State.board_pieces));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief The Board changed so now we have to see what is different and act accordingly.
|
||
|
|
* @note Yes i know the design of this seems really bad but it's important to remember this is supposed to simulate the chess board I'm creating.
|
||
|
|
* so I'm designing it this way because of the hardware that I'm using.
|
||
|
|
* @retval None
|
||
|
|
*/
|
||
|
|
void Board_Changed(uint8_t current_binary_board[8])
|
||
|
|
{
|
||
|
|
for (uint8_t j = 0u; j < 8u; j++)
|
||
|
|
{
|
||
|
|
uint8_t difference = (current_binary_board[j] ^ Saved_Binary_Board[j]);
|
||
|
|
if (difference != 0u)
|
||
|
|
{
|
||
|
|
for (uint8_t i = 0u; i < 8u; i++)
|
||
|
|
{
|
||
|
|
if((difference & (1u << i)) != 0u)
|
||
|
|
{
|
||
|
|
Board_Square_Was_Toggled(j, i);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Saved_Binary_Board[j] = current_binary_board[j];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Function for initializing the board
|
||
|
|
* @note
|
||
|
|
* @retval None
|
||
|
|
*/
|
||
|
|
void game_state_init(void)
|
||
|
|
{
|
||
|
|
for (uint8_t i = 0u; i < 8u; i++)
|
||
|
|
{
|
||
|
|
for (uint8_t j = 0u; j < 8u; j++)
|
||
|
|
{
|
||
|
|
Game_State.board_pieces[i*8+j] = SQUARE_EMPTY;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Saved_Binary_Board[0] = 0xFF;
|
||
|
|
Saved_Binary_Board[1] = 0xFF;
|
||
|
|
Saved_Binary_Board[6] = 0xFF;
|
||
|
|
Saved_Binary_Board[7] = 0xFF;
|
||
|
|
|
||
|
|
//Place black pieces
|
||
|
|
Game_State.board_pieces[0*8+0] = ROOK_BLACK;
|
||
|
|
Game_State.board_pieces[0*8+7] = ROOK_BLACK;
|
||
|
|
Game_State.board_pieces[0*8+1] = KNIGHT_BLACK;
|
||
|
|
Game_State.board_pieces[0*8+6] = KNIGHT_BLACK;
|
||
|
|
Game_State.board_pieces[0*8+2] = BISHOP_BLACK;
|
||
|
|
Game_State.board_pieces[0*8+5] = BISHOP_BLACK;
|
||
|
|
Game_State.board_pieces[0*8+3] = QUEEN_BLACK;
|
||
|
|
Game_State.board_pieces[0*8+4] = KING_BLACK;
|
||
|
|
Game_State.board_pieces[7*8+0] = ROOK_WHITE;
|
||
|
|
Game_State.board_pieces[7*8+7] = ROOK_WHITE;
|
||
|
|
Game_State.board_pieces[7*8+1] = KNIGHT_WHITE;
|
||
|
|
Game_State.board_pieces[7*8+6] = KNIGHT_WHITE;
|
||
|
|
Game_State.board_pieces[7*8+2] = BISHOP_WHITE;
|
||
|
|
Game_State.board_pieces[7*8+5] = BISHOP_WHITE;
|
||
|
|
Game_State.board_pieces[7*8+3] = QUEEN_WHITE;
|
||
|
|
Game_State.board_pieces[7*8+4] = KING_WHITE;
|
||
|
|
|
||
|
|
for (uint8_t i = 0; i < 8; i++)
|
||
|
|
{
|
||
|
|
Game_State.board_pieces[1*8+i] = PAWN_BLACK;
|
||
|
|
Game_State.board_pieces[6*8+i] = PAWN_WHITE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
Game_State_t Board_get_game_state(void)
|
||
|
|
{
|
||
|
|
return Game_State;
|
||
|
|
}
|
||
|
|
|
||
|
|
|