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_kill_count(self):
test_start = (""" ######
#0 1#
#....#
###### """)
# the game lasts two rounds, enough time for bot 1 to eat food
NUM_ROUNDS = 5
teams = [
SimpleTeam(SteppingPlayer('>--->')),
SimpleTeam(SteppingPlayer(
'<<<<<')) # bot 1 moves west twice to eat the single food
]
gm = GameMaster(test_start, teams, 2, game_time=NUM_ROUNDS)
gm.set_initial()
gm.play_round()
assert gm.game_state["times_killed"] == [0, 0]
gm.play_round()
assert gm.game_state["times_killed"] == [0, 1]
gm.play_round()
assert gm.game_state["times_killed"] == [0, 1]
gm.play_round()
assert gm.game_state["times_killed"] == [0, 2]
gm.play_round()
assert gm.game_state["times_killed"] == [1, 2]
def test_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_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_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_simple_failing_bots(self):
layout = """
##########
# #
#0 .. 1#
##########
"""
server = SimpleServer(layout_string=layout, rounds=5, players=2)
for bind_address in server.bind_addresses:
assert bind_address.startswith("tcp://")
client1_address = server.bind_addresses[0].replace("*", "localhost")
client2_address = server.bind_addresses[1].replace("*", "localhost")
class FailingPlayer:
def _set_initial(self, dummy, dummy2):
pass
def _set_index(self, dummy):
pass
def _get_move(self, universe, game_state):
pass
client1 = SimpleClient(SimpleTeam("team1", SteppingPlayer("^>>v<")),
address=client1_address)
client2 = SimpleClient(SimpleTeam("team2", FailingPlayer()),
address=client2_address)
client1.autoplay_process()
client2.autoplay_process()
server.run()
server.shutdown()
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_win_on_timeout_team_1(self):
test_start = (""" ######
#0 ..#
#.. 1#
###### """)
# the game lasts two rounds, enough time for bot 1 to eat food
NUM_ROUNDS = 2
teams = [
SimpleTeam(StoppingPlayer()),
SimpleTeam(SteppingPlayer(
'<<')) # bot 1 moves west twice to eat the single food
]
gm = GameMaster(test_start, teams, 2, game_time=NUM_ROUNDS)
# this test viewer caches all events lists seen through observe
class TestViewer(AbstractViewer):
def __init__(self):
self.cache = list()
def observe(self, universe, game_state):
self.cache.append(game_state)
# run the game
tv = TestViewer()
gm.register_viewer(tv)
gm.set_initial()
gm.play()
# check
assert tv.cache[-1]["team_wins"] is not None
assert tv.cache[-1]["team_wins"] == 1
assert gm.game_state["round_index"] == NUM_ROUNDS
def test_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_viewer_may_change_gm(self):
class MeanViewer(AbstractViewer):
def set_initial(self, universe):
universe.teams[1].score = 50
def observe(self, universe, game_state):
universe.teams[0].score = 100
universe.bots[0].current_pos = (4,2)
universe.maze[0,0] = False
game_state["team_wins"] = 0
test_start = (
""" ######
#0 . #
#.. 1#
###### """)
number_bots = 2
teams = [
SimpleTeam(SteppingPlayer([(0,0)])),
SimpleTeam(SteppingPlayer([(0,0)]))
]
gm = GameMaster(test_start, teams, number_bots, 200)
original_universe = gm.universe.copy()
class TestViewer(AbstractViewer):
def observe(self, universe, game_state):
# universe has been altered
assert original_universe != gm.universe
gm.register_viewer(MeanViewer())
gm.register_viewer(TestViewer())
gm.set_initial()
gm.play_round()
assert original_universe != gm.universe
def test_simple_remote_game(self):
layout = """
##########
# #
#0 .. 1#
##########
"""
server = SimpleServer(layout_string=layout, rounds=5, players=2)
for bind_address in server.bind_addresses:
assert bind_address.startswith("tcp://")
client1_address = server.bind_addresses[0].replace("*", "localhost")
client2_address = server.bind_addresses[1].replace("*", "localhost")
client1 = SimpleClient(SimpleTeam("team1", SteppingPlayer("^>>v<")),
address=client1_address)
client2 = SimpleClient(SimpleTeam("team2", SteppingPlayer("^<<v>")),
address=client2_address)
client1.autoplay_process()
client2.autoplay_process()
server.run()
server.shutdown()
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_play_step(self):
test_start = (""" ########
# 0 ..#
#.. 1 #
######## """)
number_bots = 2
teams = [
SimpleTeam(SteppingPlayer('>>>>')),
SimpleTeam(SteppingPlayer('<<<<'))
]
gm = GameMaster(test_start, teams, number_bots, 4)
gm.set_initial()
gm.play_round()
assert gm.universe.bots[0].current_pos == (3, 1)
assert gm.universe.bots[1].current_pos == (4, 2)
assert gm.game_state["round_index"] == 0
assert gm.game_state["bot_id"] is None
assert not gm.game_state["finished"]
gm.play_step()
assert gm.universe.bots[0].current_pos == (4, 1)
assert gm.universe.bots[1].current_pos == (4, 2)
assert gm.game_state["round_index"] == 1
assert gm.game_state["bot_id"] == 0
assert gm.game_state["finished"] == False
gm.play_step()
assert gm.universe.bots[0].current_pos == (4, 1)
assert gm.universe.bots[1].current_pos == (3, 2)
assert gm.game_state["round_index"] == 1
assert gm.game_state["bot_id"] == 1
assert gm.game_state["finished"] == False
gm.play_step()
assert gm.universe.bots[0].current_pos == (5, 1)
assert gm.universe.bots[1].current_pos == (3, 2)
assert gm.game_state["round_index"] == 2
assert gm.game_state["bot_id"] == 0
assert gm.game_state["finished"] == False
gm.play_step()
assert gm.universe.bots[0].current_pos == (5, 1)
assert gm.universe.bots[1].current_pos == (2, 2)
assert gm.game_state["round_index"] == 2
assert gm.game_state["bot_id"] == 1
assert gm.game_state["finished"] == False
gm.play_round()
# first call tries to finish current round (which already is finished)
# so nothing happens
assert gm.universe.bots[0].current_pos == (5, 1)
assert gm.universe.bots[1].current_pos == (2, 2)
assert gm.game_state["round_index"] == 2
assert gm.game_state["bot_id"] is None
assert gm.game_state["finished"] == False
assert gm.game_state["team_wins"] == None
assert gm.game_state["game_draw"] == None
gm.play_round()
# second call works
assert gm.universe.bots[0].current_pos == (6, 1)
assert gm.universe.bots[1].current_pos == (2, 2)
assert gm.game_state["round_index"] == 3
assert gm.game_state["bot_id"] == 0
assert gm.game_state["finished"] == True
assert gm.game_state["team_wins"] == 0
assert gm.game_state["game_draw"] == None
# Game finished immediately once all food for one group was eaten
# team 0 finished first and the round was NOT played regularly to the end
# (hence round_index == 3 and bot_id == 0)
# nothing happens anymore
gm.play_round()
assert gm.universe.bots[0].current_pos == (6, 1)
assert gm.universe.bots[1].current_pos == (2, 2)
assert gm.game_state["round_index"] == 3
assert gm.game_state["bot_id"] == 0
assert gm.game_state["finished"] == True
assert gm.game_state["team_wins"] == 0
assert gm.game_state["game_draw"] == None
# nothing happens anymore
gm.play_round()
assert gm.universe.bots[0].current_pos == (6, 1)
assert gm.universe.bots[1].current_pos == (2, 2)
assert gm.game_state["round_index"] == 3
assert gm.game_state["bot_id"] == 0
assert gm.game_state["finished"] == True
assert gm.game_state["team_wins"] == 0
assert gm.game_state["game_draw"] == None
def test_game(self):
test_start = (""" ######
#0 . #
#.. 1#
###### """)
number_bots = 2
# The problem here is that the layout does not allow us to specify a
# different inital position and current position. When testing universe
# equality by comparing its string representation, this does not matter.
# But if we want to compare using the __eq__ method, but specify the
# target as ascii encoded maze/layout we need to convert the layout to a
# CTFUniverse and then modify the initial positions. For this we define
# a closure here to quickly generate a target universe to compare to.
# Also we adapt the score, in case food has been eaten
def create_TestUniverse(layout, black_score=0, white_score=0):
initial_pos = [(1, 1), (4, 2)]
universe = CTFUniverse.create(layout, number_bots)
universe.teams[0].score = black_score
universe.teams[1].score = white_score
for i, pos in enumerate(initial_pos):
universe.bots[i].initial_pos = pos
if not (1, 2) in universe.food_list:
universe.teams[1].score += 1
if not (2, 2) in universe.food_list:
universe.teams[1].score += 1
if not (3, 1) in universe.food_list:
universe.teams[0].score += 1
return universe
teams = [
SimpleTeam(SteppingPlayer('>-v>>>')),
SimpleTeam(SteppingPlayer('<<-<<<'))
]
gm = GameMaster(test_start, teams, number_bots, 200)
gm.set_initial()
gm.play_round()
test_first_round = (""" ######
# 0. #
#..1 #
###### """)
assert create_TestUniverse(test_first_round) == gm.universe
gm.play_round()
test_second_round = (""" ######
# 0. #
#.1 #
###### """)
assert create_TestUniverse(test_second_round) == gm.universe
gm.play_round()
test_third_round = (""" ######
# . #
#.0 1#
###### """)
assert create_TestUniverse(
test_third_round,
black_score=gm.universe.KILLPOINTS) == gm.universe
gm.play_round()
test_fourth_round = (""" ######
#0 . #
#. 1 #
###### """)
assert 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 #
###### """)
assert 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)
# The game will have finished after bot 0 has eaten the pellet
assert create_TestUniverse(
test_sixth_round,
black_score=gm.universe.KILLPOINTS,
white_score=gm.universe.KILLPOINTS) == gm.universe
assert gm.game_state['finished'] is True
teams = [
SimpleTeam(SteppingPlayer('>-v>>>')),
SimpleTeam(SteppingPlayer('<<-<<<'))
]
# now play the full game
gm = GameMaster(test_start, teams, number_bots, 200)
gm.play()
test_sixth_round = (""" ######
# 0 #
#.1 #
###### """)
assert create_TestUniverse(
test_sixth_round,
black_score=gm.universe.KILLPOINTS,
white_score=gm.universe.KILLPOINTS) == gm.universe
