def test_compare_same():
game_a = get_gdl_for_game("ticTacToe")
game_b = get_gdl_for_game("ticTacToe")
idx1, sig1 = signature.get_index(game_a, verbose=False)
idx2, sig2 = signature.get_index(game_b, verbose=False)
sigs1 = sig1.sigs[:]
sigs1.sort()
sigs2 = sig1.sigs[:]
sigs2.sort()
for x, y in zip(sig1.sigs, sig2.sigs):
x, y = x.zero_sig, y.zero_sig
assert x == y
def test_with_database():
gdl_str = get_gdl_for_game("connectFour")
mapping, info = lookup.by_gdl(gdl_str)
assert mapping is None
assert info.game == "connectFour"
sm = info.get_sm()
# ensure keeps returning valid statemachines
for ii in range(10):
new_mapping, new_info = lookup.by_gdl(gdl_str)
new_sm = new_info.get_sm()
assert new_mapping is None
assert new_info is info
assert new_sm != sm
assert id(new_sm) != id(sm)
assert new_sm.get_initial_state() == sm.get_initial_state()
interface.dealloc_statemachine(new_sm)
# finally run rollouts in c++ on the original sm
log.info("Testing sm %s" % sm)
msecs_taken, rollouts, _ = interface.depth_charge(sm, 1)
rollouts_per_second = (rollouts / float(msecs_taken)) * 1000
log.info("c++ rollouts per second %.2f" % rollouts_per_second)
def test_tictactoe_take_win():
gm = GameMaster(get_gdl_for_game("ticTacToe"))
# add two c++ players
gm.add_player(get.get_player("ggtest1"), "xplayer")
gm.add_player(get.get_player("ggtest1"), "oplayer")
str_state = '''
(true (control xplayer))
(true (cell 2 2 x))
(true (cell 3 2 o))
(true (cell 3 3 x))
(true (cell 2 3 o))
(true (cell 3 1 b))
(true (cell 2 1 b))
(true (cell 1 3 b))
(true (cell 1 2 b))
(true (cell 1 1 b)) '''
gm.start(meta_time=30, move_time=2,
initial_basestate=gm.convert_to_base_state(str_state))
# play a single move - should take win
move = gm.play_single_move()
assert str(move[0]) == "(mark 1 1)"
assert str(move[1]) == "noop"
gm.play_to_end(last_move=move)
# check scores/depth make some sense
assert gm.scores['xplayer'] == 100
assert gm.scores['oplayer'] == 0
assert gm.get_game_depth() == 1
def do_game(game, gen, players, meta_time, move_time):
# ensure we have a network
gm = GameMaster(get_gdl_for_game(game), verbose=False)
info = lookup.by_name(game)
for player, role in zip(players, gm.sm.get_roles()):
gm.add_player(player, role)
roles = gm.sm.get_roles()
match_info = create_match_info(meta_time, move_time, len(roles),
game, [p.get_name() for p, r in gm.players], False)
# save match_info
update_match_info(game, match_info)
gm.start(meta_time=meta_time, move_time=move_time)
the_bs = gm.sm.new_base_state()
gm.sm.get_current_state(the_bs)
set_initial_state(match_info, basestate_to_str(info.model, the_bs))
last_move = None
while not gm.finished():
last_move = gm.play_single_move(last_move)
gm.sm.get_current_state(the_bs)
add_to_next(match_info, list(last_move), basestate_to_str(info.model, the_bs))
update_match_info(game, match_info)
gm.play_to_end(last_move)
set_goals(match_info, [gm.get_score(r) for _, r in gm.players])
update_match_info(game, match_info)
def test_tictactoe_cpp_play():
gm = GameMaster(get_gdl_for_game("ticTacToe"))
# add two c++ players
gm.add_player(get.get_player("random"), "xplayer")
gm.add_player(get.get_player("legal"), "oplayer")
gm.start(meta_time=10, move_time=5)
gm.play_to_end()
# check scores/depth make some sense
assert sum(gm.scores.values()) == 100
assert 5 <= gm.get_game_depth() <= 9
def __init__(self, game_config):
assert isinstance(game_config, GameConfig)
self.game_config = game_config
game_name = self.game_config.game_name
if game_name == "breakthrough2":
game_name = "breakthrough"
self.gm = GameMaster(get_gdl_for_game(game_name))
# add players
puct_conf = self.get_puct_config()
for role in self.gm.sm.get_roles():
self.gm.add_player(puctplayer.PUCTPlayer(conf=puct_conf), role)
def test_tictactoe_play_test_db_lookup():
game_gdl_str = get_gdl_for_game("ticTacToe", dict(mark="kram",
noop="notamove",
cell="bell",
oplayer="doobie"))
gm = GameMaster(game_gdl_str)
# add two python players
gm.add_player(get.get_player("pyrandom"), "xplayer")
gm.add_player(get.get_player("pylegal"), "oplayer")
gm.start(meta_time=10, move_time=5)
gm.play_to_end()
# check scores/depth make some sense
assert sum(gm.scores.values()) == 100
assert 5 <= gm.get_game_depth() <= 9
def play_game(config_0, config_1, game_size=11, move_time=10.0):
# add players
gm = GameMaster(get_gdl_for_game("hexLG%s" % game_size))
gm.add_player(PUCTPlayer(config_0), "black")
gm.add_player(PUCTPlayer(config_1), "white")
# play move via gamemaster:
gm.reset()
gm.start(meta_time=15, move_time=move_time)
def remove_gdl(m):
return m.replace("(place ", "").replace(")",
"").strip().replace(' ', '')
move = None
sgf_moves = []
while not gm.finished():
move = gm.play_single_move(last_move=move)
if move[0] == "noop":
ri, str_move = 1, remove_gdl(move[1])
else:
ri, str_move = 0, remove_gdl(move[0])
sgf_moves.append((ri, str_move))
if str_move == "swap":
sgf_moves[0] = (0, swapaxis(sgf_moves[0][1]))
for ri, m in sgf_moves:
print ri, m
x = hashlib.md5(hashlib.sha1("%.5f" %
time.time()).hexdigest()).hexdigest()[:6]
with open("game_%s_%s_%s.sgf" % (config_0.name, config_1.name, x),
"w") as f:
f.write("(;FF[4]EV[null]PB[%s]PW[%s]SZ[%s]GC[game#%s];" %
(config_1.name, config_0.name, game_size, x))
# piece colours are swapped for hexgui from LG
for ri, m in sgf_moves:
f.write("%s[%s];" % ("W" if ri == 0 else "B", m))
f.write(")\n")
def test_speed():
gm = GameMaster(get_gdl_for_game("reversi"))
# add two python players
a = get.get_player("simplemcts")
a.skip_single_moves = True
a.max_tree_playout_iterations = 200
b = get.get_player("simplemcts")
b.skip_single_moves = True
b.max_tree_playout_iterations = 200
gm.add_player(a, "red")
gm.add_player(b, "black")
import time
gm.start(meta_time=10, move_time=5)
s = time.time()
gm.play_to_end()
print "DONE", time.time() - s
def test_breakthrough():
gm = GameMaster(get_gdl_for_game("breakthrough"))
# add two players
pymcs = get.get_player("pymcs")
pymcs.max_run_time = 0.25
gurgeh = GurgehPlayer("Gurgeh")
gurgeh.max_tree_search_time = 1
gurgeh.max_tree_search_time = 1
gurgeh.thread_workers = 2
gm.add_player(pymcs, "white")
gm.add_player(gurgeh, "black")
gm.start(meta_time=30, move_time=15)
gm.play_to_end()
print "white_score", pymcs.name, gm.get_score("white")
print "black_score", gurgeh.name, gm.get_score("black")
def play_game(generation_name, num_previous_states):
game = "breakthrough"
# ensure we have a network
man = get_manager()
generation_descr = templates.default_generation_desc(game,
multiple_policy_heads=True,
num_previous_states=num_previous_states)
nn = man.create_new_network(game, "tiny", generation_descr)
man.save_network(nn, generation_name)
nn.summary()
conf = templates.puct_config_template(generation_name, "compete")
gm = GameMaster(get_gdl_for_game(game))
gm.add_player(CppPUCTPlayer(conf=conf), "white")
gm.add_player(get.get_player("random"), "black")
gm.start(meta_time=30, move_time=15)
gm.play_to_end()
def test_fast_plays():
''' very fast rollouts, basically this config of puct player is a policy player '''
gm = GameMaster(get_gdl_for_game("breakthrough"))
import attr
conf = confs.PUCTPlayerConfig(**attr.asdict(default_puct_config))
conf.verbose = False
# just checking that we haven't modified default
assert not conf.verbose and default_puct_config.verbose
conf.playouts_per_iteration = 1
conf.playouts_per_iteration_noop = 0
conf.dirichlet_noise_alpha = -1
print conf
# add two players
white = PUCTPlayer(conf=conf)
black = PUCTPlayer(conf=conf)
gm.add_player(white, "white")
gm.add_player(black, "black")
acc_black_score = 0
acc_red_score = 0
s = time.time()
for _ in range(ITERATIONS):
gm.start(meta_time=30, move_time=15)
gm.play_to_end()
acc_black_score += gm.scores["black"]
acc_red_score += gm.scores["white"]
print gm.get_game_depth()
print "time taken", time.time() - s
print "white_score", gm.players_map["white"].name, acc_red_score
print "black_score", gm.players_map["black"].name, acc_black_score
def test_puct_tournament():
gm = GameMaster(get_gdl_for_game("breakthrough"))
# add two players
pymcs = get.get_player("pymcs")
pymcs.max_run_time = 0.1
black = PUCTPlayer(conf=default_puct_config)
gm.add_player(pymcs, "white")
gm.add_player(black, "black")
acc_black_score = 0
acc_red_score = 0
for _ in range(ITERATIONS):
gm.start(meta_time=30, move_time=15)
gm.play_to_end()
acc_black_score += gm.scores["black"]
acc_red_score += gm.scores["white"]
print "white_score", gm.players_map["white"].name, acc_red_score
print "black_score", gm.players_map["black"].name, acc_black_score
def test_not_taking_win():
gm = GameMaster(get_gdl_for_game("breakthrough"))
# add two players
gm.add_player(PUCTPlayer(default_puct_config), "white")
gm.add_player(PUCTPlayer(default_puct_config), "black")
str_state = """ (true (control black))
(true (cellHolds 8 8 black)) (true (cellHolds 8 7 black)) (true (cellHolds 8 2 white))
(true (cellHolds 8 1 white)) (true (cellHolds 7 8 black)) (true (cellHolds 6 7 white))
(true (cellHolds 6 2 white)) (true (cellHolds 6 1 white)) (true (cellHolds 5 4 black))
(true (cellHolds 5 3 black)) (true (cellHolds 5 2 white)) (true (cellHolds 5 1 white))
(true (cellHolds 4 8 black)) (true (cellHolds 4 7 black)) (true (cellHolds 4 1 white))
(true (cellHolds 3 8 black)) (true (cellHolds 3 6 black)) (true (cellHolds 3 2 white))
(true (cellHolds 2 8 black)) (true (cellHolds 2 7 black)) (true (cellHolds 2 2 white))
(true (cellHolds 2 1 white)) (true (cellHolds 1 8 black)) (true (cellHolds 1 7 black))
(true (cellHolds 1 2 white)) (true (cellHolds 1 1 white)) """
gm.start(meta_time=30, move_time=5,
initial_basestate=gm.convert_to_base_state(str_state))
last_move = gm.play_single_move(last_move=None)
assert last_move[1] == "(move 7 8 6 7)"
def test_dupes_deallocs():
def go(gdl_str):
_, sm = builder.build_sm(gdl_str)
sm.reset()
sm2 = sm.dupe()
interface.dealloc_statemachine(sm)
sm2.reset()
log.info("Doing depth charges on %s" % sm2)
msecs_taken, rollouts, _ = interface.depth_charge(sm2, 2)
rollouts_per_second = (rollouts / float(msecs_taken)) * 1000
log.info("rollouts per second %.2f" % rollouts_per_second)
# test from python
depth_charges(sm2, 1)
interface.dealloc_statemachine(sm2)
for game in ("ticTacToe", "connectFour", "breakthrough"):
gdl_str = helper.get_gdl_for_game(game)
go(gdl_str)
def test_breakthrough():
' mcs player vs ggtest1 '
gm = GameMaster(get_gdl_for_game("breakthrough"))
# add two players
white = get.get_player("pymcs")
white.max_run_time = 0.25
black = get.get_player("simplemcts")
black.skip_single_moves = True
gm.add_player(white, "white")
gm.add_player(black, "black")
gm.start(meta_time=30, move_time=2.0)
gm.play_to_end()
# hopefully simplemcts wins! Not a great test.
assert gm.scores["white"] == 0
assert gm.scores["black"] == 100
# check scores/depth make some sense
assert sum(gm.scores.values()) == 100
assert gm.get_game_depth() >= 10
def play(moves, move_time):
# add players
gm = GameMaster(get_gdl_for_game("breakthroughSmall"))
for role in gm.sm.get_roles():
gm.add_player(PUCTPlayer(conf=compete), role)
sm = lookup.by_name("breakthroughSmall").get_sm()
sm.reset()
pretty_board(sm)
# get some states
joint_move = sm.get_joint_move()
base_state = sm.get_initial_state()
def to_cords(s):
mapping_x_cord = {x0: x1 for x0, x1 in zip('abcdef', '654321')}
return mapping_x_cord[s[0]], s[1]
def f(ri, i):
return sm.legal_to_move(ri, ls.get_legal(i))
lead_role_index = 0
gdl_moves = []
for m in moves:
from_, to_ = map(to_cords, m.split("-"))
gdl_move = []
for ri in range(2):
if ri == lead_role_index:
gdl_role_move = "(move %s %s %s %s)" % (from_[0], from_[1],
to_[0], to_[1])
else:
gdl_role_move = "noop"
ls = sm.get_legal_state(ri)
the_moves = [f(ri, ii) for ii in range(ls.get_count())]
choice = the_moves.index(gdl_role_move)
joint_move.set(ri, ls.get_legal(choice))
gdl_move.append(str(gdl_role_move))
# update state machine
sm.next_state(joint_move, base_state)
sm.update_bases(base_state)
lead_role_index ^= 1
gdl_moves.append(str(gdl_move))
print "%s -> %s" % (m, gdl_move)
pretty_board(sm)
# play move via gamemaster:
gm.reset()
gm.start(meta_time=15,
move_time=move_time,
initial_basestate=sm.get_current_state(),
game_depth=len(moves))
move = gm.play_single_move(last_move=None)
player = gm.get_player(lead_role_index)
move = move[lead_role_index]
move = move.replace("(move", "").replace(")", "")
a, b, c, d = move.split()
mapping_x_cord = {x0: x1 for x0, x1 in zip('654321', 'abcdef')}
next_move = "%s%s-%s%s" % (mapping_x_cord[a], b, mapping_x_cord[c], d)
sm.update_bases(gm.sm.get_current_state())
pretty_board(sm)
print "PLAYED", next_move, player.last_probability
return next_move, player.last_probability
def test_create_and_play_with_goalless_sm():
' plays a simple game of tictactoe, ensuring correct states throughtout'
gdl_str = helper.get_gdl_for_game("ticTacToe")
_, sm = builder.build_sm(gdl_str, try_combined=False)
create_and_play(sm)
