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 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 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 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 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)