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 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#
############ """
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
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_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_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_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_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
