def test_adjacency_bfs(self):
test_layout = (
""" ##################
#0#. . # . #
# ##### ##### #
# . # . .#1#
################## """)
game_master = GameMaster(test_layout, 2, 200)
bfs = BFSPlayer()
stopping = StoppingPlayer()
game_master.register_team(SimpleTeam(bfs))
game_master.register_team(SimpleTeam(stopping))
game_master.set_initial()
path_target = [(11, 3), (10, 3), (10, 2), (9, 2), (8, 2), (7, 2), (7,
3), (6, 3), (5, 3), (4, 3), (3, 3), (2, 3), (1, 3), (1,2)]
self.assertEqual(path_target, bfs.current_path)
for i in range(len(path_target)):
path_target.pop()
game_master.play_round()
self.assertEqual(path_target, bfs.current_path)
game_master.play_round()
self.assertEqual([(14, 3), (13, 3)], bfs.current_path)
game_master.play_round()
self.assertEqual([(14, 3)], bfs.current_path)
game_master.play_round()
self.assertEqual([], bfs.current_path)
def test_team_names(self):
test_layout = (
""" ##################
#0#. . # . #
#2##### #####1#
# . # . .#3#
################## """)
team_1 = SimpleTeam("team1", TestPlayer([]), TestPlayer([]))
team_2 = SimpleTeam("team2", TestPlayer([]), TestPlayer([]))
game_master = GameMaster(test_layout, [team_1, team_2], 4, 200)
self.assertEqual(game_master.game_state["team_name"][0], "")
self.assertEqual(game_master.game_state["team_name"][1], "")
game_master.set_initial()
self.assertEqual(game_master.game_state["team_name"][0], "team1")
self.assertEqual(game_master.game_state["team_name"][1], "team2")
# check that all players know it, before the game started
self.assertEqual(team_1._players[0].current_state["team_name"][0], "team1")
self.assertEqual(team_1._players[0].current_state["team_name"][1], "team2")
self.assertEqual(team_1._players[1].current_state["team_name"][0], "team1")
self.assertEqual(team_1._players[1].current_state["team_name"][1], "team2")
self.assertEqual(team_2._players[0].current_state["team_name"][0], "team1")
self.assertEqual(team_2._players[0].current_state["team_name"][1], "team2")
self.assertEqual(team_2._players[1].current_state["team_name"][0], "team1")
self.assertEqual(team_2._players[1].current_state["team_name"][1], "team2")
def test_team_names(self):
test_layout = (""" ##################
#0#. . # . #
#2##### #####1#
# . # . .#3#
################## """)
team_1 = SimpleTeam("team1", SteppingPlayer([]), SteppingPlayer([]))
team_2 = SimpleTeam("team2", SteppingPlayer([]), SteppingPlayer([]))
game_master = GameMaster(test_layout, [team_1, team_2], 4, 200)
assert game_master.game_state["team_name"][0] == ""
assert game_master.game_state["team_name"][1] == ""
game_master.set_initial()
assert game_master.game_state["team_name"][0] == "team1"
assert game_master.game_state["team_name"][1] == "team2"
# check that all players know it, before the game started
assert team_1._players[0].current_state["team_name"][0] == "team1"
assert team_1._players[0].current_state["team_name"][1] == "team2"
assert team_1._players[1].current_state["team_name"][0] == "team1"
assert team_1._players[1].current_state["team_name"][1] == "team2"
assert team_2._players[0].current_state["team_name"][0] == "team1"
assert team_2._players[0].current_state["team_name"][1] == "team2"
assert team_2._players[1].current_state["team_name"][0] == "team1"
assert team_2._players[1].current_state["team_name"][1] == "team2"
def test_convenience(self):
test_layout = (
""" ##################
#0#. . # . #
#2##### #####1#
# . # . .#3#
################## """)
game_master = GameMaster(test_layout, 4, 200, noise=False)
universe = game_master.universe
player_0 = StoppingPlayer()
player_1 = TestPlayer([stop, north])
player_2 = StoppingPlayer()
player_3 = StoppingPlayer()
game_master.register_team(SimpleTeam(player_0, player_2))
game_master.register_team(SimpleTeam(player_1, player_3))
game_master.set_initial()
self.assertEqual(universe.bots[0], player_0.me)
self.assertEqual(universe.bots[1], player_1.me)
self.assertEqual(universe.bots[2], player_2.me)
self.assertEqual(universe.bots[3], player_3.me)
self.assertEqual(universe, player_1.current_uni)
self.assertEqual([universe.bots[0]], player_2.other_team_bots)
self.assertEqual([universe.bots[1]], player_3.other_team_bots)
self.assertEqual([universe.bots[2]], player_0.other_team_bots)
self.assertEqual([universe.bots[3]], player_1.other_team_bots)
self.assertEqual([universe.bots[i] for i in (0, 2)], player_0.team_bots)
self.assertEqual([universe.bots[i] for i in (1, 3)], player_0.enemy_bots)
self.assertEqual([universe.bots[i] for i in (1, 3)], player_1.team_bots)
self.assertEqual([universe.bots[i] for i in (0, 2)], player_1.enemy_bots)
self.assertEqual([universe.bots[i] for i in (0, 2)], player_2.team_bots)
self.assertEqual([universe.bots[i] for i in (1, 3)], player_2.enemy_bots)
self.assertEqual([universe.bots[i] for i in (1, 3)], player_3.team_bots)
self.assertEqual([universe.bots[i] for i in (0, 2)], player_3.enemy_bots)
self.assertEqual(universe.bots[1].current_pos, player_1.current_pos)
self.assertEqual(universe.bots[1].initial_pos, player_1.initial_pos)
self.assertEqual(universe.teams[0], player_0.team)
self.assertEqual(universe.teams[0], player_2.team)
self.assertEqual(universe.teams[1], player_1.team)
self.assertEqual(universe.teams[1], player_3.team)
self.assertEqual({(0, 1): (1, 2), (0, 0): (1, 1)},
player_0.legal_moves)
self.assertEqual({(0, 1): (16, 3), (0, -1): (16, 1), (0, 0): (16, 2)},
player_1.legal_moves)
self.assertEqual({(0, 1): (1, 3), (0, -1): (1, 1), (0, 0): (1, 2)},
player_2.legal_moves)
self.assertEqual({(0, -1): (16, 2), (0, 0): (16, 3)},
player_3.legal_moves)
game_master.play_round(0)
game_master.play_round(1)
self.assertEqual(universe, player_1.current_uni)
self.assertEqual((16, 1), player_1.current_pos)
self.assertEqual((16, 2), player_1.previous_pos)
self.assertNotEqual(player_1.current_uni, player_1.universe_states[-2])
def test_team_names(self):
test_layout = (
""" ##################
#0#. . # . #
#2##### #####1#
# . # . .#3#
################## """)
game_master = GameMaster(test_layout, 4, 200)
team_1 = SimpleTeam(TestPlayer([]), TestPlayer([]))
team_2 = SimpleTeam(TestPlayer([]), TestPlayer([]))
game_master.register_team(team_1, team_name="team1")
game_master.register_team(team_2, team_name="team2")
game_master.set_initial()
self.assertEqual(game_master.universe.teams[0].name, "team1")
self.assertEqual(game_master.universe.teams[1].name, "team2")
# check that all players know it, before the game started
self.assertEqual(team_1._players[0].current_uni.teams[0].name, "team1")
self.assertEqual(team_1._players[0].current_uni.teams[1].name, "team2")
self.assertEqual(team_1._players[1].current_uni.teams[0].name, "team1")
self.assertEqual(team_1._players[1].current_uni.teams[1].name, "team2")
self.assertEqual(team_2._players[0].current_uni.teams[0].name, "team1")
self.assertEqual(team_2._players[0].current_uni.teams[1].name, "team2")
self.assertEqual(team_2._players[1].current_uni.teams[0].name, "team1")
self.assertEqual(team_2._players[1].current_uni.teams[1].name, "team2")
def test_kill_count(self):
test_start = (""" ######
#0 1#
#....#
###### """)
# the game lasts two rounds, enough time for bot 1 to eat food
NUM_ROUNDS = 5
teams = [
SimpleTeam(TestPlayer('>--->')),
SimpleTeam(TestPlayer(
'<<<<<')) # bot 1 moves west twice to eat the single food
]
gm = GameMaster(test_start, teams, 2, game_time=NUM_ROUNDS)
gm.set_initial()
gm.play_round()
self.assertEqual(gm.game_state["times_killed"], [0, 0])
gm.play_round()
self.assertEqual(gm.game_state["times_killed"], [0, 1])
gm.play_round()
self.assertEqual(gm.game_state["times_killed"], [0, 1])
gm.play_round()
self.assertEqual(gm.game_state["times_killed"], [0, 2])
gm.play_round()
self.assertEqual(gm.game_state["times_killed"], [1, 2])
def test_win_on_timeout_team_1(self):
test_start = (""" ######
#0 ..#
#.. 1#
###### """)
# the game lasts two rounds, enough time for bot 1 to eat food
NUM_ROUNDS = 2
teams = [
SimpleTeam(StoppingPlayer()),
SimpleTeam(TestPlayer(
'<<')) # bot 1 moves west twice to eat the single food
]
gm = GameMaster(test_start, teams, 2, game_time=NUM_ROUNDS)
# this test viewer caches all events lists seen through observe
class TestViewer(AbstractViewer):
def __init__(self):
self.cache = list()
def observe(self, universe, game_state):
self.cache.append(game_state)
# run the game
tv = TestViewer()
gm.register_viewer(tv)
gm.set_initial()
gm.play()
# check
self.assertTrue(tv.cache[-1]["team_wins"] is not None)
self.assertEqual(tv.cache[-1]["team_wins"], 1)
self.assertEqual(gm.game_state["round_index"], NUM_ROUNDS)
def test_lose_on_eating_all(self):
test_start = (
""" ######
#0 . #
# . 1#
###### """
)
# bot 1 eats all the food and the game stops
gm = GameMaster(test_start, 2, 100)
# players do nothing
gm.register_team(SimpleTeam(StoppingPlayer()))
gm.register_team(SimpleTeam(TestPlayer('<<<')))
gm.universe.teams[0].score = 2
# this test viewer caches all events lists seen through observe
class TestViewer(AbstractViewer):
def __init__(self):
self.cache = list()
def observe(self, universe, game_state):
self.cache.append(game_state)
# run the game
tv = TestViewer()
gm.register_viewer(tv)
gm.set_initial()
gm.play()
# check
self.assertEqual(tv.cache[-1]["round_index"], 1)
self.assertEqual(gm.universe.teams[0].score, 2)
self.assertEqual(gm.universe.teams[1].score, 1)
self.assertTrue(tv.cache[-1]["team_wins"] is not None)
self.assertEqual(tv.cache[-1]["team_wins"], 0)
self.assertEqual(gm.game_state["round_index"], 1)
def test_lose_on_eating_all(self):
test_start = (
""" ######
#0 . #
# . 1#
###### """
)
# the game lasts one round, and then draws
gm = GameMaster(test_start, 2, 100)
# players do nothing
gm.register_team(SimpleTeam(StoppingPlayer()))
gm.register_team(SimpleTeam(TestPlayer([west, west, west])))
gm.universe.teams[0].score = 2
# this test viewer caches all events lists seen through observe
class TestViewer(AbstractViewer):
def __init__(self):
self.cache = list()
self.round_ = list()
def observe(self, round_, turn, universe, events):
self.cache.append(events)
self.round_.append(round_)
# run the game
tv = TestViewer()
gm.register_viewer(tv)
gm.set_initial()
gm.play()
# check
self.assertEqual(tv.round_[-1], 1)
self.assertEqual(gm.universe.teams[0].score, 2)
self.assertEqual(gm.universe.teams[1].score, 1)
self.assertTrue(TeamWins in tv.cache[-1])
self.assertEqual(tv.cache[-1].filter_type(TeamWins)[0], TeamWins(0))
def test_team_names(self):
test_layout = (
""" ##################
#0#. . # . #
#2##### #####1#
# . # . .#3#
################## """)
team_1 = SimpleTeam("team1", SteppingPlayer([]), SteppingPlayer([]))
team_2 = SimpleTeam("team2", SteppingPlayer([]), SteppingPlayer([]))
game_master = GameMaster(test_layout, [team_1, team_2], 4, 200)
assert game_master.game_state["team_name"][0] == ""
assert game_master.game_state["team_name"][1] == ""
game_master.set_initial()
assert game_master.game_state["team_name"][0] == "team1"
assert game_master.game_state["team_name"][1] == "team2"
# check that all players know it, before the game started
assert team_1._players[0].current_state["team_name"][0] == "team1"
assert team_1._players[0].current_state["team_name"][1] == "team2"
assert team_1._players[1].current_state["team_name"][0] == "team1"
assert team_1._players[1].current_state["team_name"][1] == "team2"
assert team_2._players[0].current_state["team_name"][0] == "team1"
assert team_2._players[0].current_state["team_name"][1] == "team2"
assert team_2._players[1].current_state["team_name"][0] == "team1"
assert team_2._players[1].current_state["team_name"][1] == "team2"
def test_lose_on_eating_all(self):
test_start = (
""" ######
#0 . #
# . 1#
###### """
)
teams = [
SimpleTeam(StoppingPlayer()),
SimpleTeam(SteppingPlayer('<<<'))
]
# bot 1 eats all the food and the game stops
gm = GameMaster(test_start, teams, 2, 100)
gm.universe.teams[0].score = 2
# this test viewer caches all events lists seen through observe
class TestViewer(AbstractViewer):
def __init__(self):
self.cache = list()
def observe(self, universe, game_state):
self.cache.append(game_state)
# run the game
tv = TestViewer()
gm.register_viewer(tv)
gm.set_initial()
gm.play()
# check
assert tv.cache[-1]["round_index"] == 1
assert gm.universe.teams[0].score == 2
assert gm.universe.teams[1].score == 1
assert tv.cache[-1]["team_wins"] is not None
assert tv.cache[-1]["team_wins"] == 0
assert gm.game_state["round_index"] == 1
def test_draw_on_timeout(self):
test_start = (
""" ######
#0 . #
# . 1#
###### """)
# the game lasts one round, and then draws
gm = GameMaster(test_start, 2, 1)
# players do nothing
gm.register_team(SimpleTeam(StoppingPlayer()))
gm.register_team(SimpleTeam(StoppingPlayer()))
# this test viewer caches all events lists seen through observe
class TestViewer(AbstractViewer):
def __init__(self):
self.cache = list()
def observe(self, round_, turn, universe, events):
self.cache.append(events)
# run the game
tv = TestViewer()
gm.register_viewer(tv)
gm.set_initial()
gm.play()
# check
self.assertTrue(GameDraw in tv.cache[-1])
self.assertEqual(tv.cache[-1][0], GameDraw())
def test_kill_count(self):
test_start = (
""" ######
#0 1#
#....#
###### """)
# the game lasts two rounds, enough time for bot 1 to eat food
NUM_ROUNDS = 5
teams = [
SimpleTeam(SteppingPlayer('>--->')),
SimpleTeam(SteppingPlayer('<<<<<')) # bot 1 moves west twice to eat the single food
]
gm = GameMaster(test_start, teams, 2, game_time=NUM_ROUNDS)
gm.set_initial()
gm.play_round()
assert gm.game_state["times_killed"] == [0, 0]
gm.play_round()
assert gm.game_state["times_killed"] == [0, 1]
gm.play_round()
assert gm.game_state["times_killed"] == [0, 1]
gm.play_round()
assert gm.game_state["times_killed"] == [0, 2]
gm.play_round()
assert gm.game_state["times_killed"] == [1, 2]
def test_win_on_timeout_team_1(self):
test_start = (
""" ######
#0 ..#
#.. 1#
###### """)
# the game lasts two rounds, enough time for bot 1 to eat food
NUM_ROUNDS = 2
teams = [
SimpleTeam(StoppingPlayer()),
SimpleTeam(SteppingPlayer('<<')) # bot 1 moves west twice to eat the single food
]
gm = GameMaster(test_start, teams, 2, game_time=NUM_ROUNDS)
# this test viewer caches all events lists seen through observe
class TestViewer(AbstractViewer):
def __init__(self):
self.cache = list()
def observe(self, universe, game_state):
self.cache.append(game_state)
# run the game
tv = TestViewer()
gm.register_viewer(tv)
gm.set_initial()
gm.play()
# check
assert tv.cache[-1]["team_wins"] is not None
assert tv.cache[-1]["team_wins"] == 1
assert gm.game_state["round_index"] == NUM_ROUNDS
def test_team_names(self):
test_layout = (
""" ##################
#0#. . # . #
#2##### #####1#
# . # . .#3#
################## """)
game_master = GameMaster(test_layout, 4, 200)
team_1 = SimpleTeam(TestPlayer([]), TestPlayer([]))
team_2 = SimpleTeam(TestPlayer([]), TestPlayer([]))
game_master.register_team(team_1, team_name="team1")
game_master.register_team(team_2, team_name="team2")
game_master.set_initial()
self.assertEqual(game_master.universe.teams[0].name, "team1")
self.assertEqual(game_master.universe.teams[1].name, "team2")
# check that all players know it, before the game started
self.assertEqual(team_1._players[0].current_uni.teams[0].name, "team1")
self.assertEqual(team_1._players[0].current_uni.teams[1].name, "team2")
self.assertEqual(team_1._players[1].current_uni.teams[0].name, "team1")
self.assertEqual(team_1._players[1].current_uni.teams[1].name, "team2")
self.assertEqual(team_2._players[0].current_uni.teams[0].name, "team1")
self.assertEqual(team_2._players[0].current_uni.teams[1].name, "team2")
self.assertEqual(team_2._players[1].current_uni.teams[0].name, "team1")
self.assertEqual(team_2._players[1].current_uni.teams[1].name, "team2")
def test_draw_on_timeout(self):
test_start = (""" ######
#0 . #
# . 1#
###### """)
# the game lasts one round, and then draws
NUM_ROUNDS = 1
# players do nothing
teams = [SimpleTeam(StoppingPlayer()), SimpleTeam(StoppingPlayer())]
gm = GameMaster(test_start, teams, 2, game_time=NUM_ROUNDS)
# this test viewer caches all events lists seen through observe
class TestViewer(AbstractViewer):
def __init__(self):
self.cache = list()
def observe(self, universe, game_state):
self.cache.append(game_state)
# run the game
tv = TestViewer()
gm.register_viewer(tv)
gm.set_initial()
gm.play()
# check
self.assertTrue(tv.cache[-1]["game_draw"])
self.assertEqual(gm.game_state["round_index"], NUM_ROUNDS)
def test_tracking(self):
test_layout = (
"""##############
# 1#
#. 0 .#
#. 2 .#
# # # 3#
############## """)
game_master = GameMaster(test_layout, 4, 5, noise=False)
team_1 = SimpleTeam(TestPlayer('><--'),
TestPlayer('-><-'))
team_2 = SimpleTeam(BasicDefensePlayer(), BasicDefensePlayer())
game_master.register_team(team_1)
game_master.register_team(team_2)
game_master.set_initial()
game_master.play_round()
# 0 moved east, 1 tracks 0
# 2 did not move, 3 tracks 0
self.assertEqual(team_2._players[0].tracking_idx, 0)
self.assertEqual(team_2._players[1].tracking_idx, 0)
game_master.play_round()
# 0 moved back, 1 tracks None
# 2 moved east, 3 tracks 2
self.assertEqual(team_2._players[0].tracking_idx, None)
self.assertEqual(team_2._players[1].tracking_idx, 2)
game_master.play_round()
# 0 did not move, 1 tracks 2
# 2 moved back, 3 tracks None
self.assertEqual(team_2._players[0].tracking_idx, 2)
self.assertEqual(team_2._players[1].tracking_idx, None)
def test_draw_on_timeout(self):
test_start = (
""" ######
#0 . #
# . 1#
###### """)
# the game lasts one round, and then draws
NUM_ROUNDS = 1
# players do nothing
teams = [SimpleTeam(StoppingPlayer()), SimpleTeam(StoppingPlayer())]
gm = GameMaster(test_start, teams, 2, game_time=NUM_ROUNDS)
# this test viewer caches all events lists seen through observe
class TestViewer(AbstractViewer):
def __init__(self):
self.cache = list()
def observe(self, universe, game_state):
self.cache.append(game_state)
# run the game
tv = TestViewer()
gm.register_viewer(tv)
gm.set_initial()
gm.play()
# check
assert tv.cache[-1]["game_draw"]
assert gm.game_state["round_index"] == NUM_ROUNDS
def test_win_on_timeout_team_0(self):
test_start = """ ######
#0 ..#
#.. 1#
###### """
# the game lasts two rounds, enough time for bot 1 to eat food
NUM_ROUNDS = 2
gm = GameMaster(test_start, 2, game_time=NUM_ROUNDS)
# bot 1 moves east twice to eat the single food
gm.register_team(SimpleTeam(TestPlayer(">>")))
gm.register_team(SimpleTeam(StoppingPlayer()))
# this test viewer caches all events lists seen through observe
class TestViewer(AbstractViewer):
def __init__(self):
self.cache = list()
def observe(self, universe, game_state):
self.cache.append(game_state)
# run the game
tv = TestViewer()
gm.register_viewer(tv)
gm.set_initial()
gm.play()
# check
self.assertTrue(tv.cache[-1]["team_wins"] is not None)
self.assertEqual(tv.cache[-1]["team_wins"], 0)
self.assertEqual(gm.game_state["round_index"], NUM_ROUNDS)
def test_lose_on_eating_all(self):
test_start = (""" ######
#0 . #
# . 1#
###### """)
teams = [SimpleTeam(StoppingPlayer()), SimpleTeam(TestPlayer('<<<'))]
# bot 1 eats all the food and the game stops
gm = GameMaster(test_start, teams, 2, 100)
gm.universe.teams[0].score = 2
# this test viewer caches all events lists seen through observe
class TestViewer(AbstractViewer):
def __init__(self):
self.cache = list()
def observe(self, universe, game_state):
self.cache.append(game_state)
# run the game
tv = TestViewer()
gm.register_viewer(tv)
gm.set_initial()
gm.play()
# check
self.assertEqual(tv.cache[-1]["round_index"], 1)
self.assertEqual(gm.universe.teams[0].score, 2)
self.assertEqual(gm.universe.teams[1].score, 1)
self.assertTrue(tv.cache[-1]["team_wins"] is not None)
self.assertEqual(tv.cache[-1]["team_wins"], 0)
self.assertEqual(gm.game_state["round_index"], 1)
def test_win_on_timeout_team_1(self):
test_start = (
""" ######
#0 ..#
#.. 1#
###### """)
# the game lasts two rounds, enough time for bot 1 to eat food
gm = GameMaster(test_start, 2, 2)
gm.register_team(SimpleTeam(StoppingPlayer()))
# bot 1 moves west twice to eat the single food
gm.register_team(SimpleTeam(TestPlayer([west, west])))
# this test viewer caches all events lists seen through observe
class TestViewer(AbstractViewer):
def __init__(self):
self.cache = list()
def observe(self, round_, turn, universe, events):
self.cache.append(events)
# run the game
tv = TestViewer()
gm.register_viewer(tv)
gm.set_initial()
gm.play()
# check
self.assertTrue(TeamWins in tv.cache[-1])
self.assertEqual(tv.cache[-1][0], TeamWins(1))
def test_must_not_move_after_last_timeout(self):
# 0 must move back and forth because of random steps
# but due to its last timeout, it should be disqualified
# immediately
test_start = (
""" ######
##0.##
# ## #
##. 1#
###### """
)
# players do nothing
class TimeOutPlayer(AbstractPlayer):
def get_move(self):
raise PlayerTimeout
class CheckTestPlayer(AbstractPlayer):
def get_move(self):
raise RuntimeError("This should never be called")
teams = [
SimpleTeam(TimeOutPlayer()),
SimpleTeam(CheckTestPlayer())
]
# the game lasts one round, and then draws
gm = GameMaster(test_start, teams, 2, 100, max_timeouts=1)
# this test viewer caches all events lists seen through observe
class TestViewer(AbstractViewer):
def __init__(self):
self.cache = list()
def observe(self, universe, game_state):
self.cache.append(game_state)
# run the game
tv = TestViewer()
gm.register_viewer(tv)
gm.set_initial()
gm.play()
print(gm.universe.pretty)
print(gm.game_state)
# check
assert gm.game_state["max_timeouts"] == 1
assert tv.cache[-1]["round_index"] == gm.game_state["max_timeouts"] - 1
assert gm.universe.teams[0].score == 0
assert gm.universe.teams[1].score == 0
assert gm.universe.bots[0].current_pos == (2,1)
assert tv.cache[-1]["team_wins"] is not None
assert tv.cache[-1]["team_wins"] == 1
# the game ends in round 0 with bot_id 0
assert gm.game_state["round_index"] == 0
assert gm.game_state["bot_id"] == 0
def test_must_not_move_after_last_timeout(self):
# 0 must move back and forth because of random steps
# but due to its last timeout, it should be disqualified
# immediately
test_start = (
""" ######
##0.##
# ## #
##. 1#
###### """
)
# players do nothing
class TimeOutPlayer(AbstractPlayer):
def get_move(self):
raise PlayerTimeout
class CheckTestPlayer(AbstractPlayer):
def get_move(self):
raise RuntimeError("This should never be called")
teams = [
SimpleTeam(TimeOutPlayer()),
SimpleTeam(CheckTestPlayer())
]
# the game lasts one round, and then draws
gm = GameMaster(test_start, teams, 2, 100, max_timeouts=1)
# this test viewer caches all events lists seen through observe
class TestViewer(AbstractViewer):
def __init__(self):
self.cache = list()
def observe(self, universe, game_state):
self.cache.append(game_state)
# run the game
tv = TestViewer()
gm.register_viewer(tv)
gm.set_initial()
gm.play()
print(gm.universe.pretty)
print(gm.game_state)
# check
assert gm.game_state["max_timeouts"] == 1
assert tv.cache[-1]["round_index"] == gm.game_state["max_timeouts"] - 1
assert gm.universe.teams[0].score == 0
assert gm.universe.teams[1].score == 0
assert gm.universe.bots[0].current_pos == (2,1)
assert tv.cache[-1]["team_wins"] is not None
assert tv.cache[-1]["team_wins"] == 1
# the game ends in round 0 with bot_id 0
assert gm.game_state["round_index"] == 0
assert gm.game_state["bot_id"] == 0
def test_unreachable_bot(self):
test_layout = (
""" ############
# . 0#. 1#
############ """)
game_master = GameMaster(test_layout, 2, 1, noise=False)
bfs2 = BasicDefensePlayer()
game_master.register_team(SimpleTeam(StoppingPlayer()))
game_master.register_team(SimpleTeam(bfs2))
game_master.set_initial()
game_master.play()
self.assertTrue(bfs2.path is None)
def test_unreachable(self):
test_layout = """ ############
#0. #.1#
############ """
game_master = GameMaster(test_layout, 2, 200)
bfs1 = BFSPlayer()
bfs2 = BFSPlayer()
game_master.register_team(SimpleTeam(bfs1))
game_master.register_team(SimpleTeam(bfs2))
game_master.set_initial()
game_master.play_round(0)
self.assertEqual(0, len(bfs1.current_path))
self.assertEqual(0, len(bfs2.current_path))
def test_team_names_in_simpleteam(self):
test_layout = (""" ##################
#0#. . # . #
#2##### #####1#
# . # . .#3#
################## """)
team_1 = SimpleTeam('team1', TestPlayer([]), TestPlayer([]))
team_2 = SimpleTeam('team2', TestPlayer([]), TestPlayer([]))
game_master = GameMaster(test_layout, [team_1, team_2], 4, 200)
game_master.set_initial()
self.assertEqual(game_master.game_state["team_name"][0], "team1")
self.assertEqual(game_master.game_state["team_name"][1], "team2")
def test_team_names_in_simpleteam(self):
test_layout = (""" ##################
#0#. . # . #
#2##### #####1#
# . # . .#3#
################## """)
team_1 = SimpleTeam('team1', SteppingPlayer([]), SteppingPlayer([]))
team_2 = SimpleTeam('team2', SteppingPlayer([]), SteppingPlayer([]))
game_master = GameMaster(test_layout, [team_1, team_2], 4, 200)
game_master.set_initial()
assert game_master.game_state["team_name"][0] == "team1"
assert game_master.game_state["team_name"][1] == "team2"
def test_unreachable_border(self):
test_layout = (
""" ############
#0 . #. 1#
############ """)
game_master = GameMaster(test_layout, 2, 1, noise=False)
bfs1 = BasicDefensePlayer()
bfs2 = BasicDefensePlayer()
game_master.register_team(SimpleTeam(bfs1))
game_master.register_team(SimpleTeam(bfs2))
game_master.set_initial()
game_master.play()
self.assertEqual(bfs1.path, [(5, 1), (4, 1), (3, 1)])
self.assertTrue(bfs2.path is None)
def test_team_names_in_simpleteam(self):
test_layout = (
""" ##################
#0#. . # . #
#2##### #####1#
# . # . .#3#
################## """)
team_1 = SimpleTeam('team1', SteppingPlayer([]), SteppingPlayer([]))
team_2 = SimpleTeam('team2', SteppingPlayer([]), SteppingPlayer([]))
game_master = GameMaster(test_layout, [team_1, team_2], 4, 200)
game_master.set_initial()
assert game_master.game_state["team_name"][0] == "team1"
assert game_master.game_state["team_name"][1] == "team2"
def test_team_names_in_simpleteam(self):
test_layout = (
""" ##################
#0#. . # . #
#2##### #####1#
# . # . .#3#
################## """)
team_1 = SimpleTeam('team1', TestPlayer([]), TestPlayer([]))
team_2 = SimpleTeam('team2', TestPlayer([]), TestPlayer([]))
game_master = GameMaster(test_layout, [team_1, team_2], 4, 200)
game_master.set_initial()
self.assertEqual(game_master.game_state["team_name"][0], "team1")
self.assertEqual(game_master.game_state["team_name"][1], "team2")
def test_lose_5_timeouts(self):
# 0 must move back and forth because of random steps
test_start = (
""" ######
#0 #.#
### #
##. 1#
###### """
)
# players do nothing
class TimeOutPlayer(AbstractPlayer):
def get_move(self):
raise PlayerTimeout
teams = [
SimpleTeam(TimeOutPlayer()),
SimpleTeam(StoppingPlayer())
]
# the game lasts one round, and then draws
gm = GameMaster(test_start, teams, 2, 100, max_timeouts=5)
# this test viewer caches all events lists seen through observe
class TestViewer(AbstractViewer):
def __init__(self):
self.cache = list()
def observe(self, universe, game_state):
self.cache.append(game_state)
# run the game
tv = TestViewer()
gm.register_viewer(tv)
gm.set_initial()
assert gm.universe.bots[0].current_pos == (1,1)
gm.play()
# check
assert gm.game_state["max_timeouts"] == 5
assert tv.cache[-1]["round_index"] == gm.game_state["max_timeouts"] - 1
assert gm.universe.teams[0].score == 0
assert gm.universe.teams[1].score == 0
# the bot moves four times, so after the fourth time,
# it is back on its original position
assert gm.universe.bots[0].current_pos == (1,1)
assert tv.cache[-1]["team_wins"] is not None
assert tv.cache[-1]["team_wins"] == 1
def test_viewer_must_not_change_gm(self):
free_obj = Free()
class MeanViewer(AbstractViewer):
def set_initial(self, universe):
universe.teams[1].score = 50
def observe(self, round_, turn, universe, events):
universe.teams[0].score = 100
universe.bots[0].current_pos = (4,4)
universe.maze[0,0][0] = free_obj
events.append(TeamWins(0))
test_self.assertEqual(len(events), 2)
test_start = (
""" ######
#0 . #
#.. 1#
###### """)
number_bots = 2
gm = GameMaster(test_start, number_bots, 200)
gm.register_team(SimpleTeam(TestPlayer([(0,0)])))
gm.register_team(SimpleTeam(TestPlayer([(0,0)])))
original_universe = gm.universe.copy()
test_self = self
class TestViewer(AbstractViewer):
def observe(self, round_, turn, universe, events):
# universe should not have been altered
test_self.assertEqual(original_universe, gm.universe)
# there should only be a botmoves event
test_self.assertEqual(len(events), 1)
test_self.assertEqual(len(events), 1)
test_self.assertTrue(BotMoves in events)
gm.register_viewer(MeanViewer())
gm.register_viewer(TestViewer())
gm.set_initial()
gm.play_round(0)
self.assertEqual(original_universe, gm.universe)
def test_lose_5_timeouts(self):
# 0 must move back and forth because of random steps
test_start = (
""" ######
#0 #.#
### #
##. 1#
###### """
)
# players do nothing
class TimeOutPlayer(AbstractPlayer):
def get_move(self):
raise PlayerTimeout
teams = [
SimpleTeam(TimeOutPlayer()),
SimpleTeam(StoppingPlayer())
]
# the game lasts one round, and then draws
gm = GameMaster(test_start, teams, 2, 100, max_timeouts=5)
# this test viewer caches all events lists seen through observe
class TestViewer(AbstractViewer):
def __init__(self):
self.cache = list()
def observe(self, universe, game_state):
self.cache.append(game_state)
# run the game
tv = TestViewer()
gm.register_viewer(tv)
gm.set_initial()
assert gm.universe.bots[0].current_pos == (1,1)
gm.play()
# check
assert gm.game_state["max_timeouts"] == 5
assert tv.cache[-1]["round_index"] == gm.game_state["max_timeouts"] - 1
assert gm.universe.teams[0].score == 0
assert gm.universe.teams[1].score == 0
# the bot moves four times, so after the fourth time,
# it is back on its original position
assert gm.universe.bots[0].current_pos == (1,1)
assert tv.cache[-1]["team_wins"] is not None
assert tv.cache[-1]["team_wins"] == 1
def test_team_names_in_simpleteam(self):
test_layout = """ ##################
#0#. . # . #
#2##### #####1#
# . # . .#3#
################## """
game_master = GameMaster(test_layout, 4, 200)
team_1 = SimpleTeam("team1", TestPlayer([]), TestPlayer([]))
team_2 = SimpleTeam("team2", TestPlayer([]), TestPlayer([]))
game_master.register_team(team_1)
game_master.register_team(team_2)
game_master.set_initial()
self.assertEqual(game_master.universe.teams[0].name, "team1")
self.assertEqual(game_master.universe.teams[1].name, "team2")
def test_lose_5_timeouts(self):
# 0 must move back and forth because of random steps
test_start = (
""" ######
#0 #.#
### #
##. 1#
###### """
)
# the game lasts one round, and then draws
gm = GameMaster(test_start, 2, 100)
# players do nothing
class TimeOutPlayer(AbstractPlayer):
def get_move(self):
raise PlayerTimeout
gm.register_team(SimpleTeam(TimeOutPlayer()))
gm.register_team(SimpleTeam(StoppingPlayer()))
# this test viewer caches all events lists seen through observe
class TestViewer(AbstractViewer):
def __init__(self):
self.cache = list()
self.round_ = list()
def observe(self, round_, turn, universe, events):
self.cache.append(events)
self.round_.append(round_)
# run the game
tv = TestViewer()
gm.register_viewer(tv)
gm.set_initial()
self.assertEqual(gm.universe.bots[0].current_pos, (1,1))
gm.play()
# check
self.assertEqual(tv.round_[-1], pelita.game_master.MAX_TIMEOUTS - 1)
self.assertEqual(gm.universe.teams[0].score, 0)
self.assertEqual(gm.universe.teams[1].score, 0)
self.assertEqual(gm.universe.bots[0].current_pos, (2,1))
self.assertTrue(TeamWins in tv.cache[-1])
self.assertEqual(tv.cache[-1].filter_type(TeamWins)[0], TeamWins(1))
def test_shorthand(self):
test_layout = (""" ############
#0 . . #
# 1#
############ """)
num_rounds = 5
gm = GameMaster(test_layout, 2, num_rounds)
gm.register_team(SimpleTeam(TestPlayer('>v<^-)')))
gm.register_team(SimpleTeam(TestPlayer('<^>v-)')))
player0_expected_positions = [(1, 1), (2, 1), (2, 2), (1, 2), (1, 1)]
player1_expected_positions = [(10, 2), (9, 2), (9, 1), (10, 1),
(10, 2)]
gm.set_initial()
for i in range(num_rounds):
self.assertEqual(gm.universe.bots[0].current_pos,
player0_expected_positions[i])
self.assertEqual(gm.universe.bots[1].current_pos,
player1_expected_positions[i])
gm.play_round()
def test_lose_5_timeouts(self):
# 0 must move back and forth because of random steps
test_start = (
""" ######
#0 #.#
### #
##. 1#
###### """
)
# the game lasts one round, and then draws
gm = GameMaster(test_start, 2, 100, max_timeouts=5)
# players do nothing
class TimeOutPlayer(AbstractPlayer):
def get_move(self):
raise PlayerTimeout
gm.register_team(SimpleTeam(TimeOutPlayer()))
gm.register_team(SimpleTeam(StoppingPlayer()))
# this test viewer caches all events lists seen through observe
class TestViewer(AbstractViewer):
def __init__(self):
self.cache = list()
def observe(self, universe, game_state):
self.cache.append(game_state)
# run the game
tv = TestViewer()
gm.register_viewer(tv)
gm.set_initial()
self.assertEqual(gm.universe.bots[0].current_pos, (1,1))
gm.play()
# check
self.assertEqual(gm.game_state["max_timeouts"], 5)
self.assertEqual(tv.cache[-1]["round_index"], gm.game_state["max_timeouts"] - 1)
self.assertEqual(gm.universe.teams[0].score, 0)
self.assertEqual(gm.universe.teams[1].score, 0)
self.assertEqual(gm.universe.bots[0].current_pos, (2,1))
self.assertTrue(tv.cache[-1]["team_wins"] is not None)
self.assertEqual(tv.cache[-1]["team_wins"], 1)
def test_shorthand(self):
test_layout = (
""" ############
#0 . . #
# 1#
############ """)
num_rounds = 5
gm = GameMaster(test_layout, 2, num_rounds)
gm.register_team(SimpleTeam(TestPlayer('>v<^-)')))
gm.register_team(SimpleTeam(TestPlayer('<^>v-)')))
player0_expected_positions = [(1,1), (2,1), (2,2), (1,2), (1,1)]
player1_expected_positions = [(10,2), (9,2), (9,1), (10,1), (10,2)]
gm.set_initial()
for i in range(num_rounds):
self.assertEqual(gm.universe.bots[0].current_pos,
player0_expected_positions[i])
self.assertEqual(gm.universe.bots[1].current_pos,
player1_expected_positions[i])
gm.play_round()
def test_viewer_may_change_gm(self):
class MeanViewer(AbstractViewer):
def set_initial(self, universe):
universe.teams[1].score = 50
def observe(self, universe, game_state):
universe.teams[0].score = 100
universe.bots[0].current_pos = (4,2)
universe.maze[0,0] = False
game_state["team_wins"] = 0
test_start = (
""" ######
#0 . #
#.. 1#
###### """)
number_bots = 2
teams = [
SimpleTeam(TestPlayer([(0,0)])),
SimpleTeam(TestPlayer([(0,0)]))
]
gm = GameMaster(test_start, teams, number_bots, 200)
original_universe = gm.universe.copy()
test_self = self
class TestViewer(AbstractViewer):
def observe(self, universe, game_state):
# universe has been altered
test_self.assertNotEqual(original_universe, gm.universe)
gm.register_viewer(MeanViewer())
gm.register_viewer(TestViewer())
gm.set_initial()
gm.play_round()
self.assertNotEqual(original_universe, gm.universe)
def test_team_names_in_simpleteam(self):
test_layout = (
""" ##################
#0#. . # . #
#2##### #####1#
# . # . .#3#
################## """)
game_master = GameMaster(test_layout, 4, 200)
team_1 = SimpleTeam('team1', TestPlayer([]), TestPlayer([]))
team_2 = SimpleTeam('team2', TestPlayer([]), TestPlayer([]))
game_master.register_team(team_1)
game_master.register_team(team_2)
game_master.set_initial()
self.assertEqual(game_master.universe.teams[0].name, "team1")
self.assertEqual(game_master.universe.teams[1].name,
"team2")
def test_malicous_player(self):
class MaliciousPlayer(AbstractPlayer):
def _get_move(self, universe, game_state):
universe.teams[0].score = 100
universe.bots[0].current_pos = (2,2)
universe.maze[0,0] = False
return {"move": (0,0)}
def get_move(self):
pass
test_layout = (
""" ######
#0 . #
#.. 1#
###### """)
test_self = self
original_universe = None
class TestMaliciousPlayer(AbstractPlayer):
def get_move(self):
test_self.assertIsNotNone(original_universe)
print(id(original_universe.maze))
print(id(gm.universe.maze))
# universe should have been altered because the
# Player is really malicious
test_self.assertNotEqual(original_universe, gm.universe)
return (0,0)
teams = [
SimpleTeam(MaliciousPlayer()),
SimpleTeam(TestMaliciousPlayer())
]
gm = GameMaster(test_layout, teams, 2, 200)
original_universe = gm.universe.copy()
gm.set_initial()
gm.play_round()
test_self.assertNotEqual(original_universe, gm.universe)
def test_viewer_may_change_gm(self):
class MeanViewer(AbstractViewer):
def set_initial(self, universe):
universe.teams[1].score = 50
def observe(self, universe, game_state):
universe.teams[0].score = 100
universe.bots[0].current_pos = (4, 2)
universe.maze[0, 0] = False
game_state["team_wins"] = 0
test_start = (""" ######
#0 . #
#.. 1#
###### """)
number_bots = 2
teams = [
SimpleTeam(TestPlayer([(0, 0)])),
SimpleTeam(TestPlayer([(0, 0)]))
]
gm = GameMaster(test_start, teams, number_bots, 200)
original_universe = gm.universe.copy()
test_self = self
class TestViewer(AbstractViewer):
def observe(self, universe, game_state):
# universe has been altered
test_self.assertNotEqual(original_universe, gm.universe)
gm.register_viewer(MeanViewer())
gm.register_viewer(TestViewer())
gm.set_initial()
gm.play_round()
self.assertNotEqual(original_universe, gm.universe)
def test_shorthand(self):
test_layout = (
""" ############
#0 . . #
# 1#
############ """)
num_rounds = 5
teams = [
SimpleTeam(TestPlayer('>v<^-)')),
SimpleTeam(TestPlayer('<^>v-)'))
]
gm = GameMaster(test_layout, teams, 2, num_rounds)
player0_expected_positions = [(1,1), (2,1), (2,2), (1,2), (1,1)]
player1_expected_positions = [(10,2), (9,2), (9,1), (10,1), (10,2)]
gm.set_initial()
for i in range(num_rounds):
assert gm.universe.bots[0].current_pos == \
player0_expected_positions[i]
assert gm.universe.bots[1].current_pos == \
player1_expected_positions[i]
gm.play_round()
def test_malicous_player(self):
class MaliciousPlayer(AbstractPlayer):
def _get_move(self, universe, game_state):
universe.teams[0].score = 100
universe.bots[0].current_pos = (2, 2)
universe.maze[0, 0] = False
return {"move": (0, 0)}
def get_move(self):
pass
test_layout = (""" ######
#0 . #
#.. 1#
###### """)
test_self = self
original_universe = None
class TestMaliciousPlayer(AbstractPlayer):
def get_move(self):
test_self.assertIsNotNone(original_universe)
print(id(original_universe.maze))
print(id(gm.universe.maze))
# universe should have been altered because the
# Player is really malicious
test_self.assertNotEqual(original_universe, gm.universe)
return (0, 0)
teams = [
SimpleTeam(MaliciousPlayer()),
SimpleTeam(TestMaliciousPlayer())
]
gm = GameMaster(test_layout, teams, 2, 200)
original_universe = gm.universe.copy()
gm.set_initial()
gm.play_round()
test_self.assertNotEqual(original_universe, gm.universe)
def test_team_names(self):
test_layout = (""" ##################
#0#. . # . #
#2##### #####1#
# . # . .#3#
################## """)
team_1 = SimpleTeam("team1", TestPlayer([]), TestPlayer([]))
team_2 = SimpleTeam("team2", TestPlayer([]), TestPlayer([]))
game_master = GameMaster(test_layout, [team_1, team_2], 4, 200)
self.assertEqual(game_master.game_state["team_name"][0], "")
self.assertEqual(game_master.game_state["team_name"][1], "")
game_master.set_initial()
self.assertEqual(game_master.game_state["team_name"][0], "team1")
self.assertEqual(game_master.game_state["team_name"][1], "team2")
# check that all players know it, before the game started
self.assertEqual(team_1._players[0].current_state["team_name"][0],
"team1")
self.assertEqual(team_1._players[0].current_state["team_name"][1],
"team2")
self.assertEqual(team_1._players[1].current_state["team_name"][0],
"team1")
self.assertEqual(team_1._players[1].current_state["team_name"][1],
"team2")
self.assertEqual(team_2._players[0].current_state["team_name"][0],
"team1")
self.assertEqual(team_2._players[0].current_state["team_name"][1],
"team2")
self.assertEqual(team_2._players[1].current_state["team_name"][0],
"team1")
self.assertEqual(team_2._players[1].current_state["team_name"][1],
"team2")
def test_random_seeds(self):
test_layout = (""" ################
# #
# #
# #
# 0 1 #
# 2 3 #
# #
# #
#. .#
################ """)
players_a = [RandomPlayer() for _ in range(4)]
team_1 = [
SimpleTeam(players_a[0], players_a[2]),
SimpleTeam(players_a[1], players_a[3])
]
gm1 = GameMaster(test_layout, team_1, 4, 5, seed=20)
gm1.set_initial()
random_numbers_a = [
player.rnd.randint(0, 10000) for player in players_a
]
# check that each player has a different seed (if randomness allows)
self.assertEqual(len(set(random_numbers_a)), 4,
"Probably not all player seeds were unique.")
players_b = [RandomPlayer() for _ in range(4)]
team_2 = [
SimpleTeam(players_b[0], players_b[2]),
SimpleTeam(players_b[1], players_b[3])
]
gm2 = GameMaster(test_layout, team_2, 4, 5, seed=20)
gm2.set_initial()
random_numbers_b = [
player.rnd.randint(0, 10000) for player in players_b
]
self.assertEqual(random_numbers_a, random_numbers_b)
players_c = [RandomPlayer() for _ in range(4)]
team_3 = [
SimpleTeam(players_c[0], players_c[2]),
SimpleTeam(players_c[1], players_c[3])
]
gm3 = GameMaster(test_layout, team_3, 4, 5, seed=200)
gm3.set_initial()
random_numbers_c = [
player.rnd.randint(0, 10000) for player in players_c
]
self.assertNotEqual(random_numbers_a, random_numbers_c)
def test_play_step(self):
test_start = (""" ########
# 0 ..#
#.. 1 #
######## """)
number_bots = 2
teams = [
SimpleTeam(SteppingPlayer('>>>>')),
SimpleTeam(SteppingPlayer('<<<<'))
]
gm = GameMaster(test_start, teams, number_bots, 4)
gm.set_initial()
gm.play_round()
assert gm.universe.bots[0].current_pos == (3, 1)
assert gm.universe.bots[1].current_pos == (4, 2)
assert gm.game_state["round_index"] == 0
assert gm.game_state["bot_id"] is None
assert not gm.game_state["finished"]
gm.play_step()
assert gm.universe.bots[0].current_pos == (4, 1)
assert gm.universe.bots[1].current_pos == (4, 2)
assert gm.game_state["round_index"] == 1
assert gm.game_state["bot_id"] == 0
assert gm.game_state["finished"] == False
gm.play_step()
assert gm.universe.bots[0].current_pos == (4, 1)
assert gm.universe.bots[1].current_pos == (3, 2)
assert gm.game_state["round_index"] == 1
assert gm.game_state["bot_id"] == 1
assert gm.game_state["finished"] == False
gm.play_step()
assert gm.universe.bots[0].current_pos == (5, 1)
assert gm.universe.bots[1].current_pos == (3, 2)
assert gm.game_state["round_index"] == 2
assert gm.game_state["bot_id"] == 0
assert gm.game_state["finished"] == False
gm.play_step()
assert gm.universe.bots[0].current_pos == (5, 1)
assert gm.universe.bots[1].current_pos == (2, 2)
assert gm.game_state["round_index"] == 2
assert gm.game_state["bot_id"] == 1
assert gm.game_state["finished"] == False
gm.play_round()
# first call tries to finish current round (which already is finished)
# so nothing happens
assert gm.universe.bots[0].current_pos == (5, 1)
assert gm.universe.bots[1].current_pos == (2, 2)
assert gm.game_state["round_index"] == 2
assert gm.game_state["bot_id"] is None
assert gm.game_state["finished"] == False
assert gm.game_state["team_wins"] == None
assert gm.game_state["game_draw"] == None
gm.play_round()
# second call works
assert gm.universe.bots[0].current_pos == (6, 1)
assert gm.universe.bots[1].current_pos == (2, 2)
assert gm.game_state["round_index"] == 3
assert gm.game_state["bot_id"] == 0
assert gm.game_state["finished"] == True
assert gm.game_state["team_wins"] == 0
assert gm.game_state["game_draw"] == None
# Game finished immediately once all food for one group was eaten
# team 0 finished first and the round was NOT played regularly to the end
# (hence round_index == 3 and bot_id == 0)
# nothing happens anymore
gm.play_round()
assert gm.universe.bots[0].current_pos == (6, 1)
assert gm.universe.bots[1].current_pos == (2, 2)
assert gm.game_state["round_index"] == 3
assert gm.game_state["bot_id"] == 0
assert gm.game_state["finished"] == True
assert gm.game_state["team_wins"] == 0
assert gm.game_state["game_draw"] == None
# nothing happens anymore
gm.play_round()
assert gm.universe.bots[0].current_pos == (6, 1)
assert gm.universe.bots[1].current_pos == (2, 2)
assert gm.game_state["round_index"] == 3
assert gm.game_state["bot_id"] == 0
assert gm.game_state["finished"] == True
assert gm.game_state["team_wins"] == 0
assert gm.game_state["game_draw"] == None
def test_convenience(self):
test_layout = (""" ##################
#0#. . # . #
#2##### ####1 #
# . # . #3##
################## """)
player_0 = StoppingPlayer()
player_1 = TestPlayer('^<')
player_2 = StoppingPlayer()
player_3 = StoppingPlayer()
teams = [
SimpleTeam(player_0, player_2),
SimpleTeam(player_1, player_3)
]
game_master = GameMaster(test_layout, teams, 4, 2, noise=False)
universe = game_master.universe
game_master.set_initial()
self.assertEqual(universe.bots[0], player_0.me)
self.assertEqual(universe.bots[1], player_1.me)
self.assertEqual(universe.bots[2], player_2.me)
self.assertEqual(universe.bots[3], player_3.me)
self.assertEqual(universe, player_1.current_uni)
self.assertEqual([universe.bots[0]], player_2.other_team_bots)
self.assertEqual([universe.bots[1]], player_3.other_team_bots)
self.assertEqual([universe.bots[2]], player_0.other_team_bots)
self.assertEqual([universe.bots[3]], player_1.other_team_bots)
self.assertEqual([universe.bots[i] for i in (0, 2)],
player_0.team_bots)
self.assertEqual([universe.bots[i] for i in (1, 3)],
player_0.enemy_bots)
self.assertEqual([universe.bots[i] for i in (1, 3)],
player_1.team_bots)
self.assertEqual([universe.bots[i] for i in (0, 2)],
player_1.enemy_bots)
self.assertEqual([universe.bots[i] for i in (0, 2)],
player_2.team_bots)
self.assertEqual([universe.bots[i] for i in (1, 3)],
player_2.enemy_bots)
self.assertEqual([universe.bots[i] for i in (1, 3)],
player_3.team_bots)
self.assertEqual([universe.bots[i] for i in (0, 2)],
player_3.enemy_bots)
self.assertEqual(player_1.current_pos, (15, 2))
self.assertEqual(player_1.initial_pos, (15, 2))
self.assertEqual(universe.bots[1].current_pos, (15, 2))
self.assertEqual(universe.bots[1].initial_pos, (15, 2))
self.assertEqual(universe.teams[0], player_0.team)
self.assertEqual(universe.teams[0], player_2.team)
self.assertEqual(universe.teams[1], player_1.team)
self.assertEqual(universe.teams[1], player_3.team)
self.assertEqual(universe.teams[1], player_0.enemy_team)
self.assertEqual(universe.teams[1], player_2.enemy_team)
self.assertEqual(universe.teams[0], player_1.enemy_team)
self.assertEqual(universe.teams[0], player_3.enemy_team)
self.assertCountEqual(player_0.enemy_food,
universe.enemy_food(player_0.team.index))
self.assertCountEqual(player_1.enemy_food,
universe.enemy_food(player_1.team.index))
self.assertCountEqual(player_2.enemy_food,
universe.enemy_food(player_2.team.index))
self.assertCountEqual(player_3.enemy_food,
universe.enemy_food(player_3.team.index))
self.assertCountEqual(player_0.team_food,
universe.team_food(player_0.team.index))
self.assertCountEqual(player_1.team_food,
universe.team_food(player_1.team.index))
self.assertCountEqual(player_2.team_food,
universe.team_food(player_2.team.index))
self.assertCountEqual(player_3.team_food,
universe.team_food(player_3.team.index))
self.assertEqual({
(0, 1): (1, 2),
(0, 0): (1, 1)
}, player_0.legal_moves)
self.assertEqual(
{
(0, 1): (15, 3),
(0, -1): (15, 1),
(0, 0): (15, 2),
(1, 0): (16, 2)
}, player_1.legal_moves)
self.assertEqual({
(0, 1): (1, 3),
(0, -1): (1, 1),
(0, 0): (1, 2)
}, player_2.legal_moves)
self.assertEqual({
(0, -1): (15, 2),
(0, 0): (15, 3)
}, player_3.legal_moves)
self.assertEqual(player_1.current_state["round_index"], None)
self.assertEqual(player_1.current_state["bot_id"], None)
game_master.play_round()
self.assertEqual(player_1.current_pos, (15, 2))
self.assertEqual(player_1.previous_pos, (15, 2))
self.assertEqual(player_1.initial_pos, (15, 2))
self.assertEqual(player_1.current_state["round_index"], 0)
self.assertTrue(player_1.current_state["bot_id"] is None)
self.assertEqual(universe.bots[1].current_pos, (15, 1))
self.assertEqual(universe.bots[1].initial_pos, (15, 2))
self.assertUniversesEqual(player_1.current_uni,
player_1.universe_states[-1])
game_master.play_round()
self.assertEqual(player_1.current_pos, (15, 1))
self.assertEqual(player_1.previous_pos, (15, 2))
self.assertEqual(player_1.initial_pos, (15, 2))
self.assertEqual(player_1.current_state["round_index"], 1)
self.assertTrue(player_1.current_state["bot_id"] is None)
self.assertEqual(universe.bots[1].current_pos, (14, 1))
self.assertEqual(universe.bots[1].initial_pos, (15, 2))
self.assertUniversesNotEqual(player_1.current_uni,
player_1.universe_states[-2])
def test_remote_viewer_may_not_change_gm(self):
free_obj = Free
self.mean_viewer_did_run = False
class MeanViewer(AbstractViewer):
def set_initial(self, universe):
universe.teams[1].score = 50
def observe(self_, universe, game_state):
self.mean_viewer_did_run = True
universe.teams[0].score = 100
universe.bots[0].current_pos = (4, 4)
universe.maze[0, 0] = free_obj
game_state["team_wins"] = 0
test_start = (""" ######
#0 . #
#.. 1#
###### """)
number_bots = 2
gm = GameMaster(test_start, number_bots, 1)
gm.register_team(SimpleTeam(TestPlayer([(0, 0)])))
gm.register_team(SimpleTeam(TestPlayer([(0, 0)])))
original_universe = gm.universe.copy()
self.test_viewer_did_run = False
test_self = self
class TestViewer(AbstractViewer):
def observe(self_, universe, game_state):
self.test_viewer_did_run = True
# universe should not have been altered
test_self.assertEqual(original_universe, gm.universe)
# there should only be a botmoves event
test_self.assertEqual(len(game_state["bot_moved"]), 1)
test_self.assertEqual(len(game_state["bot_moved"]), 1)
# We need to be able to tell when our subscriber is able to receive
# new events from the publisher.
# Due to its completely asynchronous approach, zmq does not even
# provide built-in methods to check whether two or more sockets
# are connected, so we have to figure a way to find out.
# The approach is as follows: When the publisher starts, it
# sends only ‘sync’ messages without a pause.
# When a subscriber is finally connected, it will receive this message and
# set an instance variable (`has_sync`). The main thread checks whether
# all variables of all subscribers have been set, will stop
# sending ‘sync’ and move on.
# No special thread synchronisation or locking is being used. The current
# code is hopefully simple enough not to include any race conditions.
class SyncedSubscriber(SimpleSubscriber):
def sync(self):
self.has_sync = True
address = "ipc:///tmp/pelita-publisher-%s" % uuid.uuid4()
mean_viewer = SyncedSubscriber(MeanViewer(), address)
test_viewer = SyncedSubscriber(TestViewer(), address)
# must be threads because we try to access shared state
# in the mean_viewer_did_run variable
# (and in a bad way)
mean_viewer_thread = mean_viewer.autoplay_thread()
test_viewer_thread = test_viewer.autoplay_thread()
publisher_viewer = SimplePublisher(address)
viewers = [mean_viewer, test_viewer]
while not all(
getattr(viewer, "has_sync", False) for viewer in viewers):
publisher_viewer.socket.send_json({"__action__": "sync"})
# now we can register it and game_master takes care of sending messages
gm.register_viewer(publisher_viewer)
gm.set_initial()
gm.play()
# exit our threads
publisher_viewer.socket.send_json({
"__action__": "exit",
"__data__": {}
})
# wait until threads stop
mean_viewer_thread.join()
test_viewer_thread.join()
# must close the socket and terminate the context
# else we may get an assertion failure in zmq
publisher_viewer.socket.close()
publisher_viewer.context.term()
self.assertEqual(original_universe, gm.universe)
# check, that the code was actually executed
self.assertTrue(self.mean_viewer_did_run)
self.assertTrue(self.test_viewer_did_run)
def test_play_step(self):
test_start = (""" ########
# 0 ..#
#.. 1 #
######## """)
number_bots = 2
teams = [
SimpleTeam(TestPlayer('>>>>')),
SimpleTeam(TestPlayer('<<<<'))
]
gm = GameMaster(test_start, teams, number_bots, 4)
gm.set_initial()
gm.play_round()
self.assertEqual(gm.universe.bots[0].current_pos, (3, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (4, 2))
self.assertEqual(gm.game_state["round_index"], 0)
self.assertTrue(gm.game_state["bot_id"] is None)
self.assertFalse(gm.game_state["finished"])
gm.play_step()
self.assertEqual(gm.universe.bots[0].current_pos, (4, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (4, 2))
self.assertEqual(gm.game_state["round_index"], 1)
self.assertEqual(gm.game_state["bot_id"], 0)
self.assertEqual(gm.game_state["finished"], False)
gm.play_step()
self.assertEqual(gm.universe.bots[0].current_pos, (4, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (3, 2))
self.assertEqual(gm.game_state["round_index"], 1)
self.assertEqual(gm.game_state["bot_id"], 1)
self.assertEqual(gm.game_state["finished"], False)
gm.play_step()
self.assertEqual(gm.universe.bots[0].current_pos, (5, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (3, 2))
self.assertEqual(gm.game_state["round_index"], 2)
self.assertEqual(gm.game_state["bot_id"], 0)
self.assertEqual(gm.game_state["finished"], False)
gm.play_step()
self.assertEqual(gm.universe.bots[0].current_pos, (5, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (2, 2))
self.assertEqual(gm.game_state["round_index"], 2)
self.assertEqual(gm.game_state["bot_id"], 1)
self.assertEqual(gm.game_state["finished"], False)
gm.play_round()
# first call tries to finish current round (which already is finished)
# so nothing happens
self.assertEqual(gm.universe.bots[0].current_pos, (5, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (2, 2))
self.assertEqual(gm.game_state["round_index"], 2)
self.assertTrue(gm.game_state["bot_id"] is None)
self.assertEqual(gm.game_state["finished"], False)
self.assertEqual(gm.game_state["team_wins"], None)
self.assertEqual(gm.game_state["game_draw"], None)
gm.play_round()
# second call works
self.assertEqual(gm.universe.bots[0].current_pos, (6, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (1, 2))
self.assertEqual(gm.game_state["round_index"], 3)
self.assertTrue(gm.game_state["bot_id"] is None)
self.assertEqual(gm.game_state["finished"], True)
self.assertEqual(gm.game_state["team_wins"], None)
self.assertEqual(gm.game_state["game_draw"], True)
# Game finished because all food was eaten
# team 0 finished first but the round was played regularly to the end
# (hence round_index == 3 and bot_id is None)
# nothing happens anymore
gm.play_round()
self.assertEqual(gm.universe.bots[0].current_pos, (6, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (1, 2))
self.assertEqual(gm.game_state["round_index"], 3)
self.assertTrue(gm.game_state["bot_id"] is None)
self.assertEqual(gm.game_state["finished"], True)
self.assertEqual(gm.game_state["team_wins"], None)
self.assertEqual(gm.game_state["game_draw"], True)
# nothing happens anymore
gm.play_round()
self.assertEqual(gm.universe.bots[0].current_pos, (6, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (1, 2))
self.assertEqual(gm.game_state["round_index"], 3)
self.assertTrue(gm.game_state["bot_id"] is None)
self.assertEqual(gm.game_state["finished"], True)
self.assertEqual(gm.game_state["team_wins"], None)
self.assertEqual(gm.game_state["game_draw"], True)
def test_game(self):
test_start = (""" ######
#0 . #
#.. 1#
###### """)
number_bots = 2
# The problem here is that the layout does not allow us to specify a
# different inital position and current position. When testing universe
# equality by comparing its string representation, this does not matter.
# But if we want to compare using the __eq__ method, but specify the
# target as ascii encoded maze/layout we need to convert the layout to a
# CTFUniverse and then modify the initial positions. For this we define
# a closure here to quickly generate a target universe to compare to.
# Also we adapt the score, in case food has been eaten
def create_TestUniverse(layout, black_score=0, white_score=0):
initial_pos = [(1, 1), (4, 2)]
universe = CTFUniverse.create(layout, number_bots)
universe.teams[0].score = black_score
universe.teams[1].score = white_score
for i, pos in enumerate(initial_pos):
universe.bots[i].initial_pos = pos
if not (1, 2) in universe.food_list:
universe.teams[1].score += 1
if not (2, 2) in universe.food_list:
universe.teams[1].score += 1
if not (3, 1) in universe.food_list:
universe.teams[0].score += 1
return universe
teams = [
SimpleTeam(TestPlayer('>-v>>>')),
SimpleTeam(TestPlayer('<<-<<<'))
]
gm = GameMaster(test_start, teams, number_bots, 200)
gm.set_initial()
gm.play_round()
test_first_round = (""" ######
# 0. #
#..1 #
###### """)
self.assertEqual(create_TestUniverse(test_first_round), gm.universe)
gm.play_round()
test_second_round = (""" ######
# 0. #
#.1 #
###### """)
self.assertEqual(create_TestUniverse(test_second_round), gm.universe)
gm.play_round()
test_third_round = (""" ######
# . #
#.0 1#
###### """)
self.assertEqual(
create_TestUniverse(test_third_round,
black_score=gm.universe.KILLPOINTS),
gm.universe)
gm.play_round()
test_fourth_round = (""" ######
#0 . #
#. 1 #
###### """)
self.assertEqual(
create_TestUniverse(test_fourth_round,
black_score=gm.universe.KILLPOINTS,
white_score=gm.universe.KILLPOINTS),
gm.universe)
gm.play_round()
test_fifth_round = (""" ######
# 0. #
#.1 #
###### """)
self.assertEqual(
create_TestUniverse(test_fifth_round,
black_score=gm.universe.KILLPOINTS,
white_score=gm.universe.KILLPOINTS),
gm.universe)
print(gm.universe.pretty)
gm.play_round()
test_sixth_round = (""" ######
# 0 #
#1 #
###### """)
print(gm.universe.pretty)
self.assertEqual(
create_TestUniverse(test_sixth_round,
black_score=gm.universe.KILLPOINTS,
white_score=gm.universe.KILLPOINTS),
gm.universe)
teams = [
SimpleTeam(TestPlayer('>-v>>>')),
SimpleTeam(TestPlayer('<<-<<<'))
]
# now play the full game
gm = GameMaster(test_start, teams, number_bots, 200)
gm.play()
test_sixth_round = (""" ######
# 0 #
#1 #
###### """)
self.assertEqual(
create_TestUniverse(test_sixth_round,
black_score=gm.universe.KILLPOINTS,
white_score=gm.universe.KILLPOINTS),
gm.universe)
