def main():
pygame.mixer.init()
mixer.music.load('background.wav')
mixer.music.play(-1)
run = True
clock = pygame.time.Clock()
game = Game(WIN)
while True:
clock.tick(FPS)
winner = game.winner()
if winner != None:
messagebox.showinfo(
"Winner",
"{0}! You won smarty pants!".format("Red" if winner == (
255, 0, 0) else "Blue"))
break
if game.turn == BLUE:
value, new_board = minimax(game.get_board(), 3, BLUE, game)
game.ai_move(new_board)
for event in pygame.event.get():
if event.type == pygame.QUIT:
break
if event.type == pygame.MOUSEBUTTONDOWN:
mouse_pos = pygame.mouse.get_pos()
row, col = get_row_col_from_mouse(mouse_pos)
game.select(row, col)
game.update()
pygame.quit()
def __init__(self, path_rede_branca, path_rede_preta):
self.rede_branca = pickle.load(open(path_rede_branca, "rb"))
self.rede_preta = pickle.load(open(path_rede_preta, "rb"))
self.train_time = self.rede_branca['time']
self.game = Game()
self.game.consecutive_noncapture_move_limit = 300
# self.game.consecutive_noncapture_move_limit = 40
self.players = {1: -1, 2: 1}
self.playersPrint = {1: 'B', 2: 'P'}
index = np.arange(1, 33)
self.positions_map = {}
for i, j in zip(np.arange(1, 5), np.arange(1, 8, 2)):
self.positions_map[i] = [0, j]
self.positions_map[i + 8] = [2, j]
self.positions_map[i + 16] = [4, j]
self.positions_map[i + 24] = [6, j]
for i, j in zip(np.arange(5, 9), np.arange(0, 8, 2)):
self.positions_map[i] = [1, j]
self.positions_map[i + 8] = [3, j]
self.positions_map[i + 16] = [5, j]
self.positions_map[i + 24] = [7, j]
self.sr_branca = 0
self.draw = 0
self.sr_preta = 0
def main_Human_vs_AI():
clock = pygame.time.Clock()
game = Game(WIN)
run = True
while run:
clock.tick(FPS)
game.update()
if game.turn == WHITE:
value, new_board = alpha_beta_pruning(game.get_board(), 5, False,
float("-inf"), float("inf"),
game)
if new_board is None:
print("White loose")
run = False
time.sleep(5000)
else:
game.ai_move(new_board)
if game.winner() != None:
run = False
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
if event.type == pygame.MOUSEBUTTONDOWN:
x = get_row_col_from_mouse(pygame.mouse.get_pos())
if x is not None:
game.select(x[1], x[0])
pygame.quit()
def main():
run = True
clock = pygame.time.Clock()
game = Game(WIN)
while run:
clock.tick(60)
if game.turn == WHITE:
#value, new_board = minimax(game.get_board(), 4, WHITE, game)
value, new_board = alpha_beta(game.get_board(), 2, WHITE, game,
float('-inf'), float('inf'))
game.ai_move(new_board)
if game.winner() != None:
run = False
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
if event.type == pygame.MOUSEBUTTONDOWN:
pos = pygame.mouse.get_pos()
row, col = get_row_col_from_mouse(pos)
game.select(row, col)
game.update()
pygame.quit()
def __init__(self, tournament_id):
self.tournament_id = tournament_id
self.moves = []
self.start_time = None
self.end_time = None
self.game = Game()
self.start()
def main():
run = True
clock = pg.time.Clock()
game = Game(WIN)
while run:
clock.tick(FPS)
if game.turn == WHITE:
value, new_board = minimax(game.get_board(),3, WHITE, game)
game.ai_move(new_board)
if game.winner != None:
print(game.winner())
for event in pg.event.get():
if event.type == pg.QUIT:
run = False
if event.type == pg.MOUSEBUTTONDOWN:
pos = pg.mouse.get_pos()
row, col = get_row_col_from_mouse(pos)
game.select(row, col)
game.update()
pg.quit()
def _min_max(self, game: Game,
maximize_score: bool,
move_list: List[Tuple[int, int]] = None,
alpha=MinMaxWeight.LOSE, beta=MinMaxWeight.WIN,
depth=0) \
-> Tuple[float, Optional[int]]:
"""
Calculate the min max
:param depth: The current depth of the branch
:return: The score and the move
"""
# Check if the game is over
if game.is_over():
winner = game.get_winner()
if winner == self.player:
return MinMaxWeight.WIN, None
return MinMaxWeight.LOSE, None
# Check if the max depth is reached
if depth >= self.branch_depth:
return self.evaluate_path(game), None
if not move_list:
move_list = game.get_possible_moves()
random.shuffle(move_list)
# Get the smallest/largest number to initialize the var
best_score: float = MinMaxWeight.LOSE if maximize_score else MinMaxWeight.WIN
best_move = move_list[0]
# Iterate through the moves and recursively find the best
for move in move_list:
updated_game = copy.deepcopy(game)
updated_game.move(move)
returned_best_score, _ = MinMax._min_max(self,
updated_game,
not maximize_score,
alpha=alpha,
beta=beta,
depth=depth + 1)
if maximize_score and best_score < returned_best_score:
best_score = returned_best_score
best_move = move
alpha = max(alpha, best_score)
if beta <= alpha:
break
elif not maximize_score and returned_best_score < best_score:
best_score = returned_best_score
best_move = move
beta = min(beta, best_score)
if beta <= alpha:
break
return best_score, best_move
def __init__(self, player: int, *_):
"""
Generate a new Random game
:param player: The player of the RandomGame (1 or 2)
"""
self.player = player
self._game = Game()
def startGame(self):
self.game = Game()
while 1:
try:
player = int(
input(
"Deseja jogar com as peças brancas (1) ou pretas (2): "
))
if player == 1 or player == 2:
self.player = player
break
else:
print("Escolha inválida")
except:
print("Escolha inválida")
if self.player == 2:
k1 = self.rede_branca['k']
weights = self.rede_branca['weights']
num_hidden_layers = self.rede_branca['num_hidden_layers']
hidden_size = self.rede_branca['hidden_size']
else:
k1 = self.rede_preta['k']
weights = self.rede_preta['weights']
num_hidden_layers = self.rede_preta['num_hidden_layers']
hidden_size = self.rede_preta['hidden_size']
k2 = -1 * k1
limit = 33 * hidden_size
weights = [
self.reconstructWeightsMatrix(weights[:limit], 0, hidden_size),
self.reconstructWeightsMatrix(weights[limit:-1], 1, hidden_size)
] #temporario pra contornar o sigma
rede = [num_hidden_layers, hidden_size, weights]
print("\nAs posições são as seguintes: \n")
self.printBoard(board_encoded=None, demo=True)
print("\nJogador 1 começa\n")
while not self.game.is_over():
board_encoded = self.createBoard(self.game, k1, k2, print=True)
self.printBoard(board_encoded)
if self.game.whose_turn() != self.player:
self.play(k1, k2, rede, rede)
else:
selected = self.selectMove()
if not isinstance(selected, list) and selected < 0:
break
self.game.move(selected)
print("Vez do jogador ", self.game.whose_turn())
if not isinstance(selected, list) and selected < 0:
print("Player ", self.player, " desistiu. Jogador ",
3 - self.player, " venceu.")
else:
print("Player ", self.game.get_winner(), " venceu")
def initialize_game(moves):
game = Game()
boards = [game.board]
for move in moves:
game.move(move)
boards.append(game.board)
return game, boards
def __init__(self, board: str = None) -> None:
self.game = Game()
if board:
lines = board.split('\n')
self.theme = int(lines.pop(0))
for mov in lines.pop(0).split():
self.game.move(list(map(int, mov.split(','))))
else:
self.theme = 0
def test_possible_moves(self):
self.game = Game()
self.expect([[9, 13], [9, 14], [10, 14], [10, 15], [11, 15], [11, 16],
[12, 16]]).move([10, 14])
self.expect([[21, 17], [22, 17], [22, 18], [23, 18], [23, 19],
[24, 19], [24, 20]]).move([23, 18])
self.expect([[14, 23]]).move([14, 23])
self.expect([[26, 19], [27, 18]]).move([27, 18])
self.expect([[6, 10], [7, 10], [9, 13], [9, 14], [11, 15], [11, 16],
[12, 16]]).move([9, 13])
self.expect([[18, 14], [18, 15], [21, 17], [22, 17], [24, 19],
[24, 20], [26, 23], [31, 27], [32, 27]]).move([21, 17])
self.expect([[5, 9], [6, 9], [6, 10], [7, 10], [11, 15], [11, 16],
[12, 16]]).move([6, 10])
self.expect([[17, 14], [18, 14], [18, 15], [24, 19], [24, 20],
[25, 21], [26, 23], [31, 27], [32, 27]]).move([18, 14])
self.expect([[1, 6], [2, 6], [5, 9], [10, 15], [11, 15], [11, 16],
[12, 16]]).move([2, 6])
self.expect([[14, 9], [22, 18], [24, 19], [24, 20], [25, 21], [26, 23],
[31, 27], [32, 27]]).move([31, 27])
self.expect([[5, 9], [6, 9], [10, 15], [11, 15], [11, 16],
[12, 16]]).move([11, 16])
self.expect([[14, 9], [22, 18], [24, 19], [24, 20], [25, 21], [26, 23],
[27, 23]]).move([22, 18])
self.expect([[13, 22]]).move([13, 22])
self.expect([[22, 31]]).move(
[22, 31]
) #double jump where 10-17 is also in a jumpable position if not for piece restriction
self.expect([[14, 9], [18, 15], [24, 19], [24, 20], [25, 21], [25, 22],
[27, 23], [30, 26]]).move([24, 19])
self.expect([[10, 17], [16, 23], [31, 24]]).move([31, 24])
self.expect([[24, 15]]).move([24, 15])
self.expect([[15, 22]]).move([15, 22])
self.expect([[25, 18]]).move([25, 18])
self.expect([[10, 17]]).move([10, 17])
self.expect([[18, 14], [18, 15], [28, 24], [29, 25], [30, 25],
[30, 26], [32, 27]]).move([29, 25])
self.expect([[5, 9], [6, 9], [6, 10], [7, 10], [7, 11], [8, 11],
[16, 19], [16, 20], [17, 21], [17, 22]]).move([17, 21])
self.expect([[18, 14], [18, 15], [25, 22], [28, 24], [30, 26],
[32, 27]]).move([30, 26])
self.expect([[21, 30]]).move([21, 30])
self.expect([[18, 14], [18, 15], [26, 22], [26, 23], [28, 24],
[32, 27]]).move([18, 15])
self.expect([[30, 23]]).move([30, 23])
self.expect([[15, 10], [15, 11], [28, 24], [32, 27]]).move([15, 11])
self.expect([[8, 15]]).move([8, 15])
self.expect([[28, 24], [32, 27]]).move([28, 24])
self.expect([[3, 8], [4, 8], [5, 9], [6, 9], [6, 10], [7, 10], [7, 11],
[15, 18], [15, 19], [16, 19], [16, 20], [23, 26],
[23, 27], [23, 18], [23, 19]]).move([4, 8])
self.expect([[24, 19], [24, 20], [32, 27], [32, 28]]).move([24, 19])
self.expect([[15, 24]]).move([15, 24])
self.expect([[32, 27], [32, 28]]).move([32, 27])
self.expect([[23, 32], [24, 31]]).move([23, 32])
self.expect([])
def test_game():
james = RandomPlayer('James')
peter = RandomPlayer('Peter')
a_game = Game(james, peter)
assert a_game.winner == 'Nobody'
a_game.play()
print('The winner is {}'.format(a_game.winner))
for i, j, val in a_game.moves:
print('{i}, {j} : {val}'.format(i=i, j=j, val=val))
def test_get_possible_next_states(self):
game1 = Game()
game2 = game1.move([11, 16])
next_states = game1.get_possible_next_states(actual_next_state=game2)
self.assertEqual(len(next_states), 7)
self.assertEqual(type(next_states[0]), Game)
actual_next_state = next(s for s in next_states
if s.last_move() == [11, 16])
self.assertEqual(actual_next_state, game2)
def main():
game = Game()
game.consecutive_noncapture_move_limit = 100
while (not game.is_over()):
if game.whose_turn() == 1:
human_move(
game
) # if you want the bot to play for the human replace this line with bot_move(game,desired_depth)
# bot_move(game, 1)
else:
bot_move(game, 5)
print_game_to_console(game)
def startGame(self, num_matches, num_executions=1):
self.game = Game()
self.sr_branca = 0
self.draw_branca = 0
self.sr_preta = 0
self.draw_preta = 0
k1 = self.rede_branca['k']
k2 = self.rede_preta['k']
weights = self.rede_branca['weights']
num_hidden_layers = self.rede_branca['num_hidden_layers']
hidden_size = self.rede_branca['hidden_size']
limit = 33*hidden_size
weights = [self.reconstructWeightsMatrix(weights[:limit], 0, hidden_size),
self.reconstructWeightsMatrix(weights[limit:], 1, hidden_size)]
rede_branca = [num_hidden_layers, hidden_size, weights]
weights = self.rede_preta['weights']
num_hidden_layers = self.rede_preta['num_hidden_layers']
hidden_size = self.rede_preta['hidden_size']
limit = 33*hidden_size
weights = [self.reconstructWeightsMatrix(weights[:limit], 0, hidden_size),
self.reconstructWeightsMatrix(weights[limit:], 1, hidden_size)]
rede_preta = [num_hidden_layers, hidden_size, weights]
self.sr_branca = np.zeros(num_executions)
self.sr_preta = np.zeros(num_executions)
self.draw = np.zeros(num_executions)
for e in tqdm(range(num_executions)):
for i in tqdm(range(num_matches), leave=False):
while not self.game.is_over():
if self.game.whose_turn() == 1:
self.play(k1, k1, rede_branca, rede_preta)
else:
self.play(k2, k2, rede_branca, rede_preta)
if self.game.get_winner() is not None:
if self.game.get_winner() == 1:
self.sr_branca[e] += 1/num_matches
# self.sr_branca += 1/num_matches
else:
self.sr_preta[e] += 1/num_matches
# self.sr_preta += 1/num_matches
else:
self.draw[e] += 1/num_matches
# self.draw += 1/num_matches
self.game = Game()
def main():
run = True
# define a clock if we want our game to run in a constant frame rate
clock = pygame.time.Clock()
game = Game(WIN)
while run:
clock.tick(
FPS
) # to make sure the main event loop does not run too fast or too slow
if game.winner() != None:
print(game.winner())
run = False
for event in pygame.event.get():
if event.type == pygame.QUIT: # quitting game event
run = False
if event.type == pygame.MOUSEBUTTONDOWN: # pressing buttons
# when we click, pygame will take the position of our 'click'
pos = pygame.mouse.get_pos()
# take the row and column corresponding to this position
row, col = get_row_col_from_mouse(pos)
# the board will recognize the piece in these row and column
game.select(row, col)
game.update()
pygame.quit()
def play_game(prediction_request, simulation_depth):
startTime = datetime.now()
global game, player1, player2
game = Game()
player1 = Player(1, game, MultiprocessModel(prediction_request))
player2 = Player(2, game, MultiprocessModel(prediction_request))
while not game.is_over():
play_turn(simulation_depth)
finalize_lessons()
print('game over', datetime.now() - startTime, len(game.moves), 'moves')
def main(): run = True clock = pygame.time.Clock() game = Game(WIN) while run: clock.tick(FPS) if game.winner() != None: print(game.winner()) run = False for event in pygame.event.get(): if event.type == pygame.QUIT: run = False if event.type == pygame.MOUSEBUTTONDOWN: pos = pygame.mouse.get_pos() row, col = get_row_col_from_mouse(pos) game.select(row, col) game.update() pygame.quit()
def main():
run = True
# Make sure game doesn't run too fast or too slow
clock = pygame.time.Clock()
# Create a Game object which will control the board for us
game = Game(WIN)
# Create an event loop while the game is running
while run:
clock.tick(FPS)
if game.winner() != None:
print(game.winner())
run = False
# Check for any events happening at current time
for event in pygame.event.get():
# End the game and get rid of window by clicking the cross
if event.type == pygame.QUIT:
run = False
# If we press any button on mouse, we first get the row, column we are in
# Then we will select the piece on that location and move that to wherever we want to move
if event.type == pygame.MOUSEBUTTONDOWN:
pos = pygame.mouse.get_pos()
row, col = get_row_col_from_mouse(pos)
game.select(row, col)
game.update()
pygame.quit()
def main():
"""Game running example."""
# Pick both players, User or RandomBot require a Player parameter...
black_bot = User(Player.black)
# ...and CheckerBot does too. An optional parameter is an integer
# that represents the depth for the Bot. By default is 6.
white_bot = CheckersBot(Player.white, 6)
# Start Game class selecting how many games will be played.
game = Game(1)
# Start the program indicating the white player, the black one,
# a boolean that requests printing on the console (True prints
# the board), and who will have the first turn.
game.simulate(white_bot, black_bot, True, Player.white)
def test_position_layout_2d(self):
board = Game().board
np.testing.assert_array_equal(
board.position_layout_2d,
np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12],
[13, 14, 15, 16], [17, 18, 19, 20], [21, 22, 23, 24],
[25, 26, 27, 28], [29, 30, 31, 32]]))
def main():
# What we run to run game
run = True # If you want the game to run
clock = pygame.time.Clock() # The fps speed of the game
game = Game(WIN)
while run:
clock.tick(FPS)
if game.winner() != None:
print(f"{game.winner()} has won!!!")
# The pygame event handler
for event in pygame.event.get():
if event.type == pygame.QUIT: # If hit red cross on pygame window
run = False
if event.type == pygame.MOUSEBUTTONDOWN: # If any button on mouse pressed down
pos = pygame.mouse.get_pos()
row, col = row_col_from_mouse(pos)
game.select(row, col)
game.update()
pygame.quit()
def main():
run = True
clock = pygame.time.Clock()
game = Game(WIN)
# mouse_pos is a tuple
def get_row_col_from_mouse(mouse_pos):
x, y = mouse_pos
mouse_row = y // SQUARE_SIZE
mouse_col = x // SQUARE_SIZE
return mouse_row, mouse_col
while run:
# clock.tick(FPS)
if game.winner() is not None:
print(f"The winner is {game.winner()}!")
break
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
break
if event.type == pygame.MOUSEBUTTONDOWN:
pos = pygame.mouse.get_pos()
row, col = get_row_col_from_mouse(pos)
# send the position of the selected square
game.select(row, col)
game.update()
pygame.quit()
class Animation:
def __init__(self):
self.win = pygame.display.set_mode((WIDTH, HEIGHT + SQUARE_SIZE))
pygame.display.set_caption("Checkers")
self.game = Game(self.win)
self.game_over = False
self.end_screen = EndScreen(self.win, None)
def update(self):
result = self.game.get_winner()
if self.game_over:
self.game.board.draw(self.win)
self.end_screen.draw()
if result:
self.end_screen.set_winner(result)
self.game_over = True
else:
self.game.update()
pygame.display.flip()
def mouse_down(self, position):
if not self.game_over:
self.game.select(position)
else:
if self.end_screen.clicked(position):
self.game.reset()
self.game_over = False
class TournamentGame():
def __init__(self, tournament_id):
self.tournament_id = tournament_id
self.moves = []
self.start_time = None
self.end_time = None
self.game = Game()
self.start()
def start(self):
self.start_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
def end(self):
self.end_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
def move(self, move):
self.game.move(move)
self.moves.append(move)
def main():
clock = pygame.time.Clock()
game = Game(WIN)
run = True
while run:
clock.tick(FPS)
game.update()
if game.winner() != None:
run = False
if game.turn == WHITE:
value, new_board = alpha_beta_pruning(game.get_board(), 3, False,
float("-inf"), float("inf"),
game)
if new_board is None:
print("WUT")
time.sleep(5000)
game.ai_move(new_board)
# else:
# value, new_board = alpha_beta_pruning(game.get_board(), 3, True, float("-inf"), float("inf"), game)
# if new_board is None:
# print("WUT")
# print("WUT")
# time.sleep(5000)
# game.ai_move(new_board)
#pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
if event.type == pygame.MOUSEBUTTONDOWN:
x = get_row_col_from_mouse(pygame.mouse.get_pos())
if x is not None:
game.select(x[1], x[0])
print(f"1: {game.board.evaluation_1()}")
print(f"2: {game.board.evaluation_2()}")
print(f"3: {game.board.evaluation_3()}")
pygame.quit()
def test_flip(self):
board = Game().board
self.assertEqual(board.flip_position(32), 1)
self.assertEqual(board.flip_position(1), 32)
self.assertEqual(board.flip_position(29), 4)
self.assertEqual(board.flip_position(4), 29)
self.assertEqual(board.flip_position(19), 14)
self.assertEqual(board.flip_position(14), 19)
def main():
run = True
clock = pygame.time.Clock()
game = Game(WIN)
while run:
clock.tick(FPS)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
if event.type == pygame.MOUSEBUTTONDOWN:
position = pygame.mouse.get_pos()
row, col = get_coordinates_from_mouse_click(position)
game.update()
pygame.quit()
def join(sid, data):
global games
global playerColors
playerColors[sid] = data["playerColor"]
# print(playerColors[sid])
games[sid] = Game()
return {"board": games[sid].get_board_state()}
