feat: set up alpha beta

This commit is contained in:
Jakub Kliszko 2023-04-08 17:50:31 +02:00
parent 108121a4ed
commit d4cb446264

View File

@ -1,4 +1,5 @@
import re import re
import copy
""" """
Program that plays draughts (checkers) with user on 8x8 board using min-max with alpha-beta prunning Program that plays draughts (checkers) with user on 8x8 board using min-max with alpha-beta prunning
""" """
@ -11,8 +12,6 @@ class Game:
self.board_size = size self.board_size = size
self.white_positions = self.initialize_white() self.white_positions = self.initialize_white()
self.black_positions = self.initialize_black() self.black_positions = self.initialize_black()
# print(self.white_positions)
# print(self.black_positions)
def initialize_white(self): def initialize_white(self):
"""Initialize white pieces""" """Initialize white pieces"""
@ -46,11 +45,11 @@ class Game:
def check_move_out_of_bounds(self, from_, to): def check_move_out_of_bounds(self, from_, to):
"""Check if the move destination is out of the bounds of the board""" """Check if the move destination is out of the bounds of the board"""
if to[0] < 0 or to[0] >= self.board_size - 1: if to[0] < 0 or to[0] > self.board_size - 1:
print(f"Illegal move! Final x coordinate must be between 0 and {self.board_size}!") # print(f"Illegal move! Final x coordinate must be between 0 and {self.board_size-1}!")
return True return True
if to[1] < 0 or to[1] >= self.board_size - 1: if to[1] < 0 or to[1] > self.board_size - 1:
print(f"Illegal move! Final y coordinate must be between 0 and {self.board_size}!") # print(f"Illegal move! Final y coordinate must be between 0 and {self.board_size-1}!")
return True return True
return False return False
@ -90,7 +89,7 @@ class Game:
if (abs(to[0]-from_[0]) != 2 or abs(to[1]-from_[1] != 2)): if (abs(to[0]-from_[0]) != 2 or abs(to[1]-from_[1] != 2)):
return None return None
middle = (abs(to[0]-from_[0])//2, abs(to[1]-from_[1])//2) middle = (abs(to[0]+from_[0])//2, abs(to[1]+from_[1])//2)
if color == "white" and self.check_piece_exists(middle, "black"): if color == "white" and self.check_piece_exists(middle, "black"):
return middle return middle
@ -101,13 +100,19 @@ class Game:
def check_move_legal(self, from_, to, color): def check_move_legal(self, from_, to, color):
"""Check if a move is legal. Return a boolean or coordinates of captured piece""" """Check if a move is legal. Return a boolean or coordinates of captured piece"""
if self.check_move_out_of_bounds(from_, to): if self.check_move_out_of_bounds(from_, to):
if from_ == (2, 3):
print(f"To: {to}")
print("Illegal move! Final position is out of the bounds of the board") print("Illegal move! Final position is out of the bounds of the board")
return False return False
if not self.check_piece_exists(from_, color): if not self.check_piece_exists(from_, color):
if from_ == (2, 3):
print(f"To: {to}")
print( print(
"Illegal move! There is no piece on the starting position that belongs to the player") "Illegal move! There is no piece on the starting position that belongs to the player")
return False return False
if self.check_piece_exists(to, "white") or self.check_piece_exists(to, "black"): if self.check_piece_exists(to, "white") or self.check_piece_exists(to, "black"):
if from_ == (2, 3):
print(f"To: {to}")
print("Illegal move! Cannot move to position taken by another piece") print("Illegal move! Cannot move to position taken by another piece")
return False return False
capture = self.check_capture(from_, to, color) capture = self.check_capture(from_, to, color)
@ -115,6 +120,8 @@ class Game:
if self.check_move_piece_capable(from_, to, color): if self.check_move_piece_capable(from_, to, color):
return True return True
else: else:
if from_ == (2, 3):
print(f"To: {to}")
print('Illegal move!') print('Illegal move!')
return False return False
return capture return capture
@ -189,57 +196,80 @@ class Game:
print() print()
# Ran first in the code # Ran first in the code
def get_possible_move_down(self, from_, color): def get_possible_move_capture(self, from_, color):
# all moves "down": print(f"Checking piece {from_}")
# all capturing moves:
legal_moves = [] legal_moves = []
move_down_left_two = (from_[0] + 2, from_[1] - 2) move_down_left_two = (from_[0] + 2, from_[1] - 2)
move_down_right_two = (from_[0] + 2, from_[1] + 2) move_down_right_two = (from_[0] + 2, from_[1] + 2)
move_down_left_one = (from_[0] + 1, from_[1] - 1) move_up_left_two = (from_[0] - 2, from_[1] - 2)
move_down_right_one = (from_[0] + 1, from_[1] + 1) move_up_right_two = (from_[0] - 2, from_[1] + 2)
if self.check_move_legal(from_, move_down_left_two, color) != False: if self.check_move_legal(from_, move_down_left_two, color) != False:
legal_moves.append((from_, move_down_two)) legal_moves.append((from_, move_down_left_two))
elif self.check_move_legal(from_, move_down_right_two, color) != False: if self.check_move_legal(from_, move_down_right_two, color) != False:
legal_moves.append((from_, move_down_right_two)) legal_moves.append((from_, move_down_right_two))
elif self.check_move_legal(from_, move_down_left_one, color) != False: if self.check_move_legal(from_, move_up_left_two, color) != False:
legal_moves.append((from_, move_down_left_one)) legal_moves.append((from_, move_up_left_two))
elif self.check_move_legal(from_, move_down_right_one, color) != False: if self.check_move_legal(from_, move_up_right_two, color) != False:
legal_moves.append((from_, move_down_right_one)) legal_moves.append((from_, move_up_right_two))
return legal_moves return legal_moves
def get_possible_move(self, from_, color): def get_possible_move_non_capture(self, from_, color):
# get all possible moves from the pawn in from_ position # all non-capturing moves
# "-" in first position -> move to the "left" legal_moves = []
# "+" in first postiin -> move to the "right" move_down_left_one = (from_[0] + 1, from_[1] - 1)
# "-" in second postion -> move "up" move_down_right_one = (from_[0] + 1, from_[1] + 1)
# "+" in second position -> move "down" move_up_left_one = (from_[0] - 1, from_[1] - 1)
legal_moves = self.get_possible_move_up(from_, color) move_up_right_one = (from_[0] - 1, from_[1] + 1)
legal_moves.append(self.get_possible_move_down(from_, color)) if self.check_move_legal(from_, move_down_left_one, color) != False:
legal_moves.append((from_, move_down_left_one))
if self.check_move_legal(from_, move_down_right_one, color) != False:
legal_moves.append((from_, move_down_right_one))
if self.check_move_legal(from_, move_up_left_one, color) != False:
legal_moves.append((from_, move_up_left_one))
if self.check_move_legal(from_, move_up_right_one, color) != False:
legal_moves.append((from_, move_up_right_one))
return legal_moves return legal_moves
def get_possible_moves(self, color): def get_possible_moves(self, color):
# toDo: get possible moves for single piece, then iterate through all pieces # toDo: get possible moves for single piece, then iterate through all pieces
legal_moves = [] legal_moves = []
captures = []
if color == "white": if color == "white":
for white_position in self.white_positions: for white_position in self.white_positions:
print((white_position[0], white_position[1])) # print((white_position[0], white_position[1]))
legal_moves.append(self.get_possible_move((white_position[0], white_position[1]), color)) legal_moves += self.get_possible_move_non_capture(
(white_position[0], white_position[1]), color)
captures += self.get_possible_move_capture(
(white_position[0], white_position[1]), color)
elif color == "black": elif color == "black":
for black_position in self.black_positions: for black_position in self.black_positions:
legal_moves.append(self.get_possible_move((black_position[0], black_position[1]), color)) legal_moves += self.get_possible_move_non_capture(
return legal_moves (black_position[0], black_position[1]), color)
captures += self.get_possible_move_capture(
(black_position[0], black_position[1]), color)
print('CAPTURES: ')
print(captures)
# if len(captures) > 0:
# print('CAPTURE POSSIBLE')
# print(captures)
# return captures
print('LEGAL MOVES')
print(legal_moves + captures)
return legal_moves + captures
def alpha_beta(self, depth, alpha, beta, player): def alpha_beta(self, depth, alpha, beta, color):
if depth == 0: if depth == 0:
return self.evaluate(), None return self.evaluate(), None
if player == 'x': if color == 'white':
max_eval = float('-inf') max_eval = float('-inf')
best_move = None best_move = None
for move in self.get_possible_moves(player): for move in self.get_possible_moves(color):
new_state = copy.deepcopy(self) new_state = copy.deepcopy(self)
new_state.move(*move) new_state.make_move(*move, 'white')
eval, _ = alpha_beta(new_state, depth-1, alpha, beta, 'o') eval, _ = new_state.alpha_beta(depth-1, alpha, beta, 'black')
if eval > max_eval: if eval > max_eval:
max_eval = eval max_eval = eval
@ -256,10 +286,10 @@ class Game:
min_eval = float('inf') min_eval = float('inf')
best_move = None best_move = None
for move in state.get_possible_moves(player): for move in self.get_possible_moves(color):
new_state = copy.deepcopy(state) new_state = copy.deepcopy(self)
new_state.move(*move) new_state.make_move(*move, 'black')
eval, _ = alpha_beta(new_state, depth-1, alpha, beta, 'x') eval, _ = new_state.alpha_beta(depth-1, alpha, beta, 'white')
if eval < min_eval: if eval < min_eval:
min_eval = eval min_eval = eval
@ -278,17 +308,17 @@ class Game:
for white_position in self.white_positions: for white_position in self.white_positions:
if white_position[2]: if white_position[2]:
white_score += 2 white_score += 10
else: else:
white_score += 2 white_score += 5
for black_position in self.black_positions: for black_position in self.black_positions:
if black_position[2]: if black_position[2]:
black_score += 2 black_score += 10
else: else:
black_score += 2 black_score += 5
return x_score - o_score return white_score - black_score
def input_to_coordinates(self, input): def input_to_coordinates(self, input):
pos_x = ord(input[0])-ord('a') pos_x = ord(input[0])-ord('a')
@ -299,7 +329,7 @@ class Game:
has_moved = False has_moved = False
while not has_moved: while not has_moved:
user_input = input('How do you want to move? (format: d6 e5)\n') user_input = input('How do you want to move? (format: d6 e5)\n')
regex = r"^[A-Za-z]\d+\s[A-Za-z]\d+$" regex = r"^[a-z]\d+\s[a-z]\d+$"
match = re.search(regex, user_input) match = re.search(regex, user_input)
if not match: if not match:
print('Invalid input, try again') print('Invalid input, try again')
@ -312,9 +342,17 @@ class Game:
self.print_board() self.print_board()
# Ran first in the code # Ran first in the code
if __name__ == "__main__": if __name__ == "__main__":
game = Game(8) game = Game(8)
while True:
game.print_board() game.print_board()
possible_moves_black = game.get_possible_moves('black')
if len(possible_moves_black) == 0:
print('Game over. White wins')
game.handle_player_move('black') game.handle_player_move('black')
possible_moves_white = game.get_possible_moves('black')
if len(possible_moves_white) == 0:
print('Game over. Black wins')
_, ai_move = game.alpha_beta(1, 5, 10, 'white')
game.make_move(ai_move[0], ai_move[1], 'white')