class GoRulesTest(unittest.TestCase):
def setUp(self):
self.board = Board(9)
self.go_rules = GoRules()
def test_generate_valid_moves(self):
max_number_of_moves = self.board.size * self.board.size
self.assertEqual(len(self.go_rules.generate_valid_moves(self.board, WHITE_COLOR)), max_number_of_moves)
self.board.make_move(Move(BLACK_COLOR, Vertex(1, 0)))
self.assertEqual(len(self.go_rules.generate_valid_moves(self.board, WHITE_COLOR)), max_number_of_moves - 1)
self.board.make_move(Move(BLACK_COLOR, Vertex(0, 1)))
self.assertEqual(len(self.go_rules.generate_valid_moves(self.board, WHITE_COLOR)), max_number_of_moves - 2)
def gtp_boardsize(self, cmd_id, args):
if not args or not args[0].isdigit():
return self.failure_response(cmd_id, self.MSG_SINTAX_ERROR)
size = int(args[0])
if size < 2 or size > 25:
return self.failure_response(cmd_id, self.MSG_WRONG_SIZE)
self.board = Board(size)
return self.success_response(cmd_id)
class OpeningKnowledgeTest(unittest.TestCase):
def setUp(self):
self.board = Board(6)
def testFirstMove(self):
openingKnowledge = OpeningKnowledge(WHITE_COLOR)
move = openingKnowledge.get_opening_move(self.board)
self.assertTrue(move)
self.assertEqual(move, Move(WHITE_COLOR, Vertex.from_string("c3")))
def testSecondMove(self):
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("c3")))
openingKnowledge = OpeningKnowledge(WHITE_COLOR)
move = openingKnowledge.get_opening_move(self.board)
self.assertTrue(move)
class GroupTest(unittest.TestCase):
"""
Tests the groups functionality
"""
def setUp(self):
self.board = Board(9)
def test_update_liberties(self):
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("b2")))
group = self.board.get_group(Vertex.from_string("b2"))
self.assertEqual(len(group.liberties), 4)
self.assertTrue(Vertex.from_string("b1") in group.liberties)
self.assertTrue(Vertex.from_string("b3") in group.liberties)
self.assertTrue(Vertex.from_string("a2") in group.liberties)
self.assertTrue(Vertex.from_string("c2") in group.liberties)
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("b1")))
self.assertEqual(len(group.liberties), 5)
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("d1")))
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("c1")))
group = self.board.get_group(Vertex.from_string("b2"))
self.assertEqual(len(group.liberties), 6)
def test_is_captured_corner(self):
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("a1")))
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("b1")))
group = self.board.get_group(Vertex.from_string("a1"))
self.assertEqual(len(group.liberties), 1)
capture_move = Move(BLACK_COLOR, Vertex.from_string("a2"))
#self.assertTrue(group.gets_captured(capture_move))
self.board.make_move(capture_move)
self.assertTrue(group.is_captured())
def test_is_captured_middle(self):
white_stone = Vertex.from_string("c3")
self.board.make_move(Move(WHITE_COLOR, white_stone))
# Capture C3
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("c4")))
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("c2")))
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("b3")))
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("d3")))
# print self.board
self.assertTrue(self.board.get_group(white_stone).is_captured())
self.assertEqual(self.board.winner, BLACK_COLOR)
def test_is_captured_group_simple(self):
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("c4")))
black_group = self.board.get_group(Vertex.from_string("c4"))
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("b4")))
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("d4")))
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("d3")))
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("c3")))
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("c5")))
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("d5")))
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("e5")))
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("e4")))
self.assertTrue(black_group.is_captured())
def setUp(self):
self.board = Board(9)
class GoEvaluatorTest(unittest.TestCase):
def setUp(self):
self.board = Board(9)
self.evaluator = AdvacedGoEvaluator()
def test_game_over_evaluation(self):
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("a2")))
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("b2")))
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("a3")))
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("b3")))
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("c2")))
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("c1")))
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("a1")))
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("b1")))
self.assertEqual(self.evaluator.evaluate(self.board), self.evaluator.MAX_EVALUATION)
def test_liberties_evaluation(self):
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("a1")))
self.assertTrue(self.evaluator.calculate_liberties_value(self.board) > 0)
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("e6")))
self.assertTrue(self.evaluator.calculate_liberties_value(self.board) < 0)
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("e5")))
self.assertTrue(self.evaluator.calculate_liberties_value(self.board) > 0)
def test_atari_value(self):
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("a1")))
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("a2")))
self.assertEqual(self.evaluator.calculate_atari_value(self.board), -self.evaluator.ATARI_VALUE)
def test_calculate_connectivity(self):
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("a1")))
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("d5")))
self.assertEqual(self.evaluator.calculate_connectivity(self.board), self.evaluator.GROUP_VALUE * 2)
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("f5")))
self.assertEqual(self.evaluator.calculate_connectivity(self.board), self.evaluator.GROUP_VALUE)
def test_calculate_territory(self):
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("e5")))
self.assertTrue(self.evaluator.calculate_territory(self.board) > 0)
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("e4")))
self.assertEqual(self.evaluator.calculate_territory(self.board), 0)
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("c3")))
self.assertTrue(self.evaluator.calculate_territory(self.board) > 0)
def setUp(self):
self.board = Board(9)
self.evaluator = AdvacedGoEvaluator()
def setUp(self):
self.board = Board(9)
self.go_rules = GoRules()
self._ask_move()
def _ask_move(self):
player = (self.black_player if self.next_move == BLACK_COLOR
else self.white_player)
move = None
while not move:
move = player.make_move(self.board.copy())
try:
self.board.make_move(move)
except InvalidMoveError:
move = None
player.notify_invalid_move()
self.next_move = (WHITE_COLOR if self.next_move == BLACK_COLOR
else BLACK_COLOR)
def finish(self):
""" Tells the game to stop asking for moves. """
self._finish = True
if __name__ == "__main__":
game = Game(AlphaBetaPlayer("white", "dx9", DepthManager(9) , AdvacedGoEvaluator(False)),
AlphaBetaPlayer("black", "chacholano", DepthManager(9), AdvacedGoEvaluator(False)), Board(9), 0)
game.play()
class GTPEngine():
DEFAULT_BOARD_SIZE = 9
MSG_UNKNOWN_COMMAND = 'unknown command'
MSG_SINTAX_ERROR = 'sintax error'
MSG_WRONG_SIZE = 'unacceptable size'
MSG_ILLEGAL_MOVE = 'illegal move'
MSG_CANNOT_UNDO = 'cannot undo'
MSG_INVALID_COLOR = 'invalid color'
def __init__(self, player):
self.player = player
self.board = Board(self.DEFAULT_BOARD_SIZE)
self.received_quit = False
def process_command(self, command):
"""
Takes a GTP command string, processes it, and returns the GTP response.
The command is assumed to be preprocessed.
"""
cmd_id, command_name, args = self.split_command(command)
if not hasattr(self, 'gtp_' + command_name):
return self.failure_response(cmd_id, self.MSG_UNKNOWN_COMMAND)
return getattr(self, 'gtp_' + command_name)(cmd_id, args)
def split_command(self, command):
"""
Splits a command string in its id (if present), the command name,
and a list of arguments.
"""
cmd_id, command_name, args = '', '', []
word_list = command.split()
if word_list:
if len(word_list) > 1 and word_list[0].isdigit():
cmd_id = word_list.pop(0)
command_name = word_list.pop(0)
args = word_list
return cmd_id, command_name, args
def failure_response(self, cmd_id, error_message):
""" Return a GTP formatted failure response. """
return "?%s %s\n\n" % (cmd_id, error_message)
def success_response(self, cmd_id, response=''):
""" Return a GTP formatted success response. """
if response != '':
return "=%s %s\n\n" % (cmd_id, response)
return "=%s\n\n" % cmd_id
#PROTOCOL COMMANDS
def gtp_protocol_version(self, cmd_id, args):
return self.success_response(cmd_id, '2')
def gtp_name(self, cmd_id, args):
return self.success_response(cmd_id, 'pygo1963')
def gtp_known_command(self, cmd_id, args):
cmd_name = args[0] if args else ''
known = 'false'
if hasattr(self, 'gtp_' + cmd_name):
known = 'true'
return self.success_response(cmd_id, known)
def gtp_list_commands(self, cmd_id, args):
cmd_list = [cmd.replace('gtp_', '') for cmd in dir(self)
if cmd.startswith('gtp_')]
cmd_list = '\n'.join(cmd_list)
return self.success_response(cmd_id, cmd_list)
def gtp_quit(self, cmd_id, args):
self.received_quit = True
return self.success_response(cmd_id)
def gtp_boardsize(self, cmd_id, args):
if not args or not args[0].isdigit():
return self.failure_response(cmd_id, self.MSG_SINTAX_ERROR)
size = int(args[0])
if size < 2 or size > 25:
return self.failure_response(cmd_id, self.MSG_WRONG_SIZE)
self.board = Board(size)
return self.success_response(cmd_id)
def gtp_clear_board(self, cmd_id, args):
self.board = Board(self.board.size)
return self.success_response(cmd_id)
def gtp_play(self, cmd_id, args):
if len(args) < 2:
return self.failure_response(cmd_id, self.MSG_SINTAX_ERROR)
try:
vertex = Vertex.from_string(args[1])
move = Move(args[0], vertex)
except:
return self.failure_response(cmd_id, self.MSG_SINTAX_ERROR)
try:
self.board.make_move(move)
except:
return self.failure_response(cmd_id, self.MSG_ILLEGAL_MOVE)
return self.success_response(cmd_id)
def gtp_genmove(self, cmd_id, args):
#The color is ignored
move = None
while not move:
move = self.player.make_move(self.board.copy())
try:
self.board.make_move(move)
except:
self.player.notify_invalid_move()
move = None
return self.success_response(cmd_id, move.vertex)
def gtp_undo(self, cmd_id, args):
try:
self.board.undo_move()
except:
return self.failure_response(cmd_id, self.MSG_CANNOT_UNDO)
return self.success_response(cmd_id)
def gtp_showboard(self, cmd_id, args):
return self.success_response(cmd_id, self.board)
#PRIVATE EXTENSIONS
#supported by gnugo
def gtp_captures(self, cmd_id, args):
"""
Returns the amount of captures of the specified color. An Atari Go
board is assumed, so the color will have at most one capture, and in
that case it would win the game.
"""
color = args[0].lower() if args else ''
if color == 'w' or color == 'white':
color = Constants.WHITE_COLOR
elif color == 'b' or color == 'black':
color = Constants.BLACK_COLOR
else:
return self.failure_response(cmd_id, self.MSG_INVALID_COLOR)
captures = 0
if self.board.winner == color:
captures = 1
return self.success_response(cmd_id, captures)
def __init__(self, player):
self.player = player
self.board = Board(self.DEFAULT_BOARD_SIZE)
self.received_quit = False
def gtp_clear_board(self, cmd_id, args):
self.board = Board(self.board.size)
return self.success_response(cmd_id)
class BoardTest(unittest.TestCase):
def setUp(self):
self.board = Board(9)
def test_make_move(self):
self.assertEqual(self.board.content[1][1], EMPTY, 'position should be empty')
self.board.make_move(Move(WHITE_COLOR, Vertex(1, 1)))
self.assertEqual(self.board.content[1][1], WHITE_COLOR)
self.board.make_move(Move(WHITE_COLOR, Vertex(1, 0)))
self.assertEqual(self.board.content[1][0], WHITE_COLOR)
self.assertRaises(InvalidMoveError, self.board.make_move, Move(WHITE_COLOR, Vertex(1, 0)))
def test_undo_move(self):
self.board.make_move(Move(BLACK_COLOR, Vertex(5, 5)))
self.assertEqual(self.board.content[5][5], BLACK_COLOR)
self.board.undo_move()
self.assertEqual(self.board.content[5][5], EMPTY)
def test_add_to_group(self):
self.board.make_move(Move(WHITE_COLOR, Vertex(2, 2)))
self.assertEqual(len(self.board.groups), 1)
self.assertEqual(len(self.board.groups[0].stones), 1)
self.board.make_move(Move(BLACK_COLOR, Vertex(2, 3)))
self.assertEqual(len(self.board.groups), 2)
self.board.make_move(Move(WHITE_COLOR, Vertex(2, 1)))
self.assertEqual(len(self.board.groups), 2)
self.board.make_move(Move(WHITE_COLOR, Vertex(1, 0)))
self.assertEqual(len(self.board.groups), 3)
#Fusion test
self.board.make_move(Move(WHITE_COLOR, Vertex(1, 1)))
self.assertEqual(len(self.board.groups), 2)
self.board.make_move(Move(WHITE_COLOR, Vertex(1, 2)))
self.assertEqual(len(self.board.groups), 2)
def test_set_winner_if_possible_simple(self):
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("a1")))
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("a2")))
self.assertFalse(self.board.game_finished)
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("b1")))
self.assertTrue(self.board.game_finished)
self.assertEqual(self.board.winner, BLACK_COLOR)
def test_set_winner_if_possible_suicide_capture(self):
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("a2")))
self.board.make_move(Move(BLACK_COLOR, Vertex.from_string("b1")))
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("a3")))
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("b2")))
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("c1")))
self.assertFalse(self.board.game_finished)
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("a1")))
self.assertTrue(self.board.game_finished)
self.assertEqual(self.board.winner, WHITE_COLOR)
def test_set_winner_if_possible_double_pass(self):
self.board.make_move(Move(WHITE_COLOR, Vertex.PASS()))
self.assertFalse(self.board.game_finished)
self.board.make_move(Move(BLACK_COLOR, Vertex.PASS()))
self.assertFalse(self.board.game_finished)
self.board.make_move(Move(WHITE_COLOR, Vertex.from_string("a1")))
self.board.make_move(Move(WHITE_COLOR, Vertex.PASS()))
self.assertFalse(self.board.game_finished)
self.board.make_move(Move(WHITE_COLOR, Vertex.PASS()))
self.assertTrue(self.board.game_finished)
self.assertEqual(self.board.winner, BLACK_COLOR)
