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

Added threading, optimizations

Browse Source
This commit is contained in:
Marcus Penate
2022-04-18 22:27:16 -04:00
parent cbdf377c86
commit 66195867eb
6 changed files with 385 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files
game.cpp
+218 -139
View File
@@ -5,6 +5,7 @@
#include <algorithm>
#include <cstdlib>
#include <limits>
#include <thread>
uint64_t time_milli() {
using namespace std::chrono;
@@ -71,6 +72,8 @@ void Game::tick()
x/=SPRITE_SIZE;
y/=SPRITE_SIZE;
process_click(x,y);
draw();
}
}
@@ -115,10 +118,16 @@ void Game::process_click(int x, int y)
void Game::do_ai_move()
{
std::vector<std::thread> threads;
std::mutex mut_result_check;
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;
int a = std::numeric_limits<int>::min();
Board board_copy = Board(board);
for(int x = 0; x < BOARD_SIZE; x++)
{
for(int y = 0; y < BOARD_SIZE; y++)
@@ -126,178 +135,239 @@ void Game::do_ai_move()
Piece cur_piece = board.get_piece(x,y);
if (cur_piece.get_team() == BLACK)
{
std::vector<int> piece_moves = board.get_moves_for_space(x,y, true);
for (unsigned int i = 0; i < piece_moves.size(); i++)
{
Board test_board(board.make_FEN());
test_board.do_move(x+y*BOARD_SIZE, piece_moves[i], false);
int board_value = minimax(test_board, 3, std::numeric_limits<int>::min(), std::numeric_limits<int>::max(), false);
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 = false;
}
if (cur_piece.get_type() == PAWN || (piece_moves[i]/BOARD_SIZE) == 7)
{
Board test_board1 = Board(board.make_FEN());
test_board1.do_move(x+y*BOARD_SIZE, piece_moves[i], true);
if (test_board1.make_FEN().compare(test_board.make_FEN()) != 0)
{
board_value = minimax(test_board1, 3, std::numeric_limits<int>::min(), std::numeric_limits<int>::max(), false);
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;
}
}
}
}
}
}
}
board.do_move(best_move_from, best_move_to, best_move_makes_queen);
}
int Game::minimax(Board current_board, int depth, int a, int b, bool maximizing)
{
if (depth == 0 || current_board.is_mate(current_board.get_active_color()))
{
return board_heuristic(current_board);
}
if (maximizing)
{
int best_move_weight = std::numeric_limits<int>::min();
for(int x = 0; x < BOARD_SIZE; x++)
{
for(int y = 0; y < BOARD_SIZE; y++)
{
Piece cur_piece = current_board.get_piece(x,y);
if (cur_piece.get_team() == BLACK)
{
std::vector<int> piece_moves = current_board.get_moves_for_space(x,y, true);
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](){
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++)
{
Board test_board(current_board.make_FEN());
Board test_board(board_copy);
test_board.do_move(x+y*BOARD_SIZE, piece_moves[i], false);
int board_value = minimax(test_board, depth-1, a, b, false);
int board_value = minimax(test_board, 4, 5, a, std::numeric_limits<int>::max(), false);
mut_result_check.lock();
if (board_value > best_move_weight)
{
best_move_weight = board_value;
}
if (best_move_weight >= b)
{
return best_move_weight;
best_move_from = x+y*BOARD_SIZE;
best_move_to = piece_moves[i];
best_move_makes_queen = false;
}
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)
{
test_board = Board(current_board.make_FEN());
test_board.do_move(x+y*BOARD_SIZE, piece_moves[i], true);
Board test_board1 = Board(board_copy);
test_board1.do_move(x+y*BOARD_SIZE, piece_moves[i], true);
board_value = minimax(test_board, depth-1, a, b, false);
if (board_value > best_move_weight)
if (test_board1.make_FEN().compare(board_copy.make_FEN()) != 0)
{
best_move_weight = board_value;
}
board_value = minimax(test_board1, 4, 5, a, std::numeric_limits<int>::max(), false);
if (best_move_weight >= b)
{
return best_move_weight;
}
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;
if (best_move_weight > a)
{
a = best_move_weight;
}
mut_result_check.unlock();
}
}
}
}));
}
}
}
for(std::thread& cur_thread : threads)
{
cur_thread.join();
}
board.do_move(best_move_from, best_move_to, best_move_makes_queen);
}
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()))
{
return board_heuristic(current_board);
}
int best_move_weight = maximizing?std::numeric_limits<int>::min():std::numeric_limits<int>::max();
bool a_eject = false, b_eject = false;
std::vector<std::thread> threads;
std::mutex mut_result_check;
int finished_threads = 0;
std::mutex mut_finished_threads;
for(int x = 0; x < BOARD_SIZE && !a_eject && !b_eject; x++)
{
for(int y = 0; y < BOARD_SIZE && !a_eject && !b_eject; y++)
{
if (current_board.get_piece(x,y).get_team() == (maximizing?BLACK:WHITE))
{
if (depth == max_depth-1)
{
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](){
minimax_evaluate(mut_result_check, current_board, x, y, depth, max_depth, best_move_weight, a, b, a_eject, b_eject, maximizing);
mut_finished_threads.lock();
finished_threads++;
mut_finished_threads.unlock();
}));
}
else
{
minimax_evaluate(mut_result_check, current_board, x, y, depth, max_depth, best_move_weight, a, b, a_eject, b_eject, maximizing);
}
}
else
{
minimax_evaluate(mut_result_check, current_board, x, y, depth, max_depth, best_move_weight, a, b, a_eject, b_eject, maximizing);
}
}
}
}
return best_move_weight;
for (std::thread& cur_thread : threads)
{
cur_thread.join();
}
return best_move_weight;
}
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);
std::vector<int> piece_moves = current_board.get_moves_for_space(x,y, true);
if (maximizing)
{
for (unsigned int i = 0; i < piece_moves.size(); i++)
{
Board test_board(current_board);
test_board.do_move(x+y*BOARD_SIZE, piece_moves[i], false);
int 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();
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
{
int best_move_weight = std::numeric_limits<int>::max();
for(int x = 0; x < BOARD_SIZE; x++)
for (unsigned int i = 0; i < piece_moves.size(); i++)
{
for(int y = 0; y < BOARD_SIZE; y++)
Board test_board(current_board);
test_board.do_move(x+y*BOARD_SIZE, piece_moves[i], false);
int board_value = minimax(test_board, depth-1, max_depth, a, b, true);
mut_result_check.lock();
if (board_value < best_move_weight)
{
Piece cur_piece = current_board.get_piece(x,y);
if (cur_piece.get_team() == WHITE)
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();
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)
{
std::vector<int> piece_moves = current_board.get_moves_for_space(x,y, true);
for (unsigned int i = 0; i < piece_moves.size(); i++)
{
Board test_board(current_board.make_FEN());
test_board.do_move(x+y*BOARD_SIZE, piece_moves[i], false);
int board_value = minimax(test_board, depth-1, a, b, true);
if (board_value < best_move_weight)
{
best_move_weight = board_value;
}
if (best_move_weight <= a)
{
return best_move_weight;
}
if (best_move_weight < b)
{
b = best_move_weight;
}
if (cur_piece.get_type() == PAWN || (piece_moves[i]/BOARD_SIZE) == 0)
{
test_board = Board(current_board.make_FEN());
test_board.do_move(x+y*BOARD_SIZE, piece_moves[i], true);
board_value = minimax(test_board, depth-1, a, b, true);
if (board_value < best_move_weight)
{
best_move_weight = board_value;
}
if (best_move_weight <= a)
{
return best_move_weight;
}
if (best_move_weight < b)
{
b = 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();
}
}
return best_move_weight;
}
}
@@ -305,7 +375,12 @@ 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}};
///Calculate the weight of an unknown piece for both teams
//The weight of an unknown piece is 2 times the average of the remaining unrevealed pieces
//The weight is 2 times so that the AI understands that the hidden pieces are valuable hidden, otherwise the average
//is less than that of Rooks, making the AI always reveal its rooks.
//In order to still sometimes prefer revealing, the number of vulnerabilities will be considered later into a pieces weight.
int unknown_white_count = 0;
int unknown_black_count = 0;
for(int x = 0; x < BOARD_SIZE; x++)
@@ -323,12 +398,12 @@ int Game::board_heuristic(Board current_board)
{
if (cur_piece.get_team() == WHITE)
{
piece_weights[WHITE][UNKNOWN] += piece_weights[WHITE][cur_piece.get_type()];
piece_weights[WHITE][UNKNOWN] += 2*piece_weights[WHITE][cur_piece.get_type()];
unknown_white_count++;
}
else
{
piece_weights[BLACK][UNKNOWN] += piece_weights[BLACK][cur_piece.get_type()];
piece_weights[BLACK][UNKNOWN] += 2*piece_weights[BLACK][cur_piece.get_type()];
unknown_black_count++;
}
}
@@ -360,7 +435,11 @@ int Game::board_heuristic(Board current_board)
cur_piece = Piece(UNKNOWN, cur_piece.get_team(), SHOWN);
}
heuristic += piece_weights[cur_piece.get_team()][cur_piece.get_type()];
int adden = piece_weights[cur_piece.get_team()][cur_piece.get_type()];
int found_attackers = current_board.get_attackers_for_space(x+y*BOARD_SIZE);
heuristic += adden/((found_attackers!=0)?2:1);
}
}