def _do_aimove(self):
ts = self.train_settings
while not self.board.current_move.analysis_ready:
self.info.text = "Thinking..."
time.sleep(0.05)
# select move
current_move = self.board.current_move
pos_moves = [
(d["move"], float(d["scoreLead"]), d["evaluation"])
for i, d in enumerate(current_move.ai_moves)
if i == 0 or int(d["visits"]) >= ts["balance_play_min_visits"]
]
sel_moves = pos_moves[:1]
# don't play suicidal to balance score - pass when it's best
if self.ai_balance.active and pos_moves[0][0] != "pass":
sel_moves = [
(move, score, move_eval)
for move, score, move_eval in pos_moves
if move_eval > ts["balance_play_randomize_eval"]
and -current_move.player_sign * score > 0 or move_eval >
ts["balance_play_min_eval"] and -current_move.player_sign *
score > ts["balance_play_target_score"]
] or sel_moves
aimove = Move(player=self.board.current_player,
gtpcoords=random.choice(sel_moves)[0],
robot=True)
if len(sel_moves) > 1:
aimove.x_comment[
"ai"] = "AI Balance on, moves considered: " + ", ".join(
f"{move} ({aimove.format_score(score)})"
for move, score, _ in sel_moves) + "\n"
self.play(aimove)
def get_player_move() -> Move:
player_move: Move = Move(-1)
while player_move not in board.legal_moves:
play: int = int(input("Enter a legal square (0-8):"))
player_move = Move(play)
return player_move
def test_diagonal_win(self):
self.test_board.place_move(Move(2, 0, PlayerType.CIRCLE))
self.test_board.place_move(Move(1, 1, PlayerType.CIRCLE))
win_move = Move(0, 2, PlayerType.CIRCLE)
self.test_board.place_move(win_move)
assert self.test_board.is_winning_move(win_move) == True
def test_is_winning_move_horizontal(self):
test_moves = [Move(i, 0, PlayerType.CIRCLE) for i in range(4)]
for move in test_moves:
self.test_board.place_move(move)
winning_move = Move(4, 0, PlayerType.CIRCLE)
self.test_board.place_move(winning_move)
self.assertTrue(self.test_board.is_winning_move(winning_move))
def get_player_move() -> Move:
# initialise Move to a negative number
player_move: Move = Move(-1)
# as for a move. condition will be satisfied as Move(-1)
# is not a legal move
while player_move not in board.legal_moves:
play: int = int(input("Enter a legal square (0-8): "))
player_move = Move(play)
return player_move
def test_is_winning_move_diagonal_trivial(self):
test_moves = [Move(i, i, PlayerType.CIRCLE) for i in range(4)]
for move in test_moves:
self.test_board.place_move(move)
winning_move = Move(4, 4, PlayerType.CIRCLE)
self.test_board.place_move(winning_move)
self.assertTrue(self.test_board.is_winning_move(winning_move))
def test_is_pawn_jump(self):
board = Board()
board.move(E2, E4)
board.move(D2, D3)
board.move(H7, H5)
self.assertTrue(is_pawn_jump(board, Move(E2, E4), WHITE))
self.assertFalse(is_pawn_jump(board, Move(D2, D3), WHITE))
self.assertTrue(is_pawn_jump(board, Move(H7, H5), BLACK))
with self.assertRaises(InternalError):
is_pawn_jump(board, Move(H6, H4), BLACK)
def select_move(self, game_state):
candidates = []
for r in range(1, BOARD_SIZE + 1):
for c in range(1, BOARD_SIZE + 1):
candidate = Point(row=r, col=c)
if game_state.is_valid_move(Move(candidate)):
candidates.append(candidate)
if not candidates:
print('Game over')
return Move(random.choice(candidates))
def create_board(self, settings, flagged=None, move=None):
self.board = BoardGenerator.generate_boards(settings, self.theme,
flagged)
self.last_settings = settings
if move == None:
self.first_move()
else:
Move.check_move(self, move)
if self.board.status == "play mode":
self.play()
return
def test_is_winning_move_diagonal_complex(self):
test_moves = [
Move(x, y, PlayerType.CIRCLE)
for x, y in [(5, 5), (7, 3), (8, 2), (9, 1)]
]
for move in test_moves:
self.test_board.place_move(move)
winning_move = Move(6, 4, PlayerType.CIRCLE)
self.test_board.place_move(winning_move)
self.assertTrue(self.test_board.is_winning_move(winning_move))
def test_is_winning_move_diagonal_inter(self):
test_moves = [Move(i, i, PlayerType.CIRCLE) for i in range(2)]
for move in test_moves:
self.test_board.place_move(move)
test_moves = [Move(i, i, PlayerType.CIRCLE) for i in range(3, 5)]
for move in test_moves:
self.test_board.place_move(move)
winning_move = Move(2, 2, PlayerType.CIRCLE)
self.test_board.place_move(winning_move)
self.assertTrue(self.test_board.is_winning_move(winning_move))
def _drawSquareHighlights(self):
size = ChessGui.SQR_SIZE
app = self._app
id = self._canvas
if self._from != None:
(mx, my) = self._from
my = 7 - my
color = "#ee0"
app.addCanvasRectangle(id,
mx * size,
my * size,
size,
size,
width=3,
outline=color,
fill=None)
if self._mouseOverSqr != None:
(mx, my) = self._mouseOverSqr
color = "#090"
if self._from != None and Move(
self._from,
self._mouseOverSqr) in self._board.possibleMoves():
color = "#ee0" # Possible move
elif self._board.get(mx, my) == self._currentColor:
color = "#cc0" # Possible piece to move
app.addCanvasRectangle(id,
mx * size, (7 - my) * size,
size,
size,
width=2,
outline=color,
fill=None)
def play(user):
board = user.start_board()
board.print_board()
move_input = ''
quit_check = ''
while board.status.lower() == 'play':
move_input = str('Available moves: l/r/u/d/q : ').lower()
while move_input not in ('l', 'r', 'u', 'd', 'q'):
move_input = input('Available moves: (l/r/u/d/q) : ')
if move_input == 'q':
quit_check = str(
input('Are you sure you want to quit? Y/N : ')).lower()
if quit_check == 'y':
exit
else:
continue
Move(board, move_input)
board.print_board()
user.update_userplayhist()
if board.status == 'won':
print('Congratulations. You won!!!')
elif board.status == 'lost':
print('Sorry. Better luck next game!')
another_game = str(input('Would you like to play another game? ')).lower()
if another_game == 'y':
play(user)
else:
print('Thanks for playing,', user.name, '. See you again!')
user.update_userplayhist()
def test_init(self):
b1 = Board()
self.assertEqual(WHITE, b1._player)
self.assertNotEqual(WHITE, b1[4][2])
self.assertEqual(4, len(b1))
self.assertEqual(4, len(b1._moves))
self.assertEqual(2, b1.count(WHITE))
self.assertEqual(2, b1.count(BLACK))
m2 = Move(WHITE, 4, 2)
b2 = Board(b1, m2)
self.assertEqual(BLACK, b2._player)
self.assertEqual(WHITE, b2[4][2])
self.assertEqual(WHITE, b2[4][3])
self.assertEqual(5, len(b2))
self.assertEqual(3, len(b2._moves))
self.assertEqual(4, b2.count(WHITE))
self.assertEqual(1, b2.count(BLACK))
b0 = Board(b1, None)
b0._p[3][3] = None
b0._p[3][4] = None
b0._p[4][3] = None
b0._p[4][4] = None
b0._moves = []
self.assertNotEqual(WHITE, b0[3][3])
self.assertEqual(0, len(b0))
self.assertEqual(0, len(b0._moves))
self.assertEqual(0, b0.count(WHITE))
self.assertEqual(0, b0.count(BLACK))
def test_moves_1(self):
b1 = Board()
b1._moves = []
b1._p[7][0] = WHITE
b1._p[5][1] = BLACK
b1._p[6][1] = WHITE
b1._p[1][2] = BLACK
b1._p[2][2] = BLACK
b1._p[3][2] = BLACK
b1._p[4][2] = BLACK
b1._p[5][2] = BLACK
b1._p[6][2] = BLACK
b1._p[2][3] = BLACK
b1._p[3][3] = BLACK
b1._p[4][3] = BLACK
b1._p[5][3] = BLACK
b1._p[6][3] = BLACK
b1._p[7][3] = BLACK
b1._p[3][4] = BLACK
b1._p[4][4] = BLACK
b1._p[5][4] = BLACK
b1._p[5][5] = BLACK
b1._p[5][6] = BLACK
print(b1.show())
b2 = Board(b1, Move(WHITE, 2, 5))
print(b2.show())
self.assertEqual(6, len(b2._moves))
def handleUserInput(self, event):
for i in range(9):
for j in range(9):
pixel_x = (i + 1) * CELL_PIXELS
pixel_y = (j + 1) * CELL_PIXELS
square_x = math.pow((event.x - pixel_x), 2)
square_y = math.pow((event.y - pixel_y), 2)
distance = math.sqrt(square_x + square_y)
# since there is noly one intersection such that the distance between it
# and where the user clicks is less than 15, it is not necessary to find
# the actual least distance
if (distance < 15):
print(f"board pos {i},{j}")
if self.board.get(i, j) != 0:
print(
f"board pos {i},{j} already has piece {self.board.get( i,j) }"
)
return
move = Move(i, j)
print(f"User's move is {move}")
self.board.makeMove(move)
invalid_pos = False
row, col = i, j
self.boardCanvas.drawState()
self.master.update()
print(self.board)
self.unbind('<Button-1>')
self.master.after(100, self.gameLoop)
def select_move(self, game_state):
candidates = game_state.legal_moves()
if not candidates:
return Move.resign()
return random.choice(candidates)
def __make_my_move(self):
if self.client.winner:
print("winner: ", self.client.winner)
return True
move = self.board.decision()
if not move:
move = Move(0, 0, is_pass=True)
result, _ = self.board.try_move(move)
if result == ILLEGAL_MOVE:
raise Exception("illegal move")
print("me: ", move)
try:
if move.is_pass:
self.client.make_move("pass")
else:
self.client.make_move(str(move))
except gthclient.MoveError as e:
if e.cause == e.ILLEGAL:
print("me: made illegal move, passing")
self.client.make_move("pass")
except gthclient.ProtocolError as e:
# python library doesn't handle game draw, so manually
# handle it here
if e.expression == 325 or e.expression == 326:
print("game drawn")
return True
return False
def test_e_p(self):
board = empty_board()
wp1 = Figure(WHITE, PAWN)
wp2 = Figure(WHITE, PAWN)
bp = Figure(BLACK, PAWN)
board.put(E4, wp1)
board.put(E5, wp2)
board.put(D4, bp)
self.assertTrue(is_e_p(Move(E4, D5), board))
self.assertFalse(is_e_p(Move(D4, E5), board))
self.assertTrue(board.figure_on_position(D5) is None)
make_e_p(board, Move(E4, D5))
wp = board.figure_on_position(D5)
self.assertTrue(wp is not None)
self.assertEqual(wp.type, PAWN)
self.assertEqual(wp.color, WHITE)
def find_best_move(board: Board, max_depth: int = 8) -> Move:
best_eval: float = float("-inf")
best_move: Move = Move(-1)
for move in board.legal_moves:
result: float = alphabeta(board.move(move), False, board.turn, max_depth)
if result > best_eval:
best_eval = result
best_move = move
return best_move
def create_move(start, end, board, player_color,figure_to_create=None):
figure = board.figure_on_position(start)
if figure is None or figure.color != player_color:
raise InvalidMove("No valid figure at {0}".format(start))
if is_castling(start, end, board):
rook_move = CASTLING_DATA[(start, end)]['rook_move']
extra_move = Move(*rook_move)
return Move(start, end, type=CASTLING_MOVE, extra_move=extra_move)
eaten_position = Coordinates(end.x, start.y)
if is_e_p(start, end, board):
return Move(start, end, type=E_P_MOVE, eaten_position=eaten_position)
if board.figure_on_position(end) is not None:
eaten_position = end
else:
eaten_position = None
return Move(start, end, type=COMMON_MOVE, eaten_position=eaten_position,after_conversion=figure_to_create)
def _move(self, row, col):
piece = self.bo.board[row][col]
move = Move.check_if_possible(self.possible_moves, (row, col))
if self.selected_square and piece == "0" and move:
self.bo.make_move(move)
self.selected_square = None
self.possible_moves = []
self.change_turn()
else:
return False
return True
def select_move(self, game_state):
candidates = game_state.legal_moves()
if not candidates:
return Move.resign()
move = ""
while True:
move = input("Please enter your move in the format FromColRow:DestColRow. Example (A1:A2): ")
print('')
move = move.upper()
if move in [c.name() for c in candidates]:
break
elif move == "QUIT":
return Move.resign()
else:
print("Invalid move. Please specify a valid move!")
return self.get_move_by_name(candidates, move)
def selectSquare(self, x, y):
if self.selectedSquare is None:
self.selectedSquare = (x, y)
elif self.selectedSquare == (x, y):
self.selectedSquare = None
else:
move = Move(self.selectedSquare[0], self.selectedSquare[1], x, y)
self.selectedSquare = None
self.onBoardMove(move)
self.delete("all")
self.drawBoard()
def find_best_move(board: Board, max_depth: int = 8) -> Move:
best_eval: float = float('-inf')
best_move: Move = Move(-1)
for move in board.legal_moves:
# result: float = minimax(board.move(move),False,board.turn,max_depth)
# 我把上面的minimax换成了它的升级版alphabeta，性能得到了优化
result: float = alphabeta(board.move(move), False, board.turn,
max_depth)
if result > best_eval:
best_eval = result
best_move = move
return best_move
def play(self):
self.board.print_board()
if self.board.r.view == self.board.n.view:
self.wins()
move = input("Please make your move: ").split()
if (len(move) == 1) and (move[0] == "q"):
answer = input("Are you sure you want to quit? (y/n):")
if answer == "y":
self.board.status = "game over"
self.play_again()
return
else:
self.play()
return
if len(move) < 2:
print("Please make a valid move.")
self.play()
else:
Move.stop_playing(self, move[0], move[1].upper())
if self.board.status == "play mode":
self.play()
def test_winning_move(self):
game = Game()
game.start()
# set winning status to board
board = Board()
[board.place_move(Move(0, i, PlayerType.CIRCLE)) for i in range(4)]
winning_move = 0, 4
game._board = board
game.move(*winning_move)
self.assertTrue(game.is_finished)
def setMove(self, value):
mx, my = value
player_move = (my // CELL_HEIGHT * 3) + (mx // CELL_WIDTH)
if player_move in self._board.legal_moves:
self._board = self._board.move(Move(player_move))
self._grid.pic(PLAYER, player_move)
if self._board.is_win:
self._game_over = True
self._msgBox.active = STATUS.WIN
elif self._board.is_draw:
self._game_over = True
self._msgBox.active = STATUS.DRAW
if not self._game_over:
computer_move = find_best_move(self._board)
self._board = self._board.move(Move(computer_move))
self._grid.pic(COMPUTER, computer_move)
if self._board.is_win:
self._game_over = True
self._msgBox.active = STATUS.LOS
elif self._board.is_draw:
self._game_over = True
self._msgBox.active = STATUS.DRAW
def find_best_move(board: Board, max_depth: int = 8) -> Move:
# initialise values to negative numbers
best_eval: float = float("-inf")
best_move: Move = Move(-1)
# go through the possible moves and update not only the best_eval
# but also the best_move
for move in board.legal_moves:
# result: float = minimax(board.move(move), False, board.turn, max_depth)
result: float = alphabeta(board.move(move), False, board.turn, max_depth)
if result > best_eval:
best_eval = result
best_move = move
return best_move
def find_best_move(board: Board, max_depth: int = 8) -> Move:
best_eval: float = float("-inf")
best_move: Move = Move(-1)
for move in board.legal_moves:
result: float = alphabeta(board.move(move), False, board.turn,
max_depth)
if result > best_eval:
best_eval = result
best_move = move
global count
print(f"Nodes visited: {count}")
count = 0
return best_move
def takePlayerMove():
print gameBoard
print "FEN:", util.boardToFEN(gameBoard)
pseudoMoves = movegenerator.generatePseudoMoves(gameBoard)
print "Pseudo moves (" + str(len(pseudoMoves)) + "): ", pseudoMoves
legalMoves = filter(lambda move: gameBoard.lazyIsLegalMove(move), pseudoMoves)
print "Legal moves (" + str(len(legalMoves)) + "): ", legalMoves
move = input("Enter the next move:")
if move == "undo":
gameBoard.takeMove()
else:
move = Move.fromUCI(move)
if move in legalMoves:
gameBoard.makeMove(move)
else:
print "Illegal move!"
takePlayerMove()
