def handle_boardsize(args):
# No need to pass this down to mogo.
try:
if args[0] != size:
raise gtp_engine.GtpError("board size %s only please" % size)
except IndexError:
gtp_engine.report_bad_arguments()
def handle_savesgf(self, args):
try:
pathname = args[0]
except IndexError:
gtp_engine.report_bad_arguments()
sgf_game = sgf.Sgf_game(self.board_size)
root = sgf_game.get_root()
root.set('KM', self.komi)
root.set('AP', ("gomill", __version__))
sgf_game.set_date()
if self.handicap is not None:
root.set('HA', self.handicap)
for arg in args[1:]:
try:
identifier, value = arg.split("=", 1)
if not identifier.isalpha():
raise ValueError
identifier = identifier.upper()
value = value.replace("\\_", " ").replace("\\\\", "\\")
except Exception:
gtp_engine.report_bad_arguments()
root.set_raw(identifier, sgf_grammar.escape_text(value))
sgf_moves.set_initial_position(sgf_game, self.history_base)
for history_move in self.move_history:
node = sgf_game.extend_main_sequence()
node.set_move(history_move.colour, history_move.move)
if history_move.comments is not None:
node.set("C", history_move.comments)
sgf_moves.indicate_first_player(sgf_game)
try:
self._save_file(pathname, sgf_game.serialise())
except EnvironmentError, e:
raise GtpError("error writing file: %s" % e)
def handle_place_free_handicap(self, args):
try:
number_of_stones = gtp_engine.interpret_int(args[0])
except IndexError:
gtp_engine.report_bad_arguments()
max_points = handicap_layout.max_free_handicap_for_board_size(
self.board_size)
if not 2 <= number_of_stones <= max_points:
raise GtpError("invalid number of stones")
if not self.board.is_empty():
raise GtpError("board not empty")
if number_of_stones == max_points:
number_of_stones = max_points - 1
moves = self._choose_free_handicap_moves(number_of_stones)
try:
try:
if len(moves) > number_of_stones:
raise ValueError
for row, col in moves:
self.board.play(row, col, 'b')
except (ValueError, TypeError):
raise GtpError("invalid result from move generator: %s"
% format_vertex_list(moves))
except Exception:
self.reset()
raise
self.simple_ko_point = None
self.handicap = number_of_stones
self.set_history_base(self.board.copy())
return " ".join(format_vertex((row, col))
for (row, col) in moves)
def handle_time_settings(self, args):
try:
main_time = gtp_engine.interpret_int(args[0])
canadian_time = gtp_engine.interpret_int(args[1])
canadian_stones = gtp_engine.interpret_int(args[2])
except IndexError:
gtp_engine.report_bad_arguments()
self.time_settings = (main_time, canadian_time, canadian_stones)
def handle_boardsize(self, args):
try:
size = gtp_engine.interpret_int(args[0])
except IndexError:
gtp_engine.report_bad_arguments()
if size not in self.acceptable_sizes:
raise GtpError("unacceptable size")
self.board_size = size
self.reset()
def handle_time_left(self, args):
# colour time stones
try:
colour = gtp_engine.interpret_colour(args[0])
time_remaining = gtp_engine.interpret_int(args[1])
stones_remaining = gtp_engine.interpret_int(args[2])
except IndexError:
gtp_engine.report_bad_arguments()
if stones_remaining == 0:
stones_remaining = None
self.time_status[colour] = (time_remaining, stones_remaining)
def handle_fixed_handicap(self, args):
try:
number_of_stones = gtp_engine.interpret_int(args[0])
except IndexError:
gtp_engine.report_bad_arguments()
if not self.board.is_empty():
raise GtpError("board not empty")
try:
points = handicap_layout.handicap_points(number_of_stones,
self.board_size)
except ValueError:
raise GtpError("invalid number of stones")
for row, col in points:
self.board.play(row, col, 'b')
self.simple_ko_point = None
self.handicap = number_of_stones
self.set_history_base(self.board.copy())
return " ".join(format_vertex((row, col)) for (row, col) in points)
def handle_play(self, args):
try:
colour_s, vertex_s = args[:2]
except ValueError:
gtp_engine.report_bad_arguments()
colour = gtp_engine.interpret_colour(colour_s)
move = gtp_engine.interpret_vertex(vertex_s, self.board_size)
if move is None:
self.simple_ko_point = None
self.move_history.append(History_move(colour, None))
return
row, col = move
try:
self.simple_ko_point = self.board.play(row, col, colour)
self.simple_ko_player = opponent_of(colour)
except ValueError:
raise GtpError("illegal move")
self.move_history.append(History_move(colour, move))
def _handle_genmove(self, args, for_regression=False, allow_claim=False):
"""Common implementation for genmove commands."""
try:
colour = gtp_engine.interpret_colour(args[0])
except IndexError:
gtp_engine.report_bad_arguments()
game_state = Game_state()
game_state.size = self.board_size
game_state.board = self.board
game_state.history_base = self.history_base
game_state.move_history = self.move_history
game_state.komi = self.komi
game_state.for_regression = for_regression
if self.simple_ko_point is not None and self.simple_ko_player == colour:
game_state.ko_point = self.simple_ko_point
else:
game_state.ko_point = None
game_state.handicap = self.handicap
game_state.time_settings = self.time_settings
game_state.time_remaining, game_state.canadian_stones_remaining = \
self.time_status[colour]
generated = self.move_generator(game_state, colour)
if allow_claim and generated.claim:
return 'claim'
if generated.resign:
return 'resign'
if generated.pass_move:
if not for_regression:
self.move_history.append(
History_move(colour, None, generated.comments,
generated.cookie))
return 'pass'
row, col = generated.move
vertex = format_vertex((row, col))
if not for_regression:
try:
self.simple_ko_point = self.board.play(row, col, colour)
self.simple_ko_player = opponent_of(colour)
except ValueError:
raise GtpError("engine error: tried to play %s" % vertex)
self.move_history.append(
History_move(colour, generated.move, generated.comments,
generated.cookie))
return vertex
def _handle_genmove(self, args, for_regression=False, allow_claim=False):
"""Common implementation for genmove commands."""
try:
colour = gtp_engine.interpret_colour(args[0])
except IndexError:
gtp_engine.report_bad_arguments()
game_state = Game_state()
game_state.size = self.board_size
game_state.board = self.board
game_state.history_base = self.history_base
game_state.move_history = self.move_history
game_state.komi = self.komi
game_state.for_regression = for_regression
if self.simple_ko_point is not None and self.simple_ko_player == colour:
game_state.ko_point = self.simple_ko_point
else:
game_state.ko_point = None
game_state.handicap = self.handicap
game_state.time_settings = self.time_settings
game_state.time_remaining, game_state.canadian_stones_remaining = \
self.time_status[colour]
generated = self.move_generator(game_state, colour)
if allow_claim and generated.claim:
return 'claim'
if generated.resign:
return 'resign'
if generated.pass_move:
if not for_regression:
self.move_history.append(History_move(
colour, None, generated.comments, generated.cookie))
return 'pass'
row, col = generated.move
vertex = format_vertex((row, col))
if not for_regression:
try:
self.simple_ko_point = self.board.play(row, col, colour)
self.simple_ko_player = opponent_of(colour)
except ValueError:
raise GtpError("engine error: tried to play %s" % vertex)
self.move_history.append(
History_move(colour, generated.move,
generated.comments, generated.cookie))
return vertex
def handle_fixed_handicap(self, args):
try:
number_of_stones = gtp_engine.interpret_int(args[0])
except IndexError:
gtp_engine.report_bad_arguments()
if not self.board.is_empty():
raise GtpError("board not empty")
try:
points = handicap_layout.handicap_points(
number_of_stones, self.board_size)
except ValueError:
raise GtpError("invalid number of stones")
for row, col in points:
self.board.play(row, col, 'b')
self.simple_ko_point = None
self.handicap = number_of_stones
self.set_history_base(self.board.copy())
return " ".join(format_vertex((row, col))
for (row, col) in points)
def handle_loadsgf(self, args):
try:
pathname = args[0]
except IndexError:
gtp_engine.report_bad_arguments()
if len(args) > 1:
move_number = gtp_engine.interpret_int(args[1])
else:
move_number = None
# The GTP spec mandates the "cannot load file" error message, so we
# can't be more helpful.
try:
s = self._load_file(pathname)
except EnvironmentError:
raise GtpError("cannot load file")
try:
sgf_game = sgf.Sgf_game.from_string(s)
except ValueError:
raise GtpError("cannot load file")
new_size = sgf_game.get_size()
if new_size not in self.acceptable_sizes:
raise GtpError("unacceptable size")
self.board_size = new_size
try:
komi = sgf_game.get_komi()
except ValueError:
raise GtpError("bad komi")
try:
handicap = sgf_game.get_handicap()
except ValueError:
# Handicap isn't important, so soldier on
handicap = None
try:
sgf_board, plays = sgf_moves.get_setup_and_moves(sgf_game)
except ValueError, e:
raise GtpError(str(e))
def handle_genmove(self, args):
try:
self.my_colour = gtp_engine.interpret_colour(args[0])
except IndexError:
gtp_engine.report_bad_arguments()
return self.proxy.pass_command("genmove", args)
def handle_passthrough(self, args):
try:
command = args[0]
except IndexError:
gtp_engine.report_bad_arguments()
return self.handle_command(command, args[1:])
def handle_passthrough(self, args):
try:
command = args[0]
except IndexError:
gtp_engine.report_bad_arguments()
return self.handle_command(command, args[1:])
def handle_genmove(self, args):
try:
self.my_colour = gtp_engine.interpret_colour(args[0])
except IndexError:
gtp_engine.report_bad_arguments()
return self.proxy.pass_command("genmove", args)
def handle_komi(self, args):
try:
f = gtp_engine.interpret_float(args[0])
except IndexError:
gtp_engine.report_bad_arguments()
self.set_komi(f)
