def test_not_in_db():
some_simple_game = """
(role white)
(role black)
(init o1)
(legal white a)
(legal white b)
(legal black a)
(<= (next o2) (does white a) (true o1))
(<= (next o3) (does white b) (true o1))
(<= (goal white 0) (true o1))
(<= (goal white 10) (true o2))
(<= (goal white 90) (true o3))
(<= (goal black 0) (true o1))
(<= (goal black 90) (true o2))
(<= (goal black 10) (true o3))
(<= terminal (true o2))
(<= terminal (true o3))
"""
gm = GameMaster(some_simple_game)
# add two python players
gm.add_player(get.get_player("pyrandom"), "black")
gm.add_player(get.get_player("ggtest1"), "white")
gm.start(meta_time=10, move_time=5)
gm.play_to_end()
def get_player(player_type, move_time, gen=None, **extra_opts):
if gen:
assert player_type == "puct", "unknown player type: %s" % player_type
return PUCTPlayer(get_puct_config(gen, **extra_opts))
add_extra_opts = False
assert gen is None
if player_type == "s":
player = get.get_player("simplemcts")
player.max_tree_search_time = move_time
add_extra_opts = True
elif player_type == "m":
player = get.get_player("pymcs")
player.max_run_time = move_time
add_extra_opts = True
elif player_type == "r":
player = get.get_player("random")
elif player_type == "g":
from gurgeh.player import GurgehPlayer
player = GurgehPlayer()
add_extra_opts = True
player.max_tree_search_time = move_time
else:
assert False, "unknown player type: %s" % player_type
if add_extra_opts:
for k, v in extra_opts.items():
setattr(player, k, v)
return player
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 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 test_tictactoe_play_verbose():
gm = GameMaster(lookup.by_name("ticTacToe"), verbose=True)
# 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 main():
import sys
from ggplib.player.get import get_player
player_type = sys.argv[1]
port = int(sys.argv[2])
# if third argument, set to player name
try:
player_name = sys.argv[3]
player = get_player(player_type, player_name=player_name)
except IndexError:
player = get_player(player_type)
play_runner(player, port)
def create_player():
from ggplib.player import get
player = get.get_player("simplemcts")
player.max_tree_search_time = 0.25
player.skip_single_moves = True
player.dump_depth = 1
return player
def play_game(generation_name, player_clz, num_previous_states=1):
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 = get_default_conf(generation_name,
max_dump_depth=2,
playouts_per_iteration=42)
attrutil.pprint(conf)
gm = GameMaster(lookup.by_name(game))
gm.add_player(player_clz(conf), "white")
gm.add_player(get.get_player("random"), "black")
gm.start(meta_time=30, move_time=15)
last_move = None
while not gm.finished():
last_move = gm.play_single_move(last_move=last_move)
gm.finalise_match(last_move)
return gm
def test_trained():
# simplemcts vs GOOD_GEN
simple = get.get_player("simplemcts")
simple.max_run_time = 0.5
eval_config = confs.PUCTEvaluatorConfig(verbose=True,
puct_constant=0.85,
puct_constant_root=3.0,
dirichlet_noise_pct=-1,
fpu_prior_discount=0.25,
fpu_prior_discount_root=0.15,
choose="choose_temperature",
temperature=2.0,
depth_temperature_max=10.0,
depth_temperature_start=0,
depth_temperature_increment=0.75,
depth_temperature_stop=1,
random_scale=1.0,
batch_size=1,
max_dump_depth=1)
puct_config = confs.PUCTPlayerConfig("gzero", True, 200, 0, GOOD_GEN1,
eval_config)
attrutil.pprint(puct_config)
puct_player = PUCTPlayer(puct_config)
play(simple, puct_player)
def main():
setup()
simplemcts = get.get_player("simplemcts")
simplemcts.skip_single_moves = True
pymcs = get.get_player("pymcs")
pymcs.skip_single_moves = True
pymcs.max_run_time = 0.5
mapping = {
'breakthrough' : ["v5_%s" % s for s in [80, 92]],
'cittaceot' : ["v8_%s" % s for s in [20, 30]],
'checkers' : ["v7_%s" % s for s in [10, 16]],
'connectFour' : ["v7_%s" % s for s in [25, 38]],
'escortLatch' : ["v7_%s" % s for s in [5]],
'hex' : ["v7_%s" % s for s in [15, 20]],
'reversi' : ["v7_%s" % s for s in [30, 40, 50]],
# 'speedChess' : ["v9_%s" % s for s in [26]]
}
players = {}
for game in mapping:
players.setdefault(game, [pymcs, simplemcts])
path_to_matches = matches_path(game)
if not os.path.exists(path_to_matches):
os.makedirs(path_to_matches)
for game, gens in mapping.items():
for gen in gens:
conf = templates.puct_config_template(gen, "compete")
players[game].append(CppPUCTPlayer(conf=conf))
meta_time = 20
move_time = 5
while True:
game = random.choice(mapping.keys())
players_available = players[game]
random.shuffle(players_available)
do_game(game, gen, players_available[:2], meta_time, move_time)
# wait 5 seconds between games
time.sleep(5)
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 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_random():
# add two players
# simplemcts vs RANDOM_GEN
pymcs = get.get_player("simplemcts")
pymcs.max_run_time = 0.25
eval_config = templates.base_puct_config(verbose=True, max_dump_depth=1)
puct_config = confs.PUCTPlayerConfig("gzero", True, 100, 0, RANDOM_GEN,
eval_config)
attrutil.pprint(puct_config)
puct_player = PUCTPlayer(puct_config)
play(pymcs, puct_player)
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 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_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
