def __init__(self,
go_bot,
termination=None,
handicap=0,
opponent='gnugo',
output_sgf="out.sgf",
our_color='b'):
self.bot = TerminationAgent(go_bot, termination)
self.handicap = handicap
self._stopped = False
self.game_state = GameState.new_game(19)
self.sgf = SGFWriter(output_sgf)
self.our_color = Player.black if our_color == 'b' else Player.white
self.their_color = self.our_color.other
cmd = self.opponent_cmd(opponent)
pipe = subprocess.PIPE
self.gtp_stream = subprocess.Popen(cmd, stdin=pipe, stdout=pipe)
def main():
board_size = 4
game = GameState.new_game(board_size)
bot = MinimaxBot(5, capture_diff)
while not game.is_over():
print(chr(27) + "[2J")
print_board(game.board)
if game.next_player == Player.black:
valid = False
while not valid:
human_move = input('-- ')
human_move = human_move.upper()
point = point_from_coords(human_move.strip())
move = Move.play(point)
valid = game.is_valid_move(move)
else:
move = bot.select_move(game)
print_move(game.next_player, move)
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)
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 __init__(self, termination_agent, termination=None):
self.agent = termination_agent
self.game_state = GameState.new_game(19)
self._input = sys.stdin
self._output = sys.stdout
self._stopped = False
self.handlers = {
'boardsize': self.handle_boardsize,
'clear_board': self.handle_clear_board,
'fixed_handicap': self.handle_fixed_handicap,
'genmove': self.handle_genmove,
'known_command': self.handle_known_command,
'komi': self.ignore,
'showboard': self.handle_showboard,
'time_settings': self.ignore,
'time_left': self.ignore,
'play': self.handle_play,
'protocol_version': self.handle_protocol_version,
'quit': self.handle_quit,
}
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)
def get_handicap(sgf): # Get handicap stones
go_board = Board(19, 19)
first_move_done = False
move = None
game_state = GameState.new_game(19)
board_ext = Board_Ext(game_state.board)
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)) # black gets handicap
#My inserting Nail
point = Point(row + 1, col + 1)
ret = board_ext.place_stone_ext(
go_board, 'b', point) # Handicap for black Player
#### Nail
first_move_done = True
game_state = GameState(go_board, Player.white, None, move)
return game_state, first_move_done, board_ext
def main():
board_size = 5
pygame.init()
pygame.display.set_caption('Goban')
game = GameState.new_game(board_size)
bots = {
gotypes.Player.black: RandomBot(),
gotypes.Player.white: AlphaBetaAgent(2, capture_diff),
}
while not game.is_over():
#time.sleep(0.3)
print(chr(27) + "[2J")
print_board(game.board)
GuiBoard.draw(game.board)
bot_move = bots[game.next_player].select_move(game)
print_move(game.next_player, bot_move)
game = game.apply_move(game.next_player, bot_move)
print("winner is:", game.winner())
print("score is is:", compute_game_result(game))
input("Press Enter to continue...")
def handle_clear_board(self):
self.game_state = GameState.new_game(19)
return response.success()
from dlgo.gosgf import Sgf_game
from dlgo.goboard_fast import GameState, Move
from dlgo.gotypes import Point
from dlgo.utils import print_board
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)
def generate_game(board_size, game_id_str, rounds_per_move=10, c=2.0):
start = time.time()
print(f'Generating {game_id_str}...')
game = GameState.new_game(board_size)
encoder = zero.ZeroEncoder(board_size)
# load current best agent, if any
# has to be able to pass through cPickle which is why we don't just reuse it
if os.path.exists('agz_bot.h5'):
with h5py.File('agz_bot.h5') as bot_file:
black_agent = zero.load_zero_agent(bot_file)
white_agent = zero.load_zero_agent(bot_file)
else:
print(f'WARN: using default model to generate {game_id_str}')
model = zero_model(board_size)
black_agent = zero.ZeroAgent(model, encoder, rounds_per_move=rounds_per_move, c=c)
white_agent = zero.ZeroAgent(model, encoder, rounds_per_move=rounds_per_move, c=c)
agents = {
Player.black: black_agent,
Player.white: white_agent,
}
c1 = zero.ZeroExperienceCollector()
c2 = zero.ZeroExperienceCollector()
black_agent.set_collector(c1)
white_agent.set_collector(c2)
c1.begin_episode()
c2.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:
c1.complete_episode(1)
c2.complete_episode(-1)
else:
c1.complete_episode(-1)
c2.complete_episode(1)
combined = zero.combine_experience([c1, c2], board_size)
c1 = c2 = game_result = None
model = encoder = None
game = None
del black_agent.model
del white_agent.model
black_agent = white_agent = None
import gc
K.clear_session()
gc.collect()
return combined, game_id_str, time.time() - start
