def simulate_random_game(game: GameState):
bots = {Player.black: RandomBot(), Player.white: RandomBot()}
while (not game.is_over()):
bot_move = bots[game.next_player].select_move(game)
game = game.apply_move(bot_move)
return game.winner()
def simulate_random_game(game: GameState) -> Player:
bots = {
Player.black: FastRandomAgent(),
Player.white: FastRandomAgent(),
}
while not game.is_over():
bot_move = bots[game.next_player].select_move(game)
game = game.apply_move(bot_move)
return cast(Player, game.winner())
def get_handicap(sgf):
go_board = Board(19, 19)
first_move_done = False
move = None
game_state = GameState.new_game(19)
if sgf.get_handicap() is not None and sgf.get_handicap() != 0:
for setup in sgf.get_root().get_setup_stones():
for move in setup:
row, col = move
go_board.place_stone(Player.black, Point(row + 1, col + 1))
first_move_done = True
game_state = GameState(go_board, Player.white, None, move)
return game_state, first_move_done
def test_new_game(self):
start = GameState.new_game(19)
next_state = start.apply_move(Move.play(Point(16, 16)))
self.assertEqual(start, next_state.previous_state)
self.assertEqual(Player.white, next_state.next_player)
self.assertEqual(Player.black, next_state.board.get(Point(16, 16)))
def select_move(self, game_state: GameState):
best_moves: List[Move] = []
best_score = float("-inf")
# Loop over all legal moves.
for possible_move in game_state.legal_moves():
if possible_move.point and is_point_an_eye(game_state.board, possible_move.point, game_state.next_player):
continue # skip the eye
next_state = game_state.apply_move(possible_move)
result = alphabeta(next_state, False, game_state.next_player, self.max_depth, ev_fn=self.ev_fn)
if (not best_moves) or result > best_score:
best_moves = [possible_move]
best_score = result
elif result == best_score:
best_moves.append(possible_move)
# For variety, randomly select among all equally good moves.
return random.choice(best_moves)
def main():
board_size = 7
game: GameState = GameState.new_game(board_size)
bots = {
# gotypes.Player.black: RandomBot(),
# gotypes.Player.black: AlphaBetaAgent(max_depth=0, ev_fn=eval_fn2),
# gotypes.Player.white: RandomAgent(),
# gotypes.Player.black: RandomAgent(),
# gotypes.Player.white: FastRandomAgent(),
# gotypes.Player.black: FastRandomAgent(),
# gotypes.Player.black: AlphaBetaAgent(max_depth=1, ev_fn=eval_fn),
gotypes.Player.black:
MCTSAgent(2500, temperature=1.4, parallel_rollouts=True),
gotypes.Player.white:
AlphaBetaAgent(max_depth=3, ev_fn=eval_fn2),
}
while not game.is_over():
# time.sleep(0.5)
bot_move = bots[game.next_player].select_move(game)
game = game.apply_move(bot_move)
print('\033c') # clear terminal [Linux and OS X]
print_board(game.board)
print_move(game.next_player.opposite, bot_move)
print(compute_game_result(game))
print(compute_game_result(game))
def simulate_parallel_random_games(self, game: GameState) -> List[Player]:
game_with_nomore_than_one_parent = game
parent = game.previous_state
if parent is not None:
board = copy.deepcopy(parent.board)
parent_copy = GameState(board, parent.next_player, None, parent.last_move)
game_with_nomore_than_one_parent.previous_state = parent_copy
self.socket.send_pyobj(game_with_nomore_than_one_parent)
results: List[Player] = self.socket.recv_pyobj()
return results
def __init__(self,
game_state: GameState,
parent: 'MCTSNode' = None,
move: Move = None):
self.parent = parent
self.game_state = game_state
self.move = move
self.win_counts = {Player.white: 0, Player.black: 0}
self.num_rollouts = 0
self.children: List[MCTSNode] = []
self.univisted_moves = game_state.legal_moves()
def __init__(self, game_state: GameState, parent: MCTSNode = None, last_move: Move = None):
self.game_state = game_state
self.parent = parent
self.last_move = last_move
self.win_counts: Dict[Player, int] = {
Player.black: 0,
Player.white: 0,
}
self.num_rollouts: int = 0
self.children: List[MCTSNode] = []
b: Board = game_state.board
p: Player = game_state.next_player
moves: List[Move] = game_state.legal_moves()
self.unvisited_moves: List[Move] = [m for m in moves if not (m.point and is_point_an_eye(b, m.point, p))]
def simulate_game(black_player, white_player, board_size):
moves = []
game = GameState.new_game(board_size)
agents = {
Player.black: black_player,
Player.white: white_player,
}
while not game.is_over():
next_move = agents[game.next_player].select_move(game)
moves.append(next_move)
game = game.apply_move(next_move)
game_result = scoring.compute_game_result(game)
return game_result.winner
def encode(self, game_state: GameState):
board_tensor = np.zeroes(self.shape())
board_plane = {game_state.next_player: 0,
game_state.next_player.other: 3}
for row in range(self.board_height):
for col in range(self.board_width):
point = Point(row+1, col+1)
go_string = game_state.board.get_go_string(point)
if go_string is None:
if game_state.does_move_violate_ko(game_state.next_player, Move(point)):
board_tensor[VIOLATE_KO][row][col] = 1
else:
liberty_plane = min(3, go_string.num_liberties)
liberty_plane += board_plane[go_string.color]
board_tensor[liberty_plane][row][col] = 1
return board_tensor
def main():
board_size = 7
game: GameState = GameState.new_game(board_size)
bots = {
# gotypes.Player.white: MCTSAgent(4000, temperature=1.4),
gotypes.Player.white:
MCTSAgent(5000, temperature=1.4, parallel_rollouts=True),
gotypes.Player.black:
MCTSAgent(5000, temperature=1.1, parallel_rollouts=True),
}
while not game.is_over():
bot_move = bots[game.next_player].select_move(game)
game = game.apply_move(bot_move)
print('\033c') # clear terminal [Linux and OS X]
print_board(game.board)
print_move(game.next_player.opposite, bot_move)
print(compute_game_result(game))
print(compute_game_result(game))
def main():
board_size = 9
game: GameState = GameState.new_game(board_size)
bot: Agent = RandomAgent()
move: Move = None
while not game.is_over():
print('\033c') # clear terminal [Linux and OS X]
if move is not None:
print_move(game.next_player, move)
print_board(game.board)
if game.next_player == gotypes.Player.black:
print(compute_game_result(game))
human_move_str: str = input('-- ')
try:
point = point_from_coords(human_move_str.strip().upper())
move = Move.play(point)
except (ValueError, Exception):
move = Move.pass_turn()
else:
move = bot.select_move(game)
game = game.apply_move(move)
def simulate_game(black_player, white_player, board_size):
moves = []
game = GameState.new_game(board_size)
agents = {
Player.black: black_player,
Player.white: white_player,
}
while not game.is_over():
next_move = agents[game.next_player].select_move(game)
moves.append(next_move)
# if next_move.is_pass:
# print('%s passes' % name(game.next_player))
game = game.apply_move(next_move)
print_board(game.board)
game_result = scoring.compute_game_result(game)
print(game_result)
return GameRecord(
moves=moves,
winner=game_result.winner,
margin=game_result.winning_margin,
)
def simulate_game(
board_size,
black_agent, black_collector,
white_agent, white_collector):
print('Starting the game!')
game = GameState.new_game(board_size)
agents = {
Player.black: black_agent,
Player.white: white_agent,
}
black_collector.begin_episode()
white_collector.begin_episode()
while not game.is_over():
next_move = agents[game.next_player].select_move(game)
game = game.apply_move(next_move)
game_result = scoring.compute_game_result(game)
if game_result.winner == Player.black:
black_collector.complete_episode(1)
white_collector.complete_episode(-1)
else:
black_collector.complete_episode(-1)
white_collector.complete_episode(1)
from dlgo.goboard import GameState, Move
from dlgo.gotypes import Point
from dlgo.utils import print_board
from dlgo.gosgf.sgf import Sgf_game
sgf_content = "(;GM[1]FF[4]SZ[9];B[ee];W[ef];B[ff];W[df];B[fe];W[fc];B[ec];W[gd];B[fb])"
sgf_game = Sgf_game.from_string(sgf_content)
game_state = GameState.new_game(19)
for item in sgf_game.main_sequence_iter():
color, move_tuple = item.get_move()
if color is not None and move_tuple is not None:
row, col = move_tuple
point = Point(row + 1, col + 1)
move = Move.play(point)
game_state = game_state.apply_move(move)
print_board(game_state.board)
