266 lines
8.4 KiB
C++
266 lines
8.4 KiB
C++
#include "chess_board.h"
|
|
#include <SDL.h>
|
|
#include <SDL_video.h>
|
|
#include "stdio.h"
|
|
#include <stack>
|
|
#include <string.h>
|
|
|
|
#define MARGIN 200
|
|
|
|
#define PAWN_WHITE 0u
|
|
#define PAWN_BLACK 1u
|
|
#define KING_WHITE 2u
|
|
#define KING_BLACK 3u
|
|
#define QUEEN_WHITE 4u
|
|
#define QUEEN_BLACK 5u
|
|
#define ROOK_WHITE 6u
|
|
#define ROOK_BLACK 7u
|
|
#define KNIGHT_WHITE 8u
|
|
#define KNIGHT_BLACK 9u
|
|
#define BISHOP_WHITE 10u
|
|
#define BISHOP_BLACK 11u
|
|
#define SQUARE_EMPTY 12u
|
|
#define SQUARE_SHIFT 4u
|
|
|
|
#define POTENTIAL_MOVE (1u << SQUARE_SHIFT)
|
|
#define POTENTIAL_TAKE (2u << SQUARE_SHIFT)
|
|
#define SUGGESTED_MOVE (3u << SQUARE_SHIFT)
|
|
#define CHEATING_MOVE (4u << SQUARE_SHIFT)
|
|
|
|
const char file_names[12][16] = {"pawn_white.bmp", "pawn_black.bmp",
|
|
"king_white.bmp", "king_black.bmp",
|
|
"queen_white.bmp", "queen_black.bmp",
|
|
"rook_white.bmp", "rook_black.bmp",
|
|
"horse_white.bmp", "horse_black.bmp",
|
|
"tower_white.bmp", "tower_black.bmp"};
|
|
|
|
static int height;
|
|
static int width;
|
|
static SDL_Texture * board_texture;
|
|
static SDL_Rect rectangle;
|
|
static int board_width;
|
|
uint8_t board_state[8][8];
|
|
SDL_Surface *bitmapSurface = NULL;
|
|
SDL_Texture * bitmapTextures[12] = {NULL};
|
|
std::stack<uint8_t> selected_peices;
|
|
|
|
void pawn_move(uint8_t row, uint8_t column)
|
|
{
|
|
if((0x0Fu & board_state[row][column]) == SQUARE_EMPTY)
|
|
{
|
|
board_state[row][column] = (uint8_t)((POTENTIAL_MOVE) | (board_state[row][column] & 0x0Fu));
|
|
}
|
|
}
|
|
|
|
void pawn_take(uint8_t row, uint8_t column)
|
|
{
|
|
if ((0x0Fu & board_state[row][column]) < SQUARE_EMPTY)
|
|
{
|
|
board_state[row][column] = (uint8_t)((POTENTIAL_TAKE) | (board_state[row][column] & 0x0Fu));
|
|
}
|
|
}
|
|
|
|
void Mark_Potential_Moves(uint8_t peice, uint8_t column, uint8_t row)
|
|
{
|
|
switch (peice)
|
|
{
|
|
case PAWN_WHITE :
|
|
if (row == 6)
|
|
{
|
|
pawn_move(row - 2, column);
|
|
}
|
|
pawn_move(row - 1, column);
|
|
if(column >= 1)
|
|
{
|
|
pawn_take(row - 1, column - 1);
|
|
}
|
|
if (column <= 6)
|
|
{
|
|
pawn_take(row - 1, column + 1);
|
|
}
|
|
|
|
break;
|
|
case PAWN_BLACK:
|
|
if (row == 1)
|
|
{
|
|
board_state[row + 2][column] = (uint8_t)((POTENTIAL_MOVE) | (board_state[row + 2][column] & 0x0Fu));
|
|
}
|
|
board_state[row + 1][column] = (uint8_t)((uint8_t)(POTENTIAL_MOVE) | (uint8_t)(board_state[row + 1][column] & 0x0Fu));
|
|
break;
|
|
case ROOK_WHITE:
|
|
case ROOK_BLACK:
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool click(SDL_Renderer *p_renderer, int x, int y, bool pick_up)
|
|
{
|
|
SDL_Point const point = {x, y};
|
|
bool ret_val = false;
|
|
rectangle.w = board_width;
|
|
rectangle.h = board_width;
|
|
rectangle.x = (width - board_width) / 2;
|
|
rectangle.y = (height - board_width) / 2;
|
|
if (SDL_PointInRect(&point, &rectangle))
|
|
{
|
|
int square_size = board_width / 8;
|
|
int starting_x = rectangle.x;
|
|
rectangle.w = square_size;
|
|
rectangle.h = square_size;
|
|
for (size_t j = 0; j < 8; j++)
|
|
{
|
|
rectangle.x = starting_x;
|
|
for (size_t i = 0; i < 8; i++)
|
|
{
|
|
if(SDL_PointInRect(&point, &rectangle))
|
|
{
|
|
if (pick_up && (board_state[j][i] < SQUARE_EMPTY))
|
|
{
|
|
selected_peices.push(board_state[j][i]);
|
|
Mark_Potential_Moves(board_state[j][i], i, j);
|
|
board_state[j][i] = SQUARE_EMPTY;
|
|
}
|
|
else if (!selected_peices.empty() && (board_state[j][i] >= SQUARE_EMPTY))
|
|
{
|
|
board_state[j][i] = selected_peices.top();
|
|
selected_peices.pop();
|
|
}
|
|
else
|
|
{
|
|
/* code */
|
|
}
|
|
|
|
goto draw_square;
|
|
}
|
|
rectangle.x += square_size;
|
|
}
|
|
rectangle.y += square_size;
|
|
}
|
|
draw_square:
|
|
SDL_SetRenderTarget(p_renderer, board_texture);
|
|
//SDL_SetRenderDrawColor(p_renderer, 0x00, 0xFF, 0x00, 0x00);
|
|
//SDL_RenderDrawRect(p_renderer, &rectangle);
|
|
//SDL_RenderFillRect(p_renderer, &rectangle);
|
|
//SDL_SetRenderTarget(p_renderer, NULL);
|
|
draw_board(p_renderer);
|
|
SDL_RenderCopy(p_renderer, board_texture, NULL, NULL);
|
|
SDL_RenderPresent(p_renderer);
|
|
}
|
|
return ret_val;
|
|
}
|
|
|
|
void chess_board_resize(SDL_Renderer *p_renderer, int w, int h)
|
|
{
|
|
width = w;
|
|
height = h;
|
|
SDL_DestroyTexture(board_texture);
|
|
board_texture = SDL_CreateTexture(p_renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, w, h);
|
|
board_width = ((w > h) ? h : w) - MARGIN;
|
|
// get rid of rounding errors
|
|
board_width -= board_width % 8;
|
|
}
|
|
|
|
void chess_board_init(SDL_Renderer *p_renderer)
|
|
{
|
|
for (uint8_t i = 0; i < 8; i++)
|
|
{
|
|
for (uint8_t j = 0; j < 8; j++)
|
|
{
|
|
board_state[i][j] = SQUARE_EMPTY;
|
|
}
|
|
|
|
}
|
|
|
|
//Place black peices
|
|
board_state[0][0] = BISHOP_BLACK;
|
|
board_state[0][7] = BISHOP_BLACK;
|
|
board_state[0][1] = KNIGHT_BLACK;
|
|
board_state[0][6] = KNIGHT_BLACK;
|
|
board_state[0][2] = ROOK_BLACK;
|
|
board_state[0][5] = ROOK_BLACK;
|
|
board_state[0][3] = QUEEN_BLACK;
|
|
board_state[0][4] = KING_BLACK;
|
|
board_state[7][0] = BISHOP_WHITE;
|
|
board_state[7][7] = BISHOP_WHITE;
|
|
board_state[7][1] = KNIGHT_WHITE;
|
|
board_state[7][6] = KNIGHT_WHITE;
|
|
board_state[7][2] = ROOK_WHITE;
|
|
board_state[7][5] = ROOK_WHITE;
|
|
board_state[7][3] = QUEEN_WHITE;
|
|
board_state[7][4] = KING_WHITE;
|
|
for (uint8_t i = 0; i < 8; i++)
|
|
{
|
|
board_state[1][i] = PAWN_BLACK;
|
|
board_state[6][i] = PAWN_WHITE;
|
|
}
|
|
for (uint8_t i = 0; i < 12; i++)
|
|
{
|
|
//location of all the sprites plus the size of file names
|
|
char file[25] = "sprites\\";
|
|
memcpy(&file[8], file_names[i], 16);
|
|
bitmapSurface = SDL_LoadBMP(file);
|
|
bitmapTextures[i] = SDL_CreateTextureFromSurface(p_renderer, bitmapSurface);
|
|
}
|
|
SDL_FreeSurface(bitmapSurface);
|
|
}
|
|
|
|
void draw_board(SDL_Renderer *p_renderer)
|
|
{
|
|
SDL_SetRenderTarget(p_renderer, board_texture);
|
|
SDL_SetRenderDrawColor(p_renderer, 0x7f, 0x7f, 0x7f, 0);
|
|
SDL_RenderClear(p_renderer);
|
|
SDL_RenderDrawRect(p_renderer, &rectangle);
|
|
SDL_SetRenderDrawColor(p_renderer, 0xFF, 0xFF, 0xFF, 0x00);
|
|
rectangle.w = board_width;
|
|
rectangle.h = board_width;
|
|
rectangle.x = (width - board_width) / 2;
|
|
rectangle.y = (height - board_width) / 2;
|
|
SDL_RenderFillRect(p_renderer, &rectangle);
|
|
SDL_SetRenderDrawColor(p_renderer, 0x85, 0x5E, 0x42, 0x00);
|
|
int square_size = board_width / 8;
|
|
int starting_x = rectangle.x;
|
|
rectangle.w = square_size;
|
|
rectangle.h = square_size;
|
|
for (size_t j = 0; j < 8; j++)
|
|
{
|
|
rectangle.x = starting_x;
|
|
for (size_t i = 0; i < 8; i++)
|
|
{
|
|
if((board_state[j][i] & 0xF0u) == POTENTIAL_MOVE)
|
|
{
|
|
SDL_SetRenderDrawColor(p_renderer, 0x00, 0xFF, 0x00, 0x00);
|
|
SDL_RenderFillRect(p_renderer, &rectangle);
|
|
SDL_SetRenderDrawColor(p_renderer, 0x85, 0x5E, 0x42, 0x00);
|
|
}
|
|
else if ((board_state[j][i] & 0xF0u) == POTENTIAL_TAKE)
|
|
{
|
|
SDL_SetRenderDrawColor(p_renderer, 0xFF, 0x00, 0x00, 0x00);
|
|
SDL_RenderFillRect(p_renderer, &rectangle);
|
|
SDL_SetRenderDrawColor(p_renderer, 0x85, 0x5E, 0x42, 0x00);
|
|
}
|
|
else if (((i % 2) + (j % 2)) == 1)
|
|
{
|
|
SDL_RenderFillRect(p_renderer, &rectangle);
|
|
}
|
|
else
|
|
{
|
|
/* code */
|
|
}
|
|
|
|
if((board_state[j][i] & 0x0Fu) != SQUARE_EMPTY)
|
|
{
|
|
SDL_RenderCopy(p_renderer, bitmapTextures[(board_state[j][i] & 0x0Fu)], NULL, &rectangle);
|
|
}
|
|
|
|
rectangle.x += square_size;
|
|
}
|
|
rectangle.y += square_size;
|
|
}
|
|
|
|
SDL_SetRenderTarget(p_renderer, NULL);
|
|
SDL_RenderCopy(p_renderer, board_texture, NULL, NULL);
|
|
}
|