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_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_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_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)