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_my_player_is_not_moving(self): my_team = SimpleTeam("test", DrunkPlayer(), DrunkPlayer()) test_layout = """ ############ # 0 # # 1 # # # # # # 2 . . 3 # ############ """ teams = [ # register my_team for bots 0, 2 my_team, # register a pre-defined team as an enemy # First one moves left-down-down-left-left, second one left SimpleTeam(TestPlayer("<vv<<"), TestPlayer("<<<<<")) ] gm = GameMaster(test_layout, teams, number_bots=4, game_time=5, seed=20) # 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_track(self): def trackingBot(turn, game): bot = game.team[turn] other = game.team[1 - turn] if bot.round == 0 and turn == 0: assert bot.track[0] == bot.position game.state = {} game.state[turn] = {} game.state[1 - turn] = {} game.state[turn]['track'] = [] game.state[1 - turn]['track'] = [] if bot.eaten or not game.state[turn]['track']: game.state[turn]['track'] = [bot.position] if other.eaten or not game.state[1 - turn]['track']: game.state[1 - turn]['track'] = [other.position] else: game.state[1 - turn]['track'].append(other.position) assert bot.track[0] == bot._initial_position assert bot.track == game.state[turn][ 'track'] # bot.round * 2 + 1 + turn assert bot.track[-1] == bot.position return randomBot(turn, game) layout = """ ############ ##02 .3 1# ############ #.# #.# ############ """ team = [Team(trackingBot), Team(trackingBot)] gm = GameMaster(layout, team, 4, 300) gm.play()
def test_my_player_is_not_moving(self): my_team = SimpleTeam("test", MyPlayer(), MyPlayer()) test_layout = """ ############ # 0 # # 1 # # # # # # 2 . . 3 # ############ """ teams = [ # register my_team for bots 0, 2 my_team, # register a pre-defined team as an enemy SimpleTeam(RandomPlayer(), RandomPlayer()) ] gm = GameMaster(test_layout, teams, number_bots=4, game_time=5, seed=20) # 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_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_before_seek_food(self): my_team = SimpleTeam("test", EaterPlayer(), EaterPlayer()) test_layout = """ ############## #.23 . # #### ## . # # 0. .# # 1 ##.. # ############## """ teams = [ # register my_team for bots 0, 2 my_team, # for now enemies don't move SimpleTeam(TestPlayer(3*'>'), TestPlayer(3*'<')) ] gm = GameMaster(test_layout, teams, number_bots=4, game_time=1, seed=20) # play `game_time` rounds gm.play() # test if both players killed enemy instead of seeking food self.assertEqual(gm.universe.bots[0].current_pos, (3, 4)) self.assertEqual(gm.universe.bots[2].current_pos, (3, 1)) self.assertEqual(gm.universe.teams[0].score, 10)
def test_time_spent(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() assert 0 <= time_spent_begin < time_spent_end time_diff = abs(time_spent_begin + sleep_time - time_spent_end) delta = 0.05 assert time_diff < delta return stop test_layout = ( """ ############ #0 #. .# 1# ############ """) team = [ SimpleTeam(TimeSpendingPlayer()), SimpleTeam(RandomPlayer()) ] gm = GameMaster(test_layout, team, 2, 1) gm.play()
def test_common_target(self): my_team = SimpleTeam("test", HunterPlayer(), HunterPlayer()) test_layout = ''' #################### # 1 0 .# #### ### # # . 2 # # 3 ## #################### ''' teams = [ # register my_team for bots 0, 2 my_team, # for now enemies don't move SimpleTeam(TestPlayer('<<<'), TestPlayer('<<<')) ] gm = GameMaster(test_layout, teams, number_bots=4, game_time=3, seed=20) # play `game_time` rounds gm.play() #pdb.set_trace() # test if both players seeked the food self.assertEqual(gm.universe.bots[0].current_pos, (7, 1)) self.assertEqual(gm.universe.bots[2].current_pos, (4, 2))
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_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_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# ############ """) team = [SimpleTeam(TimeSpendingPlayer()), SimpleTeam(RandomPlayer())] gm = GameMaster(test_layout, team, 2, 1) gm.play()
def test_round_based_players(self): test_layout = (""" ############ #0 . . 1# #2 3# ############ """) movements_0 = [east, east] movements_1_0 = {0: west, 2: west} movements_1_1 = {2: west} teams = [ SimpleTeam(RoundBasedPlayer(movements_0), RoundBasedPlayer(movements_0)), SimpleTeam(RoundBasedPlayer(movements_1_0), RoundBasedPlayer(movements_1_1)) ] gm = GameMaster(test_layout, teams, 4, 3) 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, (9, 2))
def test_my_player_is_not_moving(): my_team = SimpleTeam("test", KangarooPlayer(), KangarooPlayer()) test_layout = """ ############ # 0 # # 1 # # # # # # 2 . . 3 # ############ """ teams = [ # register my_team for bots 0, 2 my_team, # register a pre-defined team as an enemy # First one moves left-down-down-left-left, second one left SimpleTeam(SteppingPlayer("<vv<<"), SteppingPlayer("<<<<<")) ] gm = GameMaster(test_layout, teams, number_bots=4, game_time=5, seed=20) # play `game_time` rounds gm.play() # check the position of my bots # Tests fail, because our player is random # assert gm.universe.bots[0].current_pos == (2, 1) # assert gm.universe.bots[2].current_pos == (2, 3) # For reference, testing the test player assert gm.universe.bots[1].current_pos == (6, 3) assert 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 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_round_based_players(self): test_layout = ( """ ############ #0 . . 1# #2 3# ############ """) movements_0 = [east, east] movements_1_0 = {0: west, 2: west} movements_1_1 = {2: west} teams = [ SimpleTeam(RoundBasedPlayer(movements_0), RoundBasedPlayer(movements_0)), SimpleTeam(RoundBasedPlayer(movements_1_0), RoundBasedPlayer(movements_1_1)) ] gm = GameMaster(test_layout, teams, 4, 3) assert gm.universe.bots[0].current_pos == (1, 1) assert gm.universe.bots[1].current_pos == (10, 1) assert gm.universe.bots[2].current_pos == (1, 2) assert gm.universe.bots[3].current_pos == (10, 2) gm.play() assert gm.universe.bots[0].current_pos == (3, 1) assert gm.universe.bots[1].current_pos == (8, 1) assert gm.universe.bots[2].current_pos == (3, 2) assert gm.universe.bots[3].current_pos == (9, 2)
def run_game(): layout = LAYOUT teams = [ SimpleTeam(StoppingPlayer(), StoppingPlayer()), SimpleTeam(StoppingPlayer(), StoppingPlayer()) ] gm = GameMaster(layout, teams, 4, 10) #gm.register_viewer(AsciiViewer()) gm.play()
def test_too_few_bots(self): test_layout = (""" ############ #0#. .# 1# ############ """) team = [Team(stopping), Team(stopping)] gm = GameMaster(test_layout, team, 2, 1) with pytest.raises(IndexError): gm.play()
def test_demo_players(self): test_layout = (""" ############ #0 #. .# 1# ############ """) team = [SimpleTeam(SpeakingPlayer()), SimpleTeam(RandomPlayer())] gm = GameMaster(test_layout, team, 2, 1) gm.play() self.assertTrue(gm.game_state["bot_talk"][0].startswith("Going")) self.assertEqual(gm.game_state["bot_talk"][1], "")
def test_demo_players(self): test_layout = (""" ############ #0#. .# 1# ############ """) team = [SimpleTeam(NQRandomPlayer()), SimpleTeam(NQRandomPlayer())] gm = GameMaster(test_layout, team, 2, 1) 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#. .# 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_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_path(self): test_layout = (""" ############ # . # .# ## # ## # # ## #0#. .##1# ############ """) team = [SimpleTeam(NQRandomPlayer()), SimpleTeam(NQRandomPlayer())] gm = GameMaster(test_layout, team, 2, 7) gm.play() self.assertEqual(gm.universe.bots[0].current_pos, (4, 3)) self.assertEqual(gm.universe.bots[1].current_pos, (10, 3))
def test_demo_players(self): test_layout = ( """ ############ #0#. .# 1# ############ """) team = [ SimpleTeam(NQRandomPlayer()), SimpleTeam(NQRandomPlayer()) ] gm = GameMaster(test_layout, team, 2, 1) gm.play() assert gm.universe.bots[0].current_pos == (1, 1) assert gm.universe.bots[1].current_pos == (9, 1)
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_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_demo_players(self): test_layout = ( """ ############ #0 #. .# 1# ############ """) team = [ SimpleTeam(SpeakingPlayer()), SimpleTeam(RandomPlayer()) ] gm = GameMaster(test_layout, team, 2, 1) gm.play() assert gm.game_state["bot_talk"][0].startswith("Going") assert gm.game_state["bot_talk"][1] == ""
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_too_few_bots(self): test_layout = ( """ ############ #0#. .# 1# ############ """) team = [ Team(stopping), Team(stopping) ] gm = GameMaster(test_layout, team, 2, 1) with pytest.raises(IndexError): gm.play()
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_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_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_path(self): test_layout = ( """ ############ # . # .# ## # ## # # ## #0#. .##1# ############ """) team = [ SimpleTeam(NQRandomPlayer()), SimpleTeam(NQRandomPlayer()) ] gm = GameMaster(test_layout, team, 2, 7) gm.play() assert gm.universe.bots[0].current_pos == (4, 3) assert gm.universe.bots[1].current_pos == (10, 3)
def test_failing_player(self): class FailingPlayer(AbstractPlayer): def get_move(self): return 1 test_layout = (""" ###### #0 . # #.. 1# ###### """) teams = [SimpleTeam(FailingPlayer()), SimpleTeam(TestPlayer("^"))] gm = GameMaster(test_layout, teams, 2, 1) gm.play() self.assertEqual(gm.game_state["timeout_teams"], [1, 0])
def test_players(self): test_layout = (""" ############ # . # . ## # ## # ## # ## # # ## # ## # # ## # # # ## #0#. . 1# ############ """) for player in SANE_PLAYERS: team = [SimpleTeam(player()), SimpleTeam(NQRandomPlayer())] gm = GameMaster(test_layout, team, 2, 20) gm.play() assert gm.finished is True
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_failing_player(self): class FailingPlayer(AbstractPlayer): def get_move(self): return 1 test_layout = ( """ ###### #0 . # #.. 1# ###### """) teams = [SimpleTeam(FailingPlayer()), SimpleTeam(SteppingPlayer("^"))] gm = GameMaster(test_layout, teams, 2, 1) gm.play() assert gm.game_state["timeout_teams"] == [1, 0]
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_too_many_moves(self): test_layout = ( """ ############ #0 . . 1# #2 3# ############ """) movements_0 = [east, east] movements_1 = [west, west] teams = [ SimpleTeam(TestPlayer(movements_0), TestPlayer(movements_0)), SimpleTeam(TestPlayer(movements_1), TestPlayer(movements_1)) ] gm = GameMaster(test_layout, teams, 4, 3) with pytest.raises(ValueError): gm.play()
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_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_panic_insight_up(self): test_layout = """ ########## # 0 # # # # 3.# #. 2 1..# ########## """ teams = [ SimpleTeam(Player(), Player()), # my_team for bots 0, 2 SimpleTeam(TestPlayer("-"), TestPlayer("-")) # enemy ] gm = GameMaster(test_layout, teams, number_bots=4, game_time=1, seed=30) gm.play() # check he runs away self.assertNotEqual(gm.universe.bots[0].current_pos, (7, 2))
def test_easy_kill_left(self): test_layout = """ ########## # 3# #10 # # .# #. 2 ..# ########## """ teams = [ SimpleTeam(Player(), Player()), # my_team for bots 0, 2 SimpleTeam(TestPlayer("-"), TestPlayer("-")) # enemy ] gm = GameMaster(test_layout, teams, number_bots=4, game_time=1, seed=30) gm.play() # check that it killed it self.assertEqual(gm.universe.bots[0].current_pos, (1, 2))
def test_no_food(self): team_1 = SimpleTeam(SteppingPlayer([]), SteppingPlayer([])) team_2 = SimpleTeam(SteppingPlayer([]), SteppingPlayer([])) both_starving_layout = (""" ###### #0 # # 1# ###### """) with pytest.warns(NoFoodWarning): GameMaster(both_starving_layout, [team_1, team_2], 2, 1) one_side_starving_layout = (""" ###### #0 .# # 1# ###### """) with pytest.warns(NoFoodWarning): GameMaster(one_side_starving_layout, [team_1, team_2], 2, 1)
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_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_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_too_few_registered_teams(self): test_layout_4 = (""" ################## #0#. . # . # #2##### #####1# # . # . .#3# ################## """) team_1 = SimpleTeam(SteppingPlayer([]), SteppingPlayer([])) with pytest.raises(ValueError): GameMaster(test_layout_4, [team_1], 4, 200)
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# ############ """) teams = [ SimpleTeam(RndPlayer(), SeedTestingPlayer()), SimpleTeam(SeedTestingPlayer(), RndPlayer()) ] gm = GameMaster(test_layout, teams, 4, 1) gm.play()
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_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_too_many_moves(self): test_layout = (""" ############ #0 . . 1# #2 3# ############ """) movements_0 = [east, east] movements_1 = [west, west] teams = [ SimpleTeam(TestPlayer(movements_0), TestPlayer(movements_0)), SimpleTeam(TestPlayer(movements_1), TestPlayer(movements_1)) ] gm = GameMaster(test_layout, teams, 4, 3) self.assertRaises(ValueError, gm.play)
def test_test_players(self): test_layout = (""" ############ #0 . . 1# #2 3# ############ """) movements_0 = [east, east] movements_1 = [west, west] teams = [ SimpleTeam(TestPlayer(movements_0), TestPlayer(movements_0)), SimpleTeam(TestPlayer(movements_1), TestPlayer(movements_1)) ] gm = GameMaster(test_layout, teams, 4, 2) 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_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