MPenate0/SchrodingersChess
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Comments, small changes

Browse Source
This commit is contained in:
Marcus Penate
2022-04-19 15:14:24 -04:00
parent 6ed4f41803
commit 5145cbb856
4 changed files with 166 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files
game.cpp
+62 -87
View File
@@ -7,11 +7,13 @@
#include <limits>
#include <thread>
//Used to calculate ticks of the game
uint64_t time_milli() {
using namespace std::chrono;
return duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
}
//Default constructor without a FEN
Game::Game(SDL_Window* window, SDL_Surface* surface)
{
this->window = window;
@@ -20,6 +22,7 @@ Game::Game(SDL_Window* window, SDL_Surface* surface)
holding_k = false;
}
//Construct with specific board
Game::Game(SDL_Window* window, SDL_Surface* surface, std::string board_fen)
{
this->window = window;
@@ -29,8 +32,10 @@ Game::Game(SDL_Window* window, SDL_Surface* surface, std::string board_fen)
holding_k = false;
}
//Main loop
void Game::run()
{
//calculates elapsed quantum and runs a tick, always draws
uint64_t last_update_time = time_milli(), delta_time;
uint64_t time_quantum = 1000/60;
running = true;
@@ -50,13 +55,17 @@ void Game::run()
void Game::tick()
{
static bool ai_lost = false;
//Check for user interface
SDL_Event e;
while(running && SDL_PollEvent(&e) != 0)
{
{
//Pressing q or hitting close should stop the game
if (e.type == SDL_QUIT || (e.type == SDL_KEYUP && e.key.keysym.sym == SDLK_q))
{
running = false;
}
//holding K needs to be kept track of for pawn promotion between queen or knight
else if (e.type == SDL_KEYUP && e.key.keysym.sym == SDLK_k)
{
holding_k = false;
@@ -65,6 +74,7 @@ void Game::tick()
{
holding_k = true;
}
//Clicking causes the selection of spaces
else if (e.type == SDL_MOUSEBUTTONDOWN)
{
int x,y;
@@ -72,14 +82,17 @@ void Game::tick()
x/=SPRITE_SIZE;
y/=SPRITE_SIZE;
process_click(x,y);
//Draw now because the AI turn takes a fair amount of time
draw();
}
}
if (BLACK == board.get_active_color())
if (!ai_lost && BLACK == board.get_active_color())
{
do_ai_move();
if (-1 == do_ai_move())
{
ai_lost = true;
}
}
}
@@ -90,20 +103,26 @@ void Game::draw()
SDL_UpdateWindowSurface(window);
}
//Processes the click on the board
void Game::process_click(int x, int y)
{
//Only allow clicks if its white's turn
if (WHITE == board.get_active_color())
{
//Get the current space and target space
int current_selected_space = board.get_selected_space();
int target_selected_space = x+y*BOARD_SIZE;
if (current_selected_space == -1)
{
//Nothing selected before, select this tile
board.set_selected_space(x,y);
}
else
{
//Get the target spaces for the previously selected space
std::vector<int> target_spaces = board.get_moves_for_space(current_selected_space, true);
//Move if the mouse clicked a possible target, otherwise change the selected space to the new one
if (target_spaces.end() != std::find(target_spaces.begin(), target_spaces.end(), target_selected_space))
{
board.do_move(current_selected_space, target_selected_space, holding_k);
@@ -116,18 +135,26 @@ void Game::process_click(int x, int y)
}
}
void Game::do_ai_move()
int Game::do_ai_move()
{
//Thread management
std::vector<std::thread> threads;
std::mutex mut_result_check;
//Best weight found and the move that describes it
int best_move_weight = std::numeric_limits<int>::min();
int best_move_from = -1;
int best_move_to = -1;
bool best_move_makes_queen = false;
//Initial alpha weight
int a = std::numeric_limits<int>::min();
//This function only does the maximizing part of minimax, its special because we need to know what the best move was
Board board_copy = Board(board);
//Go through the board and for each black piece, make a thread that will minimax
for(int x = 0; x < BOARD_SIZE; x++)
{
for(int y = BOARD_SIZE-1; y >= 0; y--)
@@ -136,15 +163,19 @@ void Game::do_ai_move()
if (cur_piece.get_team() == BLACK)
{
threads.push_back(std::thread([&mut_result_check, &best_move_weight, &best_move_from, &best_move_to, &best_move_makes_queen, &a, x, y, &board_copy](){
//Get the possible moves of this piece
std::vector<int> piece_moves = board_copy.get_moves_for_space(x,y, true);
Piece cur_piece = board_copy.get_piece(x,y);
for (unsigned int i = 0; i < piece_moves.size(); i++)
{
//Make a test board and do the move on it
Board test_board(board_copy);
test_board.do_move(x+y*BOARD_SIZE, piece_moves[i], false);
//Minimax on this test board
int board_value = minimax(test_board, 4, 5, a, std::numeric_limits<int>::max(), false);
//Record new bests if they are found
mut_result_check.lock();
if (board_value > best_move_weight)
{
@@ -154,51 +185,31 @@ void Game::do_ai_move()
best_move_makes_queen = false;
}
//Update alpha for further iterations
if (best_move_weight > a)
{
a = best_move_weight;
}
mut_result_check.unlock();
if (cur_piece.get_type() == PAWN || (piece_moves[i]/BOARD_SIZE) == 7)
{
Board test_board1 = Board(board_copy);
test_board1.do_move(x+y*BOARD_SIZE, piece_moves[i], true);
if (test_board1.make_FEN().compare(board_copy.make_FEN()) != 0)
{
board_value = minimax(test_board1, 4, 5, a, std::numeric_limits<int>::max(), false);
mut_result_check.lock();
if (board_value > best_move_weight)
{
best_move_weight = board_value;
best_move_from = x+y*BOARD_SIZE;
best_move_to = piece_moves[i];
best_move_makes_queen = true;
}
if (best_move_weight > a)
{
a = best_move_weight;
}
mut_result_check.unlock();
}
}
}
}));
}
}
}
//Wait for all threads to finish
for(std::thread& cur_thread : threads)
{
cur_thread.join();
}
//Do the best found move
board.do_move(best_move_from, best_move_to, best_move_makes_queen);
return best_move_to;
}
//Regular alpha beta pruning, max depth is used to only make threads when <= 1 node from root
int Game::minimax(Board current_board, int depth, int max_depth, int a, int b, bool maximizing)
{
if (depth == 0 || current_board.is_mate(current_board.get_active_color()))
@@ -209,21 +220,26 @@ int Game::minimax(Board current_board, int depth, int max_depth, int a, int b, b
int best_move_weight = maximizing?std::numeric_limits<int>::min():std::numeric_limits<int>::max();
bool a_eject = false, b_eject = false;
//Thread management
std::vector<std::thread> threads;
std::mutex mut_result_check;
int finished_threads = 0;
std::mutex mut_finished_threads;
//Board iteration optimization
int y_start=(maximizing)?(BOARD_SIZE-1):0, y_increment=(maximizing)?-1:1;
//Loop board, find pieces and minimax on their moves, make threads if available
for(int x = 0; x < BOARD_SIZE && !a_eject && !b_eject; x++)
{
for(int y = y_start; y >= 0 && y < BOARD_SIZE && !a_eject && !b_eject; y+=y_increment)
{
if (current_board.get_piece(x,y).get_team() == (maximizing?BLACK:WHITE))
{
//Try to make a thread?
if (depth == max_depth-1)
{
//Is a thread available?
if (threads.size()-finished_threads <= 4)
{
threads.push_back(std::thread([&finished_threads, &mut_finished_threads, &mut_result_check, current_board, x, y, depth, max_depth, &best_move_weight, &a, &b, &a_eject, &b_eject, maximizing](){
@@ -234,11 +250,11 @@ int Game::minimax(Board current_board, int depth, int max_depth, int a, int b, b
}));
}
else
{
{ //Run in this thread
minimax_evaluate(mut_result_check, current_board, x, y, depth, max_depth, best_move_weight, a, b, a_eject, b_eject, maximizing);
}
}
else
else //Cannot make threads, run in this thread
{
minimax_evaluate(mut_result_check, current_board, x, y, depth, max_depth, best_move_weight, a, b, a_eject, b_eject, maximizing);
}
@@ -246,14 +262,17 @@ int Game::minimax(Board current_board, int depth, int max_depth, int a, int b, b
}
}
//Wait for threads to finish
for (std::thread& cur_thread : threads)
{
cur_thread.join();
}
//Return best result
return best_move_weight;
}
//Evaluation of each pieces moves through minimax
void Game::minimax_evaluate(std::mutex& mut_result_check, Board current_board, int x, int y, int depth, int max_depth, int& best_move_weight, int& a, int& b, bool& a_eject, bool& b_eject, bool maximizing)
{
Piece cur_piece = current_board.get_piece(x,y);
@@ -263,6 +282,8 @@ void Game::minimax_evaluate(std::mutex& mut_result_check, Board current_board, i
{
for (unsigned int i = 0; i < piece_moves.size(); i++)
{
//Go through each move, make a test board and maximize off of it
Board test_board(current_board);
test_board.do_move(x+y*BOARD_SIZE, piece_moves[i], false);
@@ -286,39 +307,14 @@ void Game::minimax_evaluate(std::mutex& mut_result_check, Board current_board, i
a = best_move_weight;
}
mut_result_check.unlock();
if (cur_piece.get_type() == PAWN || (piece_moves[i]/BOARD_SIZE) == (maximizing?7:0))
{
test_board = Board(current_board);
test_board.do_move(x+y*BOARD_SIZE, piece_moves[i], true);
board_value = minimax(test_board, depth-1, max_depth, a, b, false);
mut_result_check.lock();
if (board_value > best_move_weight)
{
best_move_weight = board_value;
}
if (best_move_weight >= b)
{
b_eject = true;
mut_result_check.unlock();
return;
}
if (best_move_weight > a)
{
a = best_move_weight;
}
mut_result_check.unlock();
}
}
}
else
{
for (unsigned int i = 0; i < piece_moves.size(); i++)
{
//Go through each move, make a test board and minimize off of it
Board test_board(current_board);
test_board.do_move(x+y*BOARD_SIZE, piece_moves[i], false);
@@ -342,33 +338,6 @@ void Game::minimax_evaluate(std::mutex& mut_result_check, Board current_board, i
b = best_move_weight;
}
mut_result_check.unlock();
if (cur_piece.get_type() == PAWN || (piece_moves[i]/BOARD_SIZE) == (maximizing?7:0))
{
test_board = Board(current_board);
test_board.do_move(x+y*BOARD_SIZE, piece_moves[i], true);
board_value = minimax(test_board, depth-1, max_depth, a, b, true);
mut_result_check.lock();
if (board_value < best_move_weight)
{
best_move_weight = board_value;
}
if (best_move_weight <= a)
{
a_eject = true;
mut_result_check.unlock();
return;
}
if (best_move_weight < b)
{
b = best_move_weight;
}
mut_result_check.unlock();
}
}
}
}
@@ -378,6 +347,7 @@ int Game::board_heuristic(Board current_board)
int heuristic = 0;
int piece_weights[2][7] = {{-900, -90, -30, -30, -50, -10, 0}, {900, 90, 30, 30, 50, 10, 0}};
//Unknown piece weight calculation
int unknown_white_count = 0;
int unknown_black_count = 0;
for(int x = 0; x < BOARD_SIZE; x++)
@@ -416,6 +386,7 @@ int Game::board_heuristic(Board current_board)
piece_weights[BLACK][UNKNOWN] /= unknown_black_count;
}
//Per piece weight calculation
for(int x = 0; x < BOARD_SIZE; x++)
{
for(int y = 0; y < BOARD_SIZE; y++)
@@ -427,13 +398,16 @@ int Game::board_heuristic(Board current_board)
continue;
}
//Mark hidden pieces as unknown and not their actual type
if (cur_piece.get_vis() == HIDDEN)
{
cur_piece = Piece(UNKNOWN, cur_piece.get_team(), SHOWN);
}
//Get unmodified weight
int adden = piece_weights[cur_piece.get_team()][cur_piece.get_type()];
//Pawn rank bonus
if (cur_piece.get_type() == PAWN)
{
if (cur_piece.get_team() == WHITE)
@@ -446,6 +420,7 @@ int Game::board_heuristic(Board current_board)
}
}
//Attackers and defenders bonus
int found_attackers = current_board.get_attackers_for_space(x+y*BOARD_SIZE);
if (found_attackers > 0)