def test_demo_players(self):
test_layout = (""" ################
# #
# #
# #
# 0 1 #
# #
# #
# #
#. .#
################ """)
teams = [SimpleTeam(RandomPlayer()), SimpleTeam(RandomPlayer())]
gm = GameMaster(test_layout, teams, 2, 5, seed=20)
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:
teams = [SimpleTeam(RandomPlayer()), SimpleTeam(RandomPlayer())]
gm = GameMaster(test_layout, teams, 2, 5, seed=20)
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:
teams = [SimpleTeam(RandomPlayer()), SimpleTeam(RandomPlayer())]
gm = GameMaster(test_layout, teams, 2, 5, seed=200)
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_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_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#
################## """)
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#
###### """)
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
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_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_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_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_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_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_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_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_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_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_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_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#
################## """)
team_1 = SimpleTeam(SteppingPlayer([]), SteppingPlayer([]))
with pytest.raises(ValueError):
GameMaster(test_layout_4, [team_1], 4, 200)
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_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_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_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_stopping(self):
test_layout = (""" ############
#0#.23 .# 1#
############ """)
round_counting = self.round_counting()
team = [Team(stopping), Team(round_counting)]
gm = GameMaster(test_layout, team, 4, 1)
gm.play()
assert gm.universe.bots[0].current_pos == (1, 1)
assert gm.universe.bots[1].current_pos == (10, 1)
assert round_counting._storage['rounds'] == 1
round_counting = self.round_counting()
team = [Team(stopping), Team(round_counting)]
gm = GameMaster(test_layout, team, 4, 3)
gm.play()
assert gm.universe.bots[0].current_pos == (1, 1)
assert gm.universe.bots[1].current_pos == (10, 1)
assert round_counting._storage['rounds'] == 3
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#
############ """)
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_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_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', 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_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_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
