From d97d9dc34bc413de63a790bf627ddbee0cb89d59 Mon Sep 17 00:00:00 2001 From: Unbewohnte Date: Tue, 19 Dec 2023 21:14:52 +0300 Subject: [PATCH] feat: board: get any piece positions on board --- TODO | 3 +- src/board.c | 295 +++++++++++++++++++++++++++++++++++++++++++++++++--- src/board.h | 38 ++++++- 3 files changed, 316 insertions(+), 20 deletions(-) diff --git a/TODO b/TODO index d1838c6..a886bea 100644 --- a/TODO +++ b/TODO @@ -1,3 +1,4 @@ 1. Algebraic notation: notation_move_to_string, documentation 2. Board: board_is_move_legal, add other piece's moves -3. Chess: output special error message for each type of illegal move so it's clear what went wrong \ No newline at end of file +3. Chess: output special error message for each type of illegal move so it's clear what went wrong +4. board_get_pawn_moves - add en passant \ No newline at end of file diff --git a/src/board.c b/src/board.c index 04c6f18..d5df37d 100644 --- a/src/board.c +++ b/src/board.c @@ -322,11 +322,11 @@ int board_is_tile_occupied(const Board* board, Position pos) { /* -Returns all possible legal positions either in diagonal or in straight lines +Returns all possible legal positions in diagonal, in straight lines, in both as well as knight-type for specified tile. -If mode is 0 - returns positions in straight lines, 1 - in diagonals, 2 - in both +Returns NULL in case of an error */ -Position* board_get_moves(const Board* board, const Tile* piece_tile, int mode, unsigned int* pos_count) { +Position* board_get_positions(const Board* board, const Tile* piece_tile, MoveMode mode, unsigned int* pos_count) { if (!board || !piece_tile || !pos_count) { return NULL; } @@ -338,7 +338,30 @@ Position* board_get_moves(const Board* board, const Tile* piece_tile, int mode, } switch (mode) { - case 0: { + case MODEKNIGHT: { + for (unsigned int j = 0; j < 8; j++) { + int vx = KNIGHTDELTAS[j].x; + int vy = KNIGHTDELTAS[j].y; + + int xtmp = piece_tile->position.row + vx; + int ytmp = piece_tile->position.column + vy; + if (board_is_tile_in_bounds(board, position_new(xtmp, ytmp))) { + Tile* tile = board_get_tile(board, position_new(xtmp, ytmp)); + if (tile->piece.type == NONE) { + legal_moves[i] = tile->position; + i++; + } else if (tile->piece.color != piece_tile->piece.color) { + legal_moves[i] = tile->position; + i++; + } else { + break; + } + } + } + break; + } + + case MODESTRAIGHTS: { for (unsigned int j = 0; j < 4; j++) { int vx = CARDINALS[j].x; int vy = CARDINALS[j].y; @@ -365,7 +388,7 @@ Position* board_get_moves(const Board* board, const Tile* piece_tile, int mode, break; } - case 1: { + case MODEDIAGONALS: { for (unsigned int j = 0; j < 4; j++) { int vx = DIAGONALS[j].x; int vy = DIAGONALS[j].y; @@ -392,7 +415,7 @@ Position* board_get_moves(const Board* board, const Tile* piece_tile, int mode, break; } - case 2: { + case MODESTRAIGHTSDIAGONALS: { for (unsigned int j = 0; j < 4; j++) { int vx = CARDINALS[j].x; int vy = CARDINALS[j].y; @@ -455,21 +478,184 @@ Position* board_get_moves(const Board* board, const Tile* piece_tile, int mode, } -// Returns all possible legal rook moves. Returns NULL if given tile does not contain a rook piece + +// Returns all possible legal knight positions. +Position* board_get_knight_moves(const Board* board, const Tile* knight_tile, unsigned int* pos_count) { + if (!board || !knight_tile || !pos_count) { + return NULL; + } + + return board_get_positions(board, knight_tile, MODEKNIGHT, pos_count); +} + + +// Returns all possible legal rook moves. Position* board_get_rook_moves(const Board* board, const Tile* rook_tile, unsigned int* pos_count) { if (!board || !rook_tile || !pos_count) { return NULL; } - if (rook_tile->piece.type != ROOK) { + return board_get_positions(board, rook_tile, MODESTRAIGHTS, pos_count); +} + + +// Returns all possible legal bishop positions. +Position* board_get_bishop_moves(const Board* board, const Tile* bishop_tile, unsigned int* pos_count) { + if (!board || !bishop_tile || !pos_count) { + return NULL; + } + + return board_get_positions(board, bishop_tile, MODEDIAGONALS, pos_count); +} + + +// Returns all possible legal queen positions. +Position* board_get_queen_moves(const Board* board, const Tile* queen_tile, unsigned int* pos_count) { + if (!board || !queen_tile || !pos_count) { + return NULL; + } + + return board_get_positions(board, queen_tile, MODESTRAIGHTSDIAGONALS, pos_count); +} + + +// Returns all possible legal king positions. +Position* board_get_king_moves(const Board* board, const Tile* king_tile, unsigned int* pos_count) { + if (!board || !king_tile || !pos_count) { + return NULL; + } + + Position* queen_positions = board_get_queen_moves(board, king_tile, pos_count); + Position* king_positions = malloc(sizeof(Position) * (*pos_count)); + if (!king_positions) { + free(queen_positions); + return NULL; + } + + unsigned int king_pos_count = 0; + for (unsigned int i = 0; i < *pos_count; i++) { + if (position_distance(king_tile->position, queen_positions[i]) > 1) { + continue; + } + + king_positions[king_pos_count] = queen_positions[i]; + king_pos_count++; + } + + free(queen_positions); + *pos_count = king_pos_count; + king_positions = realloc(king_positions, sizeof(Position) * king_pos_count); + + return NULL; +} + + +// Returns all possible legal pawn positions. +Position* board_get_pawn_moves(const Board* board, const Tile* pawn_tile, unsigned int* pos_count) { + if (!board || !pawn_tile || !pos_count) { return NULL; } + + Position* positions = malloc(sizeof(Position) * board->rows * board->columns); + if (!positions) { + return NULL; + } + + + // 1 and 2 tile advancements and takes + Position pos = pawn_tile->position; + for (int i = 1; i <= 2; i++) { + pos = pawn_tile->position; + + // Advances + if (pawn_tile->piece.color == WHITE) { + pos.row = pos.row + i; + } else { + pos.row = pos.row - i; + } + + + if (board_is_tile_in_bounds(board, pos)) { + Tile* tile = board_get_tile(board, pos); + if (tile->piece.type == NONE) { + // Add this position + positions[*pos_count] = pos; + (*pos_count)++; + } + } + + + // Takes + if (i % 2 == 0) { + pos.column = pos.column + 1; + } else { + pos.column = pos.column - 1; + } - return board_get_moves(board, rook_tile, 0, pos_count); + if (board_is_tile_in_bounds(board, pos)) { + Tile* tile = board_get_tile(board, pos); + if (tile->piece.type != NONE && tile->piece.color != pawn_tile->piece.color) { + // Add this position + positions[*pos_count] = pos; + (*pos_count)++; + } + } + } + + + positions = realloc(positions, sizeof(Position) * (*pos_count)); + + return positions; } +// Returns all possible legal positions for a piece standing on piece_tile. Returns NULL in case of an error +Position* board_get_positions_for(const Board* board, const Tile* piece_tile, unsigned int* pos_count) { + if (!board || !piece_tile || !pos_count) { + return NULL; + } + + // Check if there is a piece or not + if (piece_tile->piece.type == NONE) { + return NULL; + } + + switch (piece_tile->piece.type) { + PAWN: { + return board_get_pawn_moves(board, piece_tile, pos_count); + } + + KNIGHT: { + return board_get_knight_moves(board, piece_tile, pos_count); + } + + ROOK: { + return board_get_rook_moves(board, piece_tile, pos_count); + } + + BISHOP: { + return board_get_bishop_moves(board, piece_tile, pos_count); + } + + QUEEN: { + return board_get_queen_moves(board, piece_tile, pos_count); + } + + KING: { + return board_get_king_moves(board, piece_tile, pos_count); + } + + default: { + return NULL; + } + } + + return NULL; +} + + + /* Checks if a move is legal or not (and reason) on this board. @@ -520,7 +706,27 @@ MoveLegality board_is_move_legal(const Board* board, Move move, Color color_play } case QUEEN: { - return LEGAL; + unsigned int pos_count = 0; + Position* legal_positions = board_get_queen_moves( + board, + board_get_tile(board, move.origin), + &pos_count + ); + + for (unsigned int i = 0; i < pos_count; i++) { + if (legal_positions[i].row == move.target.row && + legal_positions[i].column == move.target.column + ) + { + // This position is allowed to be moved to + free(legal_positions); + return LEGAL; + } + } + + // Couldn't find such a position in legal placements + free(legal_positions); + return ILLINVALIDPIECEMOVEMENT; } case ROOK: { @@ -542,20 +748,81 @@ MoveLegality board_is_move_legal(const Board* board, Move move, Color color_play } } + // Couldn't find such a position in legal placements free(legal_positions); - return LEGAL; + return ILLINVALIDPIECEMOVEMENT; } case KNIGHT: { - return LEGAL; + unsigned int pos_count = 0; + Position* legal_positions = board_get_knight_moves( + board, + board_get_tile(board, move.origin), + &pos_count + ); + + for (unsigned int i = 0; i < pos_count; i++) { + if (legal_positions[i].row == move.target.row && + legal_positions[i].column == move.target.column + ) + { + // This position is allowed to be moved to + free(legal_positions); + return LEGAL; + } + } + + // Couldn't find such a position in legal placements + free(legal_positions); + return ILLINVALIDPIECEMOVEMENT; } case BISHOP: { - return LEGAL; + unsigned int pos_count = 0; + Position* legal_positions = board_get_bishop_moves( + board, + board_get_tile(board, move.origin), + &pos_count + ); + + for (unsigned int i = 0; i < pos_count; i++) { + if (legal_positions[i].row == move.target.row && + legal_positions[i].column == move.target.column + ) + { + // This position is allowed to be moved to + free(legal_positions); + return LEGAL; + } + } + + // Couldn't find such a position in legal placements + free(legal_positions); + return ILLINVALIDPIECEMOVEMENT; } case PAWN: { - return LEGAL; + unsigned int pos_count = 0; + Position* legal_positions = board_get_pawn_moves( + board, + board_get_tile(board, move.origin), + &pos_count + ); + + for (unsigned int i = 0; i < pos_count; i++) { + if (legal_positions[i].row == move.target.row && + legal_positions[i].column == move.target.column + ) + { + // This position is allowed to be moved to + free(legal_positions); + return LEGAL; + } + } + + // Couldn't find such a position in legal placements + free(legal_positions); + return ILLINVALIDPIECEMOVEMENT; } default: { diff --git a/src/board.h b/src/board.h index f9ba6f8..939e569 100644 --- a/src/board.h +++ b/src/board.h @@ -107,22 +107,50 @@ int board_is_tile_occupied(const Board* board, Position pos); void board_print(const Board* board, FILE* out); +typedef enum MoveMode { + MODESTRAIGHTS, + MODEDIAGONALS, + MODESTRAIGHTSDIAGONALS, + MODEKNIGHT +} MoveMode; + + /* -Returns all possible legal positions either in diagonal or in straight lines +Returns all possible legal positions in diagonal, in straight lines, in both as well as knight-type for specified tile. -If mode is 0 - returns positions in straight lines, 1 - in diagonals, 2 - in both +Returns NULL in case of an error */ -Position* board_get_moves(const Board* board, const Tile* piece_tile, int mode, unsigned int* pos_count); +Position* board_get_positions(const Board* board, const Tile* piece_tile, MoveMode mode, unsigned int* pos_count); -// Returns all possible legal king positions. Returns NULL if given tile does not contain a king piece +// Returns all possible legal king positions. Position* board_get_king_moves(const Board* board, const Tile* king_tile, unsigned int* pos_count); -// Returns all possible legal king positions. Returns NULL if given tile does not contain a rook piece +// Returns all possible legal rook positions. Position* board_get_rook_moves(const Board* board, const Tile* rook_tile, unsigned int* pos_count); +// Returns all possible legal queen positions. +Position* board_get_queen_moves(const Board* board, const Tile* queen_tile, unsigned int* pos_count); + + +// Returns all possible legal bishop positions. +Position* board_get_bishop_moves(const Board* board, const Tile* bishop_tile, unsigned int* pos_count); + + +// Returns all possible legal knight positions. +Position* board_get_knight_moves(const Board* board, const Tile* knight_tile, unsigned int* pos_count); + + +// Returns all possible legal pawn positions. +Position* board_get_pawn_moves(const Board* board, const Tile* pawn_tile, unsigned int* pos_count); + + +// Returns all possible legal positions for a piece standing on piece_tile. Returns NULL in case of an error +Position* board_get_positions_for(const Board* board, const Tile* piece_tile, unsigned int* pos_count); + + // Move legality status typedef enum MoveLegality { LEGAL,