def test_white_is_not_taken_when_it_has_a_liberty():
goban = Goban([
'...',
'#o#',
'.#.',
])
assert goban.is_taken(1, 1) is False
def setUp(self):
self.goban = Goban()
self.goban.votes = {}
self.goban.vote_random = MagicMock()
self.a1_move = Move('a1')
self.a2_move = Move('a2')
self.random_move = Move('random')
def test_white_is_taken_when_surrounded_by_black():
goban = Goban([
'.#.',
'#o#',
'.#.',
])
assert goban.is_taken(1, 1) is True
def test_black_shape_is_taken_when_surrounded():
goban = Goban([
'oo.',
'##o',
'o#o',
'.o.',
])
assert goban.is_taken(0, 1) is True
assert goban.is_taken(1, 1) is True
assert goban.is_taken(1, 2) is True
def test_black_shape_is_not_taken_when_it_has_a_liberty():
goban = Goban([
'oo.',
'##.',
'o#o',
'.o.',
])
assert goban.is_taken(0, 1) is False
assert goban.is_taken(1, 1) is False
assert goban.is_taken(1, 2) is False
def test_square_shape_is_taken():
goban = Goban([
'oo.',
'##o',
'##o',
'oo.',
])
assert goban.is_taken(0, 1) is True
assert goban.is_taken(0, 2) is True
assert goban.is_taken(1, 1) is True
assert goban.is_taken(1, 2) is True
class PlayerInterface():
def __init__(self, color, board_size):
self.goban = Goban(board_size)
self.color = color
self._opponent = self.goban.invert_color(self.color)
def __str__(self):
return f"Player: {self.getPlayerName()}"
def getPlayerName(self):
"""
Returns your player name, as to be displayed during the game.
"""
return NotImplementedError
def getPlayerMove(self):
"""
Returns your move. The move must be a couple of two integers,
which are the coordinates of where you want to put your piece on the board.
Coordinates are the coordinates given by the Reversy.py methods (e.g. validMove(board, x, y)
must be true of you play '(x,y)') You can also answer (-1,-1) as "pass".
Note: the referee will nevercall your function if the game is over
"""
return (-1, -1)
def playOpponentMove(self, x, y):
"""Inform you that the oponent has played this move. You must play it with no search
(just update your local variables to take it into account)
"""
pass
class Game(db.Model):
size = db.IntegerProperty(required=True)
black = db.StringProperty()
white = db.StringProperty()
black_caught = db.IntegerProperty(default=0)
white_caught = db.IntegerProperty(default=0)
turn_count = db.IntegerProperty(default=1)
pass_count = db.IntegerProperty(default=0)
data = db.TextProperty()
prev_data = db.TextProperty()
created_at = db.DateTimeProperty(auto_now_add=True)
updated_at = db.DateTimeProperty(auto_now=True)
@property
def turn(self):
logging.info(self.turn_count)
return Goban.black if self.turn_count % 2 else Goban.white
@property
def turn_label(self):
return u'黒' if self.turn is Goban.black else u'白'
def touch(self, x, y):
self._ensure_goban_object()
caught = self.goban_object.touch(x, y, self.turn)
if self.is_kou():
raise Goban.Untouchable()
if self.turn is Goban.black:
self.white_caught += caught
else:
self.black_caught += caught
self.prev_data = self.data
self.data = simplejson.dumps(self.goban_object.data)
self.turn_count += 1
self.pass_count = 0
def pass_touch(self):
self.prev_data = self.data
self.turn_count += 1
self.pass_count += 1
def render(self):
self._ensure_goban_object()
buffer = StringIO()
self.goban_object.render(buffer, html=True)
return buffer.getvalue()
def _ensure_goban_object(self):
if not hasattr(self, 'goban_object'):
self.goban_object = Goban(self.size)
if self.data is not None:
self.goban_object.data = simplejson.loads(self.data)
def is_kou(self):
if self.prev_data is None: return False
prev_goban_object = Goban(self.size)
prev_goban_object.data = simplejson.loads(self.prev_data)
return self.goban_object.is_kou(prev_goban_object)
async def start(self, size):
size = int(size[1:-1])
if (size >= 2):
g = Goban(size)
self.goban = g
self.scorer = None
self.game_state = GameState.STARTED
await self.update()
else:
await self.channel.send("Please select at least a goban of size 2")
def evaluate(model1_path, model2_path, rounds, device="cpu"):
win1, win2 = 0, 0
# Turn verbosity off
sys.stdout = open(os.devnull, 'w')
for _round in range(rounds):
goban = Goban(GOBAN_SIZE)
# Random color asignment
color1 = random.choice([Goban._BLACK, Goban._WHITE])
color2 = goban.invert_color(color1)
p1 = AlphaZeroPlayer(color1, GOBAN_SIZE, model1_path)
p2 = AlphaZeroPlayer(color2, GOBAN_SIZE, model2_path)
winner = play(p1, p2, goban, verbose=False)
if winner == color1:
win1 += 1
elif winner == color2:
win2 += 1
# Turn verbosity on
sys.stdout = sys.__stdout__
return win1 / rounds
class TestVoteMove(unittest.TestCase):
def setUp(self):
self.goban = Goban()
self.goban.votes = {}
self.goban.vote_random = MagicMock()
self.a1_move = Move('a1')
self.a2_move = Move('a2')
self.random_move = Move('random')
def test_vote_succeeds(self):
self.goban.is_valid = MagicMock(return_value=True)
vote_move_result = self.goban.vote_move(self.a1_move, 'user')
self.assertEqual(self.goban.votes['user'], self.a1_move)
self.assertEqual(vote_move_result, 'Voted for `A1`.')
def test_invalid_move(self):
self.goban.is_valid = MagicMock(return_value=False)
vote_move_result = self.goban.vote_move(self.a1_move, 'user')
self.assertEqual(self.goban.votes, {})
self.assertEqual(vote_move_result, '`A1` seems to be an invalid move.')
def test_already_voted(self):
self.goban.is_valid = MagicMock(return_value=True)
self.goban.votes = {'user': self.a1_move}
vote_move_result = self.goban.vote_move(self.a1_move, 'user')
self.assertEqual(self.goban.votes['user'], self.a1_move)
self.assertEqual(vote_move_result, "You've already voted for `A1`!")
def test_change_vote(self):
self.goban.is_valid = MagicMock(return_value=True)
self.goban.votes = {'user': self.a2_move}
vote_move_result = self.goban.vote_move(self.a1_move, 'user')
self.assertEqual(self.goban.votes['user'], self.a1_move)
self.assertEqual(vote_move_result, 'Changed vote from `A2` to `A1`!')
def test_vote_random(self):
self.goban.vote_move(self.random_move, 'user')
self.goban.vote_random.assert_called_with('user', self.random_move.hidden)
def is_kou(self):
if self.prev_data is None: return False
prev_goban_object = Goban(self.size)
prev_goban_object.data = simplejson.loads(self.prev_data)
return self.goban_object.is_kou(prev_goban_object)
def _ensure_goban_object(self):
if not hasattr(self, 'goban_object'):
self.goban_object = Goban(self.size)
if self.data is not None:
self.goban_object.data = simplejson.loads(self.data)
args = parser.parse_args()
tf.get_logger().setLevel('INFO')
saves_path_best_folder = os.path.join("saves", args.name, "best")
os.makedirs(saves_path_best_folder, exist_ok=True)
saves_path_best = os.path.join(saves_path_best_folder, "model")
saves_path_current_folder = os.path.join("saves", args.name, "current")
os.makedirs(saves_path_current_folder, exist_ok=True)
saves_path_current = os.path.join(saves_path_current_folder, "model")
best_mcts = None
for round_idx in range(1, 1 + TRAIN_ROUNDS):
print("Starting round: ", round_idx)
starting_goban = Goban(GOBAN_SIZE)
current_mcts = MCTS(GOBAN_SIZE)
current_mcts.train(starting_goban,
N_EPISODES,
N_EPOCHS,
FIT_EVERY_EPISODE,
BATCH_SIZE,
learning_rate=LEARNING_RATE,
verbose=True)
if round_idx % EVALUATE_EVERY_ROUND == 0:
if best_mcts is not None:
print("End of round, evaluating mcts...")
current_mcts.model.save_weights(saves_path_current)
win_ratio = evaluate(saves_path_current, saves_path_best,
def load_goban(self) -> Goban:
try:
with open(self.STATE_FILE_NAME, 'rb') as file:
return load(file)
except FileNotFoundError:
return Goban()
def __init__(self, color, board_size):
self.goban = Goban(board_size)
self.color = color
self._opponent = self.goban.invert_color(self.color)
def test_move(self):
g = Goban(3, handicap=["aa", "ab", "ac", "ba", "bc", "cc", "cb", "bc", "ca"])
g.move("w", "bb")
print(g.history)
def test():
from goban import Goban, Stone
g = Goban(5)
g.play([0, 0], Stone.WHITE)
g.play([2, 0], Stone.BLACK)
g.play([3, 0], Stone.WHITE)
g.play([0, 1], Stone.BLACK)
g.play([1, 1], Stone.BLACK)
g.play([2, 1], Stone.BLACK)
g.play([3, 1], Stone.WHITE)
g.play([4, 1], Stone.WHITE)
g.play([0, 2], Stone.WHITE)
g.play([2, 2], Stone.BLACK)
g.play([3, 2], Stone.WHITE)
g.play([0, 3], Stone.BLACK)
g.play([1, 3], Stone.BLACK)
g.play([3, 3], Stone.WHITE)
g.play([1, 4], Stone.BLACK)
g.play([3, 4], Stone.WHITE)
g.play([4, 4], Stone.BLACK)
g.play([1, 2], Stone.BLACK)
g.play([1, 0], Stone.BLACK)
g.play([4, 3], Stone.WHITE)
scorer = Scorer(g)
scorer.kill([0, 0])
scorer.kill([4, 4])
print(scorer.count_territory())
scorer.display()
import pdb
pdb.set_trace()
goban.play((x, y, next_player.color))
other_player.playOpponentMove(x, y)
# Invert players
next_player, other_player = other_player, next_player
if verbose:
print(goban)
print("The game is over")
nbblacks, nbwhites = goban.get_score()
winner = goban.get_winner()
if verbose:
print("Time:", totalTime)
print("Winner: ", end="")
if winner == goban._WHITE:
print("WHITE")
elif winner == goban._BLACK:
print("BLACK")
else:
print("DEUCE")
print("Final is: ", nbwhites, "whites and ", nbblacks, "blacks")
return winner
if __name__ == "__main__":
goban = Goban()
model_path = "saves/test1/best/model" # not well trained
player1, player2 = AlphaZeroPlayer(
goban._WHITE, goban.get_board_size(), model_path), MCTSPlayer(goban._BLACK, goban.get_board_size())
play(player1, player2, goban)
