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_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_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_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_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_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 gm = GameMaster(test_start, 2, game_time=NUM_ROUNDS) gm.register_team(SimpleTeam(StoppingPlayer())) # bot 1 moves west twice to eat the single food gm.register_team(SimpleTeam(TestPlayer('<<'))) # 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_draw_on_timeout(self): test_start = ( """ ###### #0 . # # . 1# ###### """) # the game lasts one round, and then draws NUM_ROUNDS = 1 gm = GameMaster(test_start, 2, game_time=NUM_ROUNDS) # 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, 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_time_spent(self): outer = self class TimeSpendingPlayer(AbstractPlayer): def get_move(self): time_spent_begin = self.time_spent() sleep_time = 0.1 time.sleep(sleep_time) time_spent_end = self.time_spent() outer.assertTrue(0 <= time_spent_begin < time_spent_end) time_diff = abs(time_spent_begin + sleep_time - time_spent_end) delta = 0.05 outer.assertTrue(time_diff < delta) return stop test_layout = ( """ ############ #0 #. .# 1# ############ """) gm = GameMaster(test_layout, 2, 1) gm.register_team(SimpleTeam(TimeSpendingPlayer())) gm.register_team(SimpleTeam(RandomPlayer())) gm.play()
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_my_player_is_not_moving(self): my_team = SimpleTeam("test", DrunkPlayer(), DrunkPlayer()) test_layout = """ ############ # 0 # # 1 # # # # # # 2 . . 3 # ############ """ gm = GameMaster(test_layout, number_bots=4, game_time=5, seed=20) # register my_team for bots 0, 2 gm.register_team(my_team) # register a pre-defined team as an enemy # First one moves left-down-down-left-left, second one left gm.register_team(SimpleTeam(TestPlayer("<vv<<"), TestPlayer("<<<<<"))) # play `game_time` rounds gm.play() # check the position of my bots # Tests fail, because our player is random # self.assertEqual(gm.universe.bots[0].current_pos, (2, 1)) # self.assertEqual(gm.universe.bots[2].current_pos, (2, 3)) # For reference, testing the test player self.assertEqual(gm.universe.bots[1].current_pos, (6, 3)) self.assertEqual(gm.universe.bots[3].current_pos, (4, 3))
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_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_demo_players(self): test_layout = """ ############ #0#. .# 1# ############ """ gm = GameMaster(test_layout, 2, 1) gm.register_team(SimpleTeam(NQRandomPlayer())) gm.register_team(SimpleTeam(NQRandomPlayer())) gm.play() self.assertEqual(gm.universe.bots[0].current_pos, (1, 1)) self.assertEqual(gm.universe.bots[1].current_pos, (9, 1))
def test_demo_players(self): test_layout = """ ################## #0#. . # . # #2##### #####3# # . # . .#1# ################## """ gm = GameMaster(test_layout, 4, 200) gm.register_team(SimpleTeam(StoppingPlayer(), NQRandomPlayer())) gm.register_team(SimpleTeam(RandomPlayer(), BFSPlayer())) gm.play()
def test_demo_players(self): test_layout = ( """ ############ #0 #. .# 1# ############ """) gm = GameMaster(test_layout, 2, 1) gm.register_team(SimpleTeam(SpeakingPlayer())) gm.register_team(SimpleTeam(RandomPlayer())) gm.play() self.assertTrue(gm.game_state["bot_talk"][0].startswith("Going")) self.assertEqual(gm.game_state["bot_talk"][1], "")
def test_path(self): test_layout = (""" ############ # . # .# ## # ## # # ## #0#. .##1# ############ """) gm = GameMaster(test_layout, 2, 7) gm.register_team(SimpleTeam(NQRandomPlayer())) gm.register_team(SimpleTeam(NQRandomPlayer())) gm.play() self.assertEqual(gm.universe.bots[0].current_pos, (4, 3)) self.assertEqual(gm.universe.bots[1].current_pos, (10, 3))
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# ###### """ ) # the game lasts one round, and then draws gm = GameMaster(test_start, 2, 100, max_timeouts=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") gm.register_team(SimpleTeam(TimeOutPlayer())) gm.register_team(SimpleTeam(CheckTestPlayer())) # 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 self.assertEqual(gm.game_state["max_timeouts"], 1) 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) # the game ends in round 0 with bot_id 0 self.assertEqual(gm.game_state["round_index"], 0) self.assertEqual(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# ###### """ ) # the game lasts one round, and then draws gm = GameMaster(test_start, 2, 100, max_timeouts=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") gm.register_team(SimpleTeam(TimeOutPlayer())) gm.register_team(SimpleTeam(CheckTestPlayer())) # 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 self.assertEqual(gm.game_state["max_timeouts"], 1) 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) # the game ends in round 0 with bot_id 0 self.assertEqual(gm.game_state["round_index"], 0) self.assertEqual(gm.game_state["bot_id"], 0)
def test_too_few_registered_teams(self): test_layout_4 = """ ################## #0#. . # . # #2##### #####1# # . # . .#3# ################## """ game_master = GameMaster(test_layout_4, 4, 200) team_1 = SimpleTeam(TestPlayer([]), TestPlayer([])) game_master.register_team(team_1) self.assertEqual(len(game_master.universe.teams), 2) self.assertRaises(IndexError, game_master.play)
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_too_many_moves(self): test_layout = ( """ ############ #0 . . 1# #2 3# ############ """) gm = GameMaster(test_layout, 4, 3) movements_0 = [east, east] movements_1 = [west, west] gm.register_team(SimpleTeam(TestPlayer(movements_0), TestPlayer(movements_0))) gm.register_team(SimpleTeam(TestPlayer(movements_1), TestPlayer(movements_1))) self.assertRaises(ValueError, gm.play)
def test_path(self): test_layout = ( """ ############ # . # .# ## # ## # # ## #0#. .##1# ############ """) gm = GameMaster(test_layout, 2, 7) gm.register_team(SimpleTeam(NQRandomPlayer())) gm.register_team(SimpleTeam(NQRandomPlayer())) gm.play() self.assertEqual(gm.universe.bots[0].current_pos, (4, 3)) self.assertEqual(gm.universe.bots[1].current_pos, (10, 3))
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_too_few_registered_teams(self): test_layout_4 = ( """ ################## #0#. . # . # #2##### #####1# # . # . .#3# ################## """) game_master = GameMaster(test_layout_4, 4, 200) team_1 = SimpleTeam(TestPlayer([]), TestPlayer([])) game_master.register_team(team_1) self.assertEqual(len(game_master.universe.teams), 2) self.assertRaises(IndexError, game_master.play)
def test_too_many_moves(self): test_layout = (""" ############ #0 . . 1# #2 3# ############ """) gm = GameMaster(test_layout, 4, 3) movements_0 = [east, east] movements_1 = [west, west] gm.register_team( SimpleTeam(TestPlayer(movements_0), TestPlayer(movements_0))) gm.register_team( SimpleTeam(TestPlayer(movements_1), TestPlayer(movements_1))) self.assertRaises(ValueError, gm.play)
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_failing_player(self): class FailingPlayer(AbstractPlayer): def get_move(self): return 1 test_layout = """ ###### #0 . # #.. 1# ###### """ gm = GameMaster(test_layout, 2, 1) gm.register_team(SimpleTeam(FailingPlayer())) gm.register_team(SimpleTeam(TestPlayer("^"))) gm.play() self.assertEqual(gm.game_state["timeout_teams"], [1, 0])
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_failing_player(self): class FailingPlayer(AbstractPlayer): def get_move(self): return 1 test_layout = ( """ ###### #0 . # #.. 1# ###### """) gm = GameMaster(test_layout, 2, 1) gm.register_team(SimpleTeam(FailingPlayer())) gm.register_team(SimpleTeam(TestPlayer("^"))) gm.play() self.assertEqual(gm.game_state["timeout_teams"], [1, 0])
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) # the bot moves four times, so after the fourth time, # it is back on its original position self.assertEqual(gm.universe.bots[0].current_pos, (1,1)) self.assertTrue(tv.cache[-1]["team_wins"] is not None) self.assertEqual(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_rnd(self): outer = self class RndPlayer(AbstractPlayer): def set_initial(self): original_seed = self.current_state["seed"] original_rand = self.rnd.randint(10, 100) outer.assertTrue(10 <= original_rand <= 100) # now check test_rnd = random.Random(original_seed + self._index) outer.assertEqual(test_rnd.randint(10, 100), original_rand) def get_move(self): outer.assertTrue(10 <= self.rnd.randint(10, 100) <= 100) return datamodel.stop class SeedTestingPlayer(AbstractPlayer): def __init__(self): # must be initialised before set_initial is called self.seed_offset = 120 def set_initial(self): original_seed = self.current_state["seed"] original_rand = self.rnd.randint(0, 100) # now check test_rnd = random.Random(original_seed + self.seed_offset) outer.assertEqual(test_rnd.randint(0, 100), original_rand) def get_move(self): outer.assertTrue(10 <= self.rnd.randint(10, 100) <= 100) return datamodel.stop test_layout = ( """ ############ #02#. .#31# ############ """) gm = GameMaster(test_layout, 4, 1) gm.register_team(SimpleTeam(RndPlayer(), SeedTestingPlayer())) gm.register_team(SimpleTeam(SeedTestingPlayer(), RndPlayer())) gm.play()
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_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_viewer_may_change_gm(self): free_obj = Free 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] = free_obj game_state["team_wins"] = 0 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, 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_rnd(self): outer = self class RndPlayer(AbstractPlayer): def set_initial(self): original_seed = self.current_state["seed"] original_rand = self.rnd.randint(10, 100) outer.assertTrue(10 <= original_rand <= 100) # now check test_rnd = random.Random(original_seed + self._index) outer.assertEqual(test_rnd.randint(10, 100), original_rand) def get_move(self): outer.assertTrue(10 <= self.rnd.randint(10, 100) <= 100) return datamodel.stop class SeedTestingPlayer(AbstractPlayer): def __init__(self): # must be initialised before set_initial is called self.seed_offset = 120 def set_initial(self): original_seed = self.current_state["seed"] original_rand = self.rnd.randint(0, 100) # now check test_rnd = random.Random(original_seed + self.seed_offset) outer.assertEqual(test_rnd.randint(0, 100), original_rand) def get_move(self): outer.assertTrue(10 <= self.rnd.randint(10, 100) <= 100) return datamodel.stop test_layout = (""" ############ #02#. .#31# ############ """) gm = GameMaster(test_layout, 4, 1) gm.register_team(SimpleTeam(RndPlayer(), SeedTestingPlayer())) gm.register_team(SimpleTeam(SeedTestingPlayer(), RndPlayer())) gm.play()
def test_malicous_player(self): free_obj = Free 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] = free_obj return {"move": (0,0)} def get_move(self): pass test_layout = ( """ ###### #0 . # #.. 1# ###### """) gm = GameMaster(test_layout, 2, 200) original_universe = gm.universe.copy() test_self = self class TestMaliciousPlayer(AbstractPlayer): def get_move(self): 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) gm.register_team(SimpleTeam(MaliciousPlayer())) gm.register_team(SimpleTeam(TestMaliciousPlayer())) gm.set_initial() gm.play_round() test_self.assertNotEqual(original_universe, gm.universe)
def test_test_players(self): test_layout = (""" ############ #0 . . 1# #2 3# ############ """) gm = GameMaster(test_layout, 4, 2) movements_0 = [east, east] movements_1 = [west, west] gm.register_team( SimpleTeam(TestPlayer(movements_0), TestPlayer(movements_0))) gm.register_team( SimpleTeam(TestPlayer(movements_1), TestPlayer(movements_1))) self.assertEqual(gm.universe.bots[0].current_pos, (1, 1)) self.assertEqual(gm.universe.bots[1].current_pos, (10, 1)) self.assertEqual(gm.universe.bots[2].current_pos, (1, 2)) self.assertEqual(gm.universe.bots[3].current_pos, (10, 2)) gm.play() self.assertEqual(gm.universe.bots[0].current_pos, (3, 1)) self.assertEqual(gm.universe.bots[1].current_pos, (8, 1)) self.assertEqual(gm.universe.bots[2].current_pos, (3, 2)) self.assertEqual(gm.universe.bots[3].current_pos, (8, 2))
def test_my_player_is_not_moving(self): my_team = SimpleTeam("test", MyPlayer(), MyPlayer()) test_layout = """ ############ # 0 # # 1 # # # # # # 2 . . 3 # ############ """ gm = GameMaster(test_layout, number_bots=4, game_time=5, seed=20) # register my_team for bots 0, 2 gm.register_team(my_team) # register a pre-defined team as an enemy gm.register_team(SimpleTeam(RandomPlayer(), RandomPlayer())) # play `game_time` rounds gm.play() # check the position of my bots self.assertEqual(gm.universe.bots[0].current_pos, (2,1)) self.assertEqual(gm.universe.bots[2].current_pos, (2,3))
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 gm = GameMaster(test_start, 2, game_time=NUM_ROUNDS) gm.register_team(SimpleTeam(TestPlayer('>--->'))) # bot 1 moves west twice to eat the single food gm.register_team(SimpleTeam(TestPlayer('<<<<<'))) 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_random_seeds(self): test_layout = (""" ################ # # # # # # # 0 1 # # 2 3 # # # # # #. .# ################ """) gm1 = GameMaster(test_layout, 4, 5, seed=20) players_a = [RandomPlayer() for _ in range(4)] gm1.register_team(SimpleTeam(players_a[0], players_a[2])) gm1.register_team(SimpleTeam(players_a[1], players_a[3])) 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.") gm2 = GameMaster(test_layout, 4, 5, seed=20) players_b = [RandomPlayer() for _ in range(4)] gm2.register_team(SimpleTeam(players_b[0], players_b[2])) gm2.register_team(SimpleTeam(players_b[1], players_b[3])) gm2.set_initial() random_numbers_b = [ player.rnd.randint(0, 10000) for player in players_b ] self.assertEqual(random_numbers_a, random_numbers_b) gm3 = GameMaster(test_layout, 4, 5, seed=200) players_c = [RandomPlayer() for _ in range(4)] gm3.register_team(SimpleTeam(players_c[0], players_c[2])) gm3.register_team(SimpleTeam(players_c[1], players_c[3])) 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_demo_players(self): test_layout = (""" ################ # # # # # # # 0 1 # # # # # # # #. .# ################ """) gm = GameMaster(test_layout, 2, 5, seed=20) gm.register_team(SimpleTeam(RandomPlayer())) gm.register_team(SimpleTeam(RandomPlayer())) self.assertEqual(gm.universe.bots[0].current_pos, (4, 4)) self.assertEqual(gm.universe.bots[1].current_pos, (4 + 7, 4)) gm.play() pos_left_bot = gm.universe.bots[0].current_pos pos_right_bot = gm.universe.bots[1].current_pos # running again to test seed: gm = GameMaster(test_layout, 2, 5, seed=20) gm.register_team(SimpleTeam(RandomPlayer())) gm.register_team(SimpleTeam(RandomPlayer())) gm.play() self.assertEqual(gm.universe.bots[0].current_pos, pos_left_bot) self.assertEqual(gm.universe.bots[1].current_pos, pos_right_bot) # running again with other seed: gm = GameMaster(test_layout, 2, 5, seed=200) gm.register_team(SimpleTeam(RandomPlayer())) gm.register_team(SimpleTeam(RandomPlayer())) gm.play() # most probably, either the left bot or the right bot or both are at # a different position self.assertTrue(gm.universe.bots[0].current_pos != pos_left_bot or gm.universe.bots[1].current_pos != pos_right_bot)
def test_play_step(self): test_start = ( """ ######## # 0 ..# #.. 1 # ######## """) number_bots = 2 gm = GameMaster(test_start, number_bots, 4) gm.register_team(SimpleTeam(TestPlayer('>>>>'))) gm.register_team(SimpleTeam(TestPlayer('<<<<'))) 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)
#!/usr/bin/python from pelita.game_master import GameMaster from pelita.player import SimpleTeam, StoppingPlayer from pelita.viewer import AsciiViewer from pelita.layout import get_random_layout from players import BFSPlayer, BasicDefensePlayer if __name__ == '__main__': name, layout = get_random_layout() gm = GameMaster(layout, 4, 200) gm.register_team(SimpleTeam(BFSPlayer(), BFSPlayer())) gm.register_team(SimpleTeam(BasicDefensePlayer(), BasicDefensePlayer())) gm.register_viewer(AsciiViewer()) gm.play()
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 Food in universe.maze[1, 2]: universe.teams[1]._score_point() if not Food in universe.maze[2, 2]: universe.teams[1]._score_point() if not Food in universe.maze[3, 1]: universe.teams[0]._score_point() return universe gm = GameMaster(test_start, number_bots, 200) gm.register_team(SimpleTeam(TestPlayer('>-v>>>'))) gm.register_team(SimpleTeam(TestPlayer('<<-<<<'))) 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) # now play the full game gm = GameMaster(test_start, number_bots, 200) gm.register_team(SimpleTeam(TestPlayer('>-v>>>'))) gm.register_team(SimpleTeam(TestPlayer('<<-<<<'))) 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)
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)
#!/usr/bin/python from pelita.game_master import GameMaster from pelita.player import StoppingPlayer, SimpleTeam from pelita.viewer import AsciiViewer from players import RandomPlayer, NQRandomPlayer if __name__ == '__main__': layout = (""" ################## #0#. . # . # #2##### #####1# # . # . .#3# ################## """) gm = GameMaster(layout, 4, 200) gm.register_team(SimpleTeam(StoppingPlayer(), NQRandomPlayer())) gm.register_team(SimpleTeam(NQRandomPlayer(), NQRandomPlayer())) gm.register_viewer(AsciiViewer()) gm.play()
def test_convenience(self): test_layout = (""" ################## #0#. . # . # #2##### ####1 # # . # . #3## ################## """) game_master = GameMaster(test_layout, 4, 2, noise=False) universe = game_master.universe player_0 = StoppingPlayer() player_1 = TestPlayer('^<') 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(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.assertEqual(player_0.enemy_food, universe.enemy_food(player_0.team.index)) self.assertEqual(player_1.enemy_food, universe.enemy_food(player_1.team.index)) self.assertEqual(player_2.enemy_food, universe.enemy_food(player_2.team.index)) self.assertEqual(player_3.enemy_food, universe.enemy_food(player_3.team.index)) self.assertEqual(player_0.team_food, universe.team_food(player_0.team.index)) self.assertEqual(player_1.team_food, universe.team_food(player_1.team.index)) self.assertEqual(player_2.team_food, universe.team_food(player_2.team.index)) self.assertEqual(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])
#!/usr/bin/python from pelita.game_master import GameMaster from pelita.player import StoppingPlayer, SimpleTeam from pelita.viewer import AsciiViewer from players import BFSPlayer if __name__ == '__main__': layout = (""" ################## #0#. . # . # # ##### ##### # # . # . .#1# ################## """) gm = GameMaster(layout, 2, 200) gm.register_team(SimpleTeam(BFSPlayer())) gm.register_team(SimpleTeam(StoppingPlayer())) gm.register_viewer(AsciiViewer()) gm.play()