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_convenience(self):
test_layout = (
""" ##################
#0#. . # . #
#2##### #####1#
# . # . .#3#
################## """)
game_master = GameMaster(test_layout, 4, 200, noise=False)
universe = game_master.universe
player_0 = StoppingPlayer()
player_1 = TestPlayer([stop, north])
player_2 = StoppingPlayer()
player_3 = StoppingPlayer()
game_master.register_team(SimpleTeam(player_0, player_2))
game_master.register_team(SimpleTeam(player_1, player_3))
game_master.set_initial()
self.assertEqual(universe.bots[0], player_0.me)
self.assertEqual(universe.bots[1], player_1.me)
self.assertEqual(universe.bots[2], player_2.me)
self.assertEqual(universe.bots[3], player_3.me)
self.assertEqual(universe, player_1.current_uni)
self.assertEqual([universe.bots[0]], player_2.other_team_bots)
self.assertEqual([universe.bots[1]], player_3.other_team_bots)
self.assertEqual([universe.bots[2]], player_0.other_team_bots)
self.assertEqual([universe.bots[3]], player_1.other_team_bots)
self.assertEqual([universe.bots[i] for i in (0, 2)], player_0.team_bots)
self.assertEqual([universe.bots[i] for i in (1, 3)], player_0.enemy_bots)
self.assertEqual([universe.bots[i] for i in (1, 3)], player_1.team_bots)
self.assertEqual([universe.bots[i] for i in (0, 2)], player_1.enemy_bots)
self.assertEqual([universe.bots[i] for i in (0, 2)], player_2.team_bots)
self.assertEqual([universe.bots[i] for i in (1, 3)], player_2.enemy_bots)
self.assertEqual([universe.bots[i] for i in (1, 3)], player_3.team_bots)
self.assertEqual([universe.bots[i] for i in (0, 2)], player_3.enemy_bots)
self.assertEqual(universe.bots[1].current_pos, player_1.current_pos)
self.assertEqual(universe.bots[1].initial_pos, player_1.initial_pos)
self.assertEqual(universe.teams[0], player_0.team)
self.assertEqual(universe.teams[0], player_2.team)
self.assertEqual(universe.teams[1], player_1.team)
self.assertEqual(universe.teams[1], player_3.team)
self.assertEqual({(0, 1): (1, 2), (0, 0): (1, 1)},
player_0.legal_moves)
self.assertEqual({(0, 1): (16, 3), (0, -1): (16, 1), (0, 0): (16, 2)},
player_1.legal_moves)
self.assertEqual({(0, 1): (1, 3), (0, -1): (1, 1), (0, 0): (1, 2)},
player_2.legal_moves)
self.assertEqual({(0, -1): (16, 2), (0, 0): (16, 3)},
player_3.legal_moves)
game_master.play_round(0)
game_master.play_round(1)
self.assertEqual(universe, player_1.current_uni)
self.assertEqual((16, 1), player_1.current_pos)
self.assertEqual((16, 2), player_1.previous_pos)
self.assertNotEqual(player_1.current_uni, player_1.universe_states[-2])
def test_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_adjacency_bfs(self):
test_layout = (
""" ##################
#0#. . # . #
# ##### ##### #
# . # . .#1#
################## """)
game_master = GameMaster(test_layout, 2, 200)
bfs = BFSPlayer()
stopping = StoppingPlayer()
game_master.register_team(SimpleTeam(bfs))
game_master.register_team(SimpleTeam(stopping))
game_master.set_initial()
path_target = [(11, 3), (10, 3), (10, 2), (9, 2), (8, 2), (7, 2), (7,
3), (6, 3), (5, 3), (4, 3), (3, 3), (2, 3), (1, 3), (1,2)]
self.assertEqual(path_target, bfs.current_path)
for i in range(len(path_target)):
path_target.pop()
game_master.play_round()
self.assertEqual(path_target, bfs.current_path)
game_master.play_round()
self.assertEqual([(14, 3), (13, 3)], bfs.current_path)
game_master.play_round()
self.assertEqual([(14, 3)], bfs.current_path)
game_master.play_round()
self.assertEqual([], bfs.current_path)
def test_unreachable(self):
test_layout = """ ############
#0. #.1#
############ """
game_master = GameMaster(test_layout, 2, 200)
bfs1 = BFSPlayer()
bfs2 = BFSPlayer()
game_master.register_team(SimpleTeam(bfs1))
game_master.register_team(SimpleTeam(bfs2))
game_master.set_initial()
game_master.play_round(0)
self.assertEqual(0, len(bfs1.current_path))
self.assertEqual(0, len(bfs2.current_path))
def test_viewer_must_not_change_gm(self):
free_obj = Free()
class MeanViewer(AbstractViewer):
def set_initial(self, universe):
universe.teams[1].score = 50
def observe(self, round_, turn, universe, events):
universe.teams[0].score = 100
universe.bots[0].current_pos = (4,4)
universe.maze[0,0][0] = free_obj
events.append(TeamWins(0))
test_self.assertEqual(len(events), 2)
test_start = (
""" ######
#0 . #
#.. 1#
###### """)
number_bots = 2
gm = GameMaster(test_start, number_bots, 200)
gm.register_team(SimpleTeam(TestPlayer([(0,0)])))
gm.register_team(SimpleTeam(TestPlayer([(0,0)])))
original_universe = gm.universe.copy()
test_self = self
class TestViewer(AbstractViewer):
def observe(self, round_, turn, universe, events):
# universe should not have been altered
test_self.assertEqual(original_universe, gm.universe)
# there should only be a botmoves event
test_self.assertEqual(len(events), 1)
test_self.assertEqual(len(events), 1)
test_self.assertTrue(BotMoves in events)
gm.register_viewer(MeanViewer())
gm.register_viewer(TestViewer())
gm.set_initial()
gm.play_round(0)
self.assertEqual(original_universe, gm.universe)
def test_tracking(self):
test_layout = (
"""################
# 1#
#. 0 .#
#. 2 .#
# # # 3#
################ """)
game_master = GameMaster(test_layout, 4, 5, noise=False)
team_1 = SimpleTeam(TestPlayer('><---'),
TestPlayer('-><>-'))
team_2 = SimpleTeam(BasicDefensePlayer(), BasicDefensePlayer())
game_master.register_team(team_1)
game_master.register_team(team_2)
game_master.set_initial()
game_master.play_round()
# 0 moved east, 1 tracks 0
# 2 did not move, 3 tracks 0
self.assertEqual(team_2._players[0].tracking_idx, 0)
self.assertEqual(team_2._players[1].tracking_idx, 0)
game_master.play_round()
# 0 moved back, 1 tracks None
# 2 moved east, 3 tracks 2
self.assertEqual(team_2._players[0].tracking_idx, None)
self.assertEqual(team_2._players[1].tracking_idx, 2)
game_master.play_round()
# 0 did not move, 1 tracks 2
# 2 moved back, 3 tracks None
self.assertEqual(team_2._players[0].tracking_idx, 2)
self.assertEqual(team_2._players[1].tracking_idx, None)
game_master.play_round()
# 0 did not move, 1 tracks None
# 2 moved east, 3 tracks 2
self.assertEqual(team_2._players[0].tracking_idx, None)
self.assertEqual(team_2._players[1].tracking_idx, 2)
game_master.play_round()
# 0 did not move, 1 tracks 2
# 2 did not move, 3 still tracks 2
self.assertEqual(team_2._players[0].tracking_idx, 2)
self.assertEqual(team_2._players[1].tracking_idx, 2)
def test_shorthand(self):
test_layout = (""" ############
#0 . . #
# 1#
############ """)
num_rounds = 5
gm = GameMaster(test_layout, 2, num_rounds)
gm.register_team(SimpleTeam(TestPlayer('>v<^-)')))
gm.register_team(SimpleTeam(TestPlayer('<^>v-)')))
player0_expected_positions = [(1, 1), (2, 1), (2, 2), (1, 2), (1, 1)]
player1_expected_positions = [(10, 2), (9, 2), (9, 1), (10, 1),
(10, 2)]
gm.set_initial()
for i in range(num_rounds):
self.assertEqual(gm.universe.bots[0].current_pos,
player0_expected_positions[i])
self.assertEqual(gm.universe.bots[1].current_pos,
player1_expected_positions[i])
gm.play_round()
def test_shorthand(self):
test_layout = (
""" ############
#0 . . #
# 1#
############ """)
num_rounds = 5
gm = GameMaster(test_layout, 2, num_rounds)
gm.register_team(SimpleTeam(TestPlayer('>v<^-)')))
gm.register_team(SimpleTeam(TestPlayer('<^>v-)')))
player0_expected_positions = [(1,1), (2,1), (2,2), (1,2), (1,1)]
player1_expected_positions = [(10,2), (9,2), (9,1), (10,1), (10,2)]
gm.set_initial()
for i in range(num_rounds):
self.assertEqual(gm.universe.bots[0].current_pos,
player0_expected_positions[i])
self.assertEqual(gm.universe.bots[1].current_pos,
player1_expected_positions[i])
gm.play_round()
def test_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(TestPlayer([(0,0)])),
SimpleTeam(TestPlayer([(0,0)]))
]
gm = GameMaster(test_start, teams, number_bots, 200)
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_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(TestPlayer([(0, 0)])),
SimpleTeam(TestPlayer([(0, 0)]))
]
gm = GameMaster(test_start, teams, number_bots, 200)
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):
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] = False
return {"move": (0,0)}
def get_move(self):
pass
test_layout = (
""" ######
#0 . #
#.. 1#
###### """)
test_self = self
original_universe = None
class TestMaliciousPlayer(AbstractPlayer):
def get_move(self):
test_self.assertIsNotNone(original_universe)
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)
teams = [
SimpleTeam(MaliciousPlayer()),
SimpleTeam(TestMaliciousPlayer())
]
gm = GameMaster(test_layout, teams, 2, 200)
original_universe = gm.universe.copy()
gm.set_initial()
gm.play_round()
test_self.assertNotEqual(original_universe, gm.universe)
def test_shorthand(self):
test_layout = (
""" ############
#0 . . #
# 1#
############ """)
num_rounds = 5
teams = [
SimpleTeam(TestPlayer('>v<^-)')),
SimpleTeam(TestPlayer('<^>v-)'))
]
gm = GameMaster(test_layout, teams, 2, num_rounds)
player0_expected_positions = [(1,1), (2,1), (2,2), (1,2), (1,1)]
player1_expected_positions = [(10,2), (9,2), (9,1), (10,1), (10,2)]
gm.set_initial()
for i in range(num_rounds):
assert gm.universe.bots[0].current_pos == \
player0_expected_positions[i]
assert gm.universe.bots[1].current_pos == \
player1_expected_positions[i]
gm.play_round()
def test_malicous_player(self):
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] = False
return {"move": (0, 0)}
def get_move(self):
pass
test_layout = (""" ######
#0 . #
#.. 1#
###### """)
test_self = self
original_universe = None
class TestMaliciousPlayer(AbstractPlayer):
def get_move(self):
test_self.assertIsNotNone(original_universe)
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)
teams = [
SimpleTeam(MaliciousPlayer()),
SimpleTeam(TestMaliciousPlayer())
]
gm = GameMaster(test_layout, teams, 2, 200)
original_universe = gm.universe.copy()
gm.set_initial()
gm.play_round()
test_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 (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_kill_count(self):
test_start = """ ######
#0 1#
#....#
###### """
# the game lasts two rounds, enough time for bot 1 to eat food
NUM_ROUNDS = 5
gm = GameMaster(test_start, 2, game_time=NUM_ROUNDS)
gm.register_team(SimpleTeam(TestPlayer(">--->")))
# bot 1 moves west twice to eat the single food
gm.register_team(SimpleTeam(TestPlayer("<<<<<")))
gm.set_initial()
gm.play_round()
self.assertEqual(gm.game_state["times_killed"], [0, 0])
gm.play_round()
self.assertEqual(gm.game_state["times_killed"], [0, 1])
gm.play_round()
self.assertEqual(gm.game_state["times_killed"], [0, 1])
gm.play_round()
self.assertEqual(gm.game_state["times_killed"], [0, 2])
gm.play_round()
self.assertEqual(gm.game_state["times_killed"], [1, 2])
def test_malicous_player(self):
free_obj = Free()
class MaliciousPlayer(AbstractPlayer):
def _get_move(self, universe):
universe.teams[0].score = 100
universe.bots[0].current_pos = (2,2)
universe.maze[0,0][0] = free_obj
return (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):
# universe should not have been altered
test_self.assertEqual(original_universe, gm.universe)
return (0,0)
gm.register_team(SimpleTeam(MaliciousPlayer()))
gm.register_team(SimpleTeam(TestMaliciousPlayer()))
gm.set_initial()
gm.play_round(0)
test_self.assertEqual(original_universe, gm.universe)
def test_game(self):
test_start = (
""" ######
#0 . #
#.. 1#
###### """)
number_bots = 2
# The problem here is that the layout does not allow us to specify a
# different inital position and current position. When testing universe
# equality by comparing its string representation, this does not matter.
# But if we want to compare using the __eq__ method, but specify the
# target as ascii encoded maze/layout we need to convert the layout to a
# CTFUniverse and then modify the initial positions. For this we define
# a closure here to quickly generate a target universe to compare to.
# Also we adapt the score, in case food has been eaten
def create_TestUniverse(layout, black_score=0, white_score=0):
initial_pos = [(1, 1), (4, 2)]
universe = CTFUniverse.create(layout, number_bots)
universe.teams[0].score = black_score
universe.teams[1].score = white_score
for i, pos in enumerate(initial_pos):
universe.bots[i].initial_pos = pos
if not Food in universe.maze[1, 2]:
universe.teams[1]._score_point()
if not Food in universe.maze[2, 2]:
universe.teams[1]._score_point()
if not Food in universe.maze[3, 1]:
universe.teams[0]._score_point()
return universe
gm = GameMaster(test_start, number_bots, 200)
gm.register_team(SimpleTeam(TestPlayer('>-v>>>')))
gm.register_team(SimpleTeam(TestPlayer('<<-<<<')))
gm.set_initial()
gm.play_round()
test_first_round = (
""" ######
# 0. #
#..1 #
###### """)
self.assertEqual(create_TestUniverse(test_first_round), gm.universe)
gm.play_round()
test_second_round = (
""" ######
# 0. #
#.1 #
###### """)
self.assertEqual(create_TestUniverse(test_second_round), gm.universe)
gm.play_round()
test_third_round = (
""" ######
# . #
#.0 1#
###### """)
self.assertEqual(create_TestUniverse(test_third_round,
black_score=gm.universe.KILLPOINTS), gm.universe)
gm.play_round()
test_fourth_round = (
""" ######
#0 . #
#. 1 #
###### """)
self.assertEqual(create_TestUniverse(test_fourth_round,
black_score=gm.universe.KILLPOINTS, white_score=gm.universe.KILLPOINTS), gm.universe)
gm.play_round()
test_fifth_round = (
""" ######
# 0. #
#.1 #
###### """)
self.assertEqual(create_TestUniverse(test_fifth_round,
black_score=gm.universe.KILLPOINTS, white_score=gm.universe.KILLPOINTS), gm.universe)
print(gm.universe.pretty)
gm.play_round()
test_sixth_round = (
""" ######
# 0 #
#1 #
###### """)
print(gm.universe.pretty)
self.assertEqual(create_TestUniverse(test_sixth_round,
black_score=gm.universe.KILLPOINTS, white_score=gm.universe.KILLPOINTS), gm.universe)
# now play the full game
gm = GameMaster(test_start, number_bots, 200)
gm.register_team(SimpleTeam(TestPlayer('>-v>>>')))
gm.register_team(SimpleTeam(TestPlayer('<<-<<<')))
gm.play()
test_sixth_round = (
""" ######
# 0 #
#1 #
###### """)
self.assertEqual(create_TestUniverse(test_sixth_round,
black_score=gm.universe.KILLPOINTS, white_score=gm.universe.KILLPOINTS), gm.universe)
def test_convenience(self):
test_layout = (
""" ##################
#0#. . # . #
#2##### ####1 #
# . # . #3##
################## """)
game_master = GameMaster(test_layout, 4, 2, noise=False)
universe = game_master.universe
player_0 = StoppingPlayer()
player_1 = TestPlayer('^<')
player_2 = StoppingPlayer()
player_3 = StoppingPlayer()
game_master.register_team(SimpleTeam(player_0, player_2))
game_master.register_team(SimpleTeam(player_1, player_3))
game_master.set_initial()
self.assertEqual(universe.bots[0], player_0.me)
self.assertEqual(universe.bots[1], player_1.me)
self.assertEqual(universe.bots[2], player_2.me)
self.assertEqual(universe.bots[3], player_3.me)
self.assertEqual(universe, player_1.current_uni)
self.assertEqual([universe.bots[0]], player_2.other_team_bots)
self.assertEqual([universe.bots[1]], player_3.other_team_bots)
self.assertEqual([universe.bots[2]], player_0.other_team_bots)
self.assertEqual([universe.bots[3]], player_1.other_team_bots)
self.assertEqual([universe.bots[i] for i in (0, 2)], player_0.team_bots)
self.assertEqual([universe.bots[i] for i in (1, 3)], player_0.enemy_bots)
self.assertEqual([universe.bots[i] for i in (1, 3)], player_1.team_bots)
self.assertEqual([universe.bots[i] for i in (0, 2)], player_1.enemy_bots)
self.assertEqual([universe.bots[i] for i in (0, 2)], player_2.team_bots)
self.assertEqual([universe.bots[i] for i in (1, 3)], player_2.enemy_bots)
self.assertEqual([universe.bots[i] for i in (1, 3)], player_3.team_bots)
self.assertEqual([universe.bots[i] for i in (0, 2)], player_3.enemy_bots)
self.assertEqual(player_1.current_pos, (15, 2))
self.assertEqual(player_1.initial_pos, (15, 2))
self.assertEqual(universe.bots[1].current_pos, (15, 2))
self.assertEqual(universe.bots[1].initial_pos, (15, 2))
self.assertEqual(universe.teams[0], player_0.team)
self.assertEqual(universe.teams[0], player_2.team)
self.assertEqual(universe.teams[1], player_1.team)
self.assertEqual(universe.teams[1], player_3.team)
self.assertEqual(universe.teams[1], player_0.enemy_team)
self.assertEqual(universe.teams[1], player_2.enemy_team)
self.assertEqual(universe.teams[0], player_1.enemy_team)
self.assertEqual(universe.teams[0], player_3.enemy_team)
self.assertEqual(player_0.enemy_food, universe.enemy_food(player_0.team.index))
self.assertEqual(player_1.enemy_food, universe.enemy_food(player_1.team.index))
self.assertEqual(player_2.enemy_food, universe.enemy_food(player_2.team.index))
self.assertEqual(player_3.enemy_food, universe.enemy_food(player_3.team.index))
self.assertEqual(player_0.team_food, universe.team_food(player_0.team.index))
self.assertEqual(player_1.team_food, universe.team_food(player_1.team.index))
self.assertEqual(player_2.team_food, universe.team_food(player_2.team.index))
self.assertEqual(player_3.team_food, universe.team_food(player_3.team.index))
self.assertEqual({(0, 1): (1, 2), (0, 0): (1, 1)},
player_0.legal_moves)
self.assertEqual({(0, 1): (15, 3), (0, -1): (15, 1), (0, 0): (15, 2),
(1, 0): (16, 2)},
player_1.legal_moves)
self.assertEqual({(0, 1): (1, 3), (0, -1): (1, 1), (0, 0): (1, 2)},
player_2.legal_moves)
self.assertEqual({(0, -1): (15, 2), (0, 0): (15, 3)},
player_3.legal_moves)
self.assertEqual(player_1.current_state["round_index"], None)
self.assertEqual(player_1.current_state["bot_id"], None)
game_master.play_round()
self.assertEqual(player_1.current_pos, (15, 2))
self.assertEqual(player_1.previous_pos, (15, 2))
self.assertEqual(player_1.initial_pos, (15, 2))
self.assertEqual(player_1.current_state["round_index"], 0)
self.assertEqual(player_1.current_state["bot_id"], 3)
self.assertEqual(universe.bots[1].current_pos, (15, 1))
self.assertEqual(universe.bots[1].initial_pos, (15, 2))
self.assertUniversesEqual(player_1.current_uni, player_1.universe_states[-1])
game_master.play_round()
self.assertEqual(player_1.current_pos, (15, 1))
self.assertEqual(player_1.previous_pos, (15, 2))
self.assertEqual(player_1.initial_pos, (15, 2))
self.assertEqual(player_1.current_state["round_index"], 1)
self.assertEqual(player_1.current_state["bot_id"], 3)
self.assertEqual(universe.bots[1].current_pos, (14, 1))
self.assertEqual(universe.bots[1].initial_pos, (15, 2))
self.assertUniversesNotEqual(player_1.current_uni,
player_1.universe_states[-2])
def test_convenience(self):
test_layout = (""" ##################
#0#. . # . #
#2##### ####1 #
# . # . #3##
################## """)
player_0 = StoppingPlayer()
player_1 = TestPlayer('^<')
player_2 = StoppingPlayer()
player_3 = StoppingPlayer()
teams = [
SimpleTeam(player_0, player_2),
SimpleTeam(player_1, player_3)
]
game_master = GameMaster(test_layout, teams, 4, 2, noise=False)
universe = game_master.universe
game_master.set_initial()
self.assertEqual(universe.bots[0], player_0.me)
self.assertEqual(universe.bots[1], player_1.me)
self.assertEqual(universe.bots[2], player_2.me)
self.assertEqual(universe.bots[3], player_3.me)
self.assertEqual(universe, player_1.current_uni)
self.assertEqual([universe.bots[0]], player_2.other_team_bots)
self.assertEqual([universe.bots[1]], player_3.other_team_bots)
self.assertEqual([universe.bots[2]], player_0.other_team_bots)
self.assertEqual([universe.bots[3]], player_1.other_team_bots)
self.assertEqual([universe.bots[i] for i in (0, 2)],
player_0.team_bots)
self.assertEqual([universe.bots[i] for i in (1, 3)],
player_0.enemy_bots)
self.assertEqual([universe.bots[i] for i in (1, 3)],
player_1.team_bots)
self.assertEqual([universe.bots[i] for i in (0, 2)],
player_1.enemy_bots)
self.assertEqual([universe.bots[i] for i in (0, 2)],
player_2.team_bots)
self.assertEqual([universe.bots[i] for i in (1, 3)],
player_2.enemy_bots)
self.assertEqual([universe.bots[i] for i in (1, 3)],
player_3.team_bots)
self.assertEqual([universe.bots[i] for i in (0, 2)],
player_3.enemy_bots)
self.assertEqual(player_1.current_pos, (15, 2))
self.assertEqual(player_1.initial_pos, (15, 2))
self.assertEqual(universe.bots[1].current_pos, (15, 2))
self.assertEqual(universe.bots[1].initial_pos, (15, 2))
self.assertEqual(universe.teams[0], player_0.team)
self.assertEqual(universe.teams[0], player_2.team)
self.assertEqual(universe.teams[1], player_1.team)
self.assertEqual(universe.teams[1], player_3.team)
self.assertEqual(universe.teams[1], player_0.enemy_team)
self.assertEqual(universe.teams[1], player_2.enemy_team)
self.assertEqual(universe.teams[0], player_1.enemy_team)
self.assertEqual(universe.teams[0], player_3.enemy_team)
self.assertCountEqual(player_0.enemy_food,
universe.enemy_food(player_0.team.index))
self.assertCountEqual(player_1.enemy_food,
universe.enemy_food(player_1.team.index))
self.assertCountEqual(player_2.enemy_food,
universe.enemy_food(player_2.team.index))
self.assertCountEqual(player_3.enemy_food,
universe.enemy_food(player_3.team.index))
self.assertCountEqual(player_0.team_food,
universe.team_food(player_0.team.index))
self.assertCountEqual(player_1.team_food,
universe.team_food(player_1.team.index))
self.assertCountEqual(player_2.team_food,
universe.team_food(player_2.team.index))
self.assertCountEqual(player_3.team_food,
universe.team_food(player_3.team.index))
self.assertEqual({
(0, 1): (1, 2),
(0, 0): (1, 1)
}, player_0.legal_moves)
self.assertEqual(
{
(0, 1): (15, 3),
(0, -1): (15, 1),
(0, 0): (15, 2),
(1, 0): (16, 2)
}, player_1.legal_moves)
self.assertEqual({
(0, 1): (1, 3),
(0, -1): (1, 1),
(0, 0): (1, 2)
}, player_2.legal_moves)
self.assertEqual({
(0, -1): (15, 2),
(0, 0): (15, 3)
}, player_3.legal_moves)
self.assertEqual(player_1.current_state["round_index"], None)
self.assertEqual(player_1.current_state["bot_id"], None)
game_master.play_round()
self.assertEqual(player_1.current_pos, (15, 2))
self.assertEqual(player_1.previous_pos, (15, 2))
self.assertEqual(player_1.initial_pos, (15, 2))
self.assertEqual(player_1.current_state["round_index"], 0)
self.assertTrue(player_1.current_state["bot_id"] is None)
self.assertEqual(universe.bots[1].current_pos, (15, 1))
self.assertEqual(universe.bots[1].initial_pos, (15, 2))
self.assertUniversesEqual(player_1.current_uni,
player_1.universe_states[-1])
game_master.play_round()
self.assertEqual(player_1.current_pos, (15, 1))
self.assertEqual(player_1.previous_pos, (15, 2))
self.assertEqual(player_1.initial_pos, (15, 2))
self.assertEqual(player_1.current_state["round_index"], 1)
self.assertTrue(player_1.current_state["bot_id"] is None)
self.assertEqual(universe.bots[1].current_pos, (14, 1))
self.assertEqual(universe.bots[1].initial_pos, (15, 2))
self.assertUniversesNotEqual(player_1.current_uni,
player_1.universe_states[-2])
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_play_step(self):
test_start = (""" ########
# 0 ..#
#.. 1 #
######## """)
number_bots = 2
teams = [
SimpleTeam(TestPlayer('>>>>')),
SimpleTeam(TestPlayer('<<<<'))
]
gm = GameMaster(test_start, teams, number_bots, 4)
gm.set_initial()
gm.play_round()
self.assertEqual(gm.universe.bots[0].current_pos, (3, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (4, 2))
self.assertEqual(gm.game_state["round_index"], 0)
self.assertTrue(gm.game_state["bot_id"] is None)
self.assertFalse(gm.game_state["finished"])
gm.play_step()
self.assertEqual(gm.universe.bots[0].current_pos, (4, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (4, 2))
self.assertEqual(gm.game_state["round_index"], 1)
self.assertEqual(gm.game_state["bot_id"], 0)
self.assertEqual(gm.game_state["finished"], False)
gm.play_step()
self.assertEqual(gm.universe.bots[0].current_pos, (4, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (3, 2))
self.assertEqual(gm.game_state["round_index"], 1)
self.assertEqual(gm.game_state["bot_id"], 1)
self.assertEqual(gm.game_state["finished"], False)
gm.play_step()
self.assertEqual(gm.universe.bots[0].current_pos, (5, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (3, 2))
self.assertEqual(gm.game_state["round_index"], 2)
self.assertEqual(gm.game_state["bot_id"], 0)
self.assertEqual(gm.game_state["finished"], False)
gm.play_step()
self.assertEqual(gm.universe.bots[0].current_pos, (5, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (2, 2))
self.assertEqual(gm.game_state["round_index"], 2)
self.assertEqual(gm.game_state["bot_id"], 1)
self.assertEqual(gm.game_state["finished"], False)
gm.play_round()
# first call tries to finish current round (which already is finished)
# so nothing happens
self.assertEqual(gm.universe.bots[0].current_pos, (5, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (2, 2))
self.assertEqual(gm.game_state["round_index"], 2)
self.assertTrue(gm.game_state["bot_id"] is None)
self.assertEqual(gm.game_state["finished"], False)
self.assertEqual(gm.game_state["team_wins"], None)
self.assertEqual(gm.game_state["game_draw"], None)
gm.play_round()
# second call works
self.assertEqual(gm.universe.bots[0].current_pos, (6, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (1, 2))
self.assertEqual(gm.game_state["round_index"], 3)
self.assertTrue(gm.game_state["bot_id"] is None)
self.assertEqual(gm.game_state["finished"], True)
self.assertEqual(gm.game_state["team_wins"], None)
self.assertEqual(gm.game_state["game_draw"], True)
# Game finished because all food was eaten
# team 0 finished first but the round was played regularly to the end
# (hence round_index == 3 and bot_id is None)
# nothing happens anymore
gm.play_round()
self.assertEqual(gm.universe.bots[0].current_pos, (6, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (1, 2))
self.assertEqual(gm.game_state["round_index"], 3)
self.assertTrue(gm.game_state["bot_id"] is None)
self.assertEqual(gm.game_state["finished"], True)
self.assertEqual(gm.game_state["team_wins"], None)
self.assertEqual(gm.game_state["game_draw"], True)
# nothing happens anymore
gm.play_round()
self.assertEqual(gm.universe.bots[0].current_pos, (6, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (1, 2))
self.assertEqual(gm.game_state["round_index"], 3)
self.assertTrue(gm.game_state["bot_id"] is None)
self.assertEqual(gm.game_state["finished"], True)
self.assertEqual(gm.game_state["team_wins"], None)
self.assertEqual(gm.game_state["game_draw"], True)
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(TestPlayer('>-v>>>')),
SimpleTeam(TestPlayer('<<-<<<'))
]
gm = GameMaster(test_start, teams, number_bots, 200)
gm.set_initial()
gm.play_round()
test_first_round = (""" ######
# 0. #
#..1 #
###### """)
self.assertEqual(create_TestUniverse(test_first_round), gm.universe)
gm.play_round()
test_second_round = (""" ######
# 0. #
#.1 #
###### """)
self.assertEqual(create_TestUniverse(test_second_round), gm.universe)
gm.play_round()
test_third_round = (""" ######
# . #
#.0 1#
###### """)
self.assertEqual(
create_TestUniverse(test_third_round,
black_score=gm.universe.KILLPOINTS),
gm.universe)
gm.play_round()
test_fourth_round = (""" ######
#0 . #
#. 1 #
###### """)
self.assertEqual(
create_TestUniverse(test_fourth_round,
black_score=gm.universe.KILLPOINTS,
white_score=gm.universe.KILLPOINTS),
gm.universe)
gm.play_round()
test_fifth_round = (""" ######
# 0. #
#.1 #
###### """)
self.assertEqual(
create_TestUniverse(test_fifth_round,
black_score=gm.universe.KILLPOINTS,
white_score=gm.universe.KILLPOINTS),
gm.universe)
print(gm.universe.pretty)
gm.play_round()
test_sixth_round = (""" ######
# 0 #
#1 #
###### """)
print(gm.universe.pretty)
self.assertEqual(
create_TestUniverse(test_sixth_round,
black_score=gm.universe.KILLPOINTS,
white_score=gm.universe.KILLPOINTS),
gm.universe)
teams = [
SimpleTeam(TestPlayer('>-v>>>')),
SimpleTeam(TestPlayer('<<-<<<'))
]
# now play the full game
gm = GameMaster(test_start, teams, number_bots, 200)
gm.play()
test_sixth_round = (""" ######
# 0 #
#1 #
###### """)
self.assertEqual(
create_TestUniverse(test_sixth_round,
black_score=gm.universe.KILLPOINTS,
white_score=gm.universe.KILLPOINTS),
gm.universe)
def test_convenience(self):
test_layout = (
""" ##################
#0#. . # . #
#2##### ####1 #
# . # . #3##
################## """)
player_0 = StoppingPlayer()
player_1 = TestPlayer('^<')
player_2 = StoppingPlayer()
player_3 = StoppingPlayer()
teams = [
SimpleTeam(player_0, player_2),
SimpleTeam(player_1, player_3)
]
game_master = GameMaster(test_layout, teams, 4, 2, noise=False)
universe = game_master.universe
game_master.set_initial()
assert universe.bots[0] == player_0.me
assert universe.bots[1] == player_1.me
assert universe.bots[2] == player_2.me
assert universe.bots[3] == player_3.me
assert universe == player_1.current_uni
assert [universe.bots[0]] == player_2.other_team_bots
assert [universe.bots[1]] == player_3.other_team_bots
assert [universe.bots[2]] == player_0.other_team_bots
assert [universe.bots[3]] == player_1.other_team_bots
assert [universe.bots[i] for i in (0, 2)] == player_0.team_bots
assert [universe.bots[i] for i in (1, 3)] == player_0.enemy_bots
assert [universe.bots[i] for i in (1, 3)] == player_1.team_bots
assert [universe.bots[i] for i in (0, 2)] == player_1.enemy_bots
assert [universe.bots[i] for i in (0, 2)] == player_2.team_bots
assert [universe.bots[i] for i in (1, 3)] == player_2.enemy_bots
assert [universe.bots[i] for i in (1, 3)] == player_3.team_bots
assert [universe.bots[i] for i in (0, 2)] == player_3.enemy_bots
assert player_1.current_pos == (15, 2)
assert player_1.initial_pos == (15, 2)
assert universe.bots[1].current_pos == (15, 2)
assert universe.bots[1].initial_pos == (15, 2)
assert universe.teams[0] == player_0.team
assert universe.teams[0] == player_2.team
assert universe.teams[1] == player_1.team
assert universe.teams[1] == player_3.team
assert universe.teams[1] == player_0.enemy_team
assert universe.teams[1] == player_2.enemy_team
assert universe.teams[0] == player_1.enemy_team
assert universe.teams[0] == player_3.enemy_team
unittest.TestCase().assertCountEqual(player_0.enemy_food, universe.enemy_food(player_0.team.index))
unittest.TestCase().assertCountEqual(player_1.enemy_food, universe.enemy_food(player_1.team.index))
unittest.TestCase().assertCountEqual(player_2.enemy_food, universe.enemy_food(player_2.team.index))
unittest.TestCase().assertCountEqual(player_3.enemy_food, universe.enemy_food(player_3.team.index))
unittest.TestCase().assertCountEqual(player_0.team_food, universe.team_food(player_0.team.index))
unittest.TestCase().assertCountEqual(player_1.team_food, universe.team_food(player_1.team.index))
unittest.TestCase().assertCountEqual(player_2.team_food, universe.team_food(player_2.team.index))
unittest.TestCase().assertCountEqual(player_3.team_food, universe.team_food(player_3.team.index))
assert {(0, 1): (1, 2), (0, 0): (1, 1)} == \
player_0.legal_moves
assert {(0, 1): (15, 3), (0, -1): (15, 1), (0, 0): (15, 2),
(1, 0): (16, 2)} == \
player_1.legal_moves
assert {(0, 1): (1, 3), (0, -1): (1, 1), (0, 0): (1, 2)} == \
player_2.legal_moves
assert {(0, -1): (15, 2), (0, 0): (15, 3)} == \
player_3.legal_moves
assert player_1.current_state["round_index"] == None
assert player_1.current_state["bot_id"] == None
game_master.play_round()
assert player_1.current_pos == (15, 2)
assert player_1.previous_pos == (15, 2)
assert player_1.initial_pos == (15, 2)
assert player_1.current_state["round_index"] == 0
assert player_1.current_state["bot_id"] is None
assert universe.bots[1].current_pos == (15, 1)
assert universe.bots[1].initial_pos == (15, 2)
self.assertUniversesEqual(player_1.current_uni, player_1.universe_states[-1])
game_master.play_round()
assert player_1.current_pos == (15, 1)
assert player_1.previous_pos == (15, 2)
assert player_1.initial_pos == (15, 2)
assert player_1.current_state["round_index"] == 1
assert player_1.current_state["bot_id"] is None
assert universe.bots[1].current_pos == (14, 1)
assert universe.bots[1].initial_pos == (15, 2)
self.assertUniversesNotEqual(player_1.current_uni,
player_1.universe_states[-2])
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
def test_play_step(self):
test_start = """ ######
#0 ..#
#.. 1#
###### """
number_bots = 2
gm = GameMaster(test_start, number_bots, 3)
gm.register_team(SimpleTeam(TestPlayer(">>>")))
gm.register_team(SimpleTeam(TestPlayer("<<<")))
gm.set_initial()
gm.play_round()
self.assertEqual(gm.universe.bots[0].current_pos, (2, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (3, 2))
self.assertEqual(gm.game_state["round_index"], 0)
self.assertEqual(gm.game_state["bot_id"], 1)
self.assertEqual(gm.game_state["finished"], False)
gm.play_step()
self.assertEqual(gm.universe.bots[0].current_pos, (3, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (3, 2))
self.assertEqual(gm.game_state["round_index"], 1)
self.assertEqual(gm.game_state["bot_id"], 0)
self.assertEqual(gm.game_state["finished"], False)
gm.play_step()
self.assertEqual(gm.universe.bots[0].current_pos, (3, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (2, 2))
self.assertEqual(gm.game_state["round_index"], 1)
self.assertEqual(gm.game_state["bot_id"], 1)
self.assertEqual(gm.game_state["finished"], False)
gm.play_round()
# first call tries to finish current round (which already is finished)
# so nothing happens
self.assertEqual(gm.universe.bots[0].current_pos, (3, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (2, 2))
self.assertEqual(gm.game_state["round_index"], 1)
self.assertEqual(gm.game_state["bot_id"], 1)
self.assertEqual(gm.game_state["finished"], False)
gm.play_round()
# second call works
self.assertEqual(gm.universe.bots[0].current_pos, (4, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (1, 2))
self.assertEqual(gm.game_state["round_index"], 2)
self.assertEqual(gm.game_state["bot_id"], 1)
self.assertEqual(gm.game_state["finished"], True)
# Game finished because all food was eaten
# (hence round_index == 2 and bot_id == 1)
# nothing happens anymore
gm.play_round()
self.assertEqual(gm.universe.bots[0].current_pos, (4, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (1, 2))
self.assertEqual(gm.game_state["round_index"], 2)
self.assertEqual(gm.game_state["bot_id"], 1)
self.assertEqual(gm.game_state["finished"], True)
# nothing happens anymore
gm.play_round()
self.assertEqual(gm.universe.bots[0].current_pos, (4, 1))
self.assertEqual(gm.universe.bots[1].current_pos, (1, 2))
self.assertEqual(gm.game_state["round_index"], 2)
self.assertEqual(gm.game_state["bot_id"], 1)
self.assertEqual(gm.game_state["finished"], True)
def test_play_step(self):
test_start = (
""" ########
# 0 ..#
#.. 1 #
######## """)
number_bots = 2
teams = [
SimpleTeam(TestPlayer('>>>>')),
SimpleTeam(TestPlayer('<<<<'))
]
gm = GameMaster(test_start, teams, number_bots, 4)
gm.set_initial()
gm.play_round()
self.assertEqual(gm.universe.bots[0].current_pos, (3,1))
self.assertEqual(gm.universe.bots[1].current_pos, (4,2))
self.assertEqual(gm.game_state["round_index"], 0)
self.assertTrue(gm.game_state["bot_id"] is None)
self.assertFalse(gm.game_state["finished"])
gm.play_step()
self.assertEqual(gm.universe.bots[0].current_pos, (4,1))
self.assertEqual(gm.universe.bots[1].current_pos, (4,2))
self.assertEqual(gm.game_state["round_index"], 1)
self.assertEqual(gm.game_state["bot_id"], 0)
self.assertEqual(gm.game_state["finished"], False)
gm.play_step()
self.assertEqual(gm.universe.bots[0].current_pos, (4,1))
self.assertEqual(gm.universe.bots[1].current_pos, (3,2))
self.assertEqual(gm.game_state["round_index"], 1)
self.assertEqual(gm.game_state["bot_id"], 1)
self.assertEqual(gm.game_state["finished"], False)
gm.play_step()
self.assertEqual(gm.universe.bots[0].current_pos, (5,1))
self.assertEqual(gm.universe.bots[1].current_pos, (3,2))
self.assertEqual(gm.game_state["round_index"], 2)
self.assertEqual(gm.game_state["bot_id"], 0)
self.assertEqual(gm.game_state["finished"], False)
gm.play_step()
self.assertEqual(gm.universe.bots[0].current_pos, (5,1))
self.assertEqual(gm.universe.bots[1].current_pos, (2,2))
self.assertEqual(gm.game_state["round_index"], 2)
self.assertEqual(gm.game_state["bot_id"], 1)
self.assertEqual(gm.game_state["finished"], False)
gm.play_round()
# first call tries to finish current round (which already is finished)
# so nothing happens
self.assertEqual(gm.universe.bots[0].current_pos, (5,1))
self.assertEqual(gm.universe.bots[1].current_pos, (2,2))
self.assertEqual(gm.game_state["round_index"], 2)
self.assertTrue(gm.game_state["bot_id"] is None)
self.assertEqual(gm.game_state["finished"], False)
self.assertEqual(gm.game_state["team_wins"], None)
self.assertEqual(gm.game_state["game_draw"], None)
gm.play_round()
# second call works
self.assertEqual(gm.universe.bots[0].current_pos, (6,1))
self.assertEqual(gm.universe.bots[1].current_pos, (1,2))
self.assertEqual(gm.game_state["round_index"], 3)
self.assertTrue(gm.game_state["bot_id"] is None)
self.assertEqual(gm.game_state["finished"], True)
self.assertEqual(gm.game_state["team_wins"], None)
self.assertEqual(gm.game_state["game_draw"], True)
# Game finished because all food was eaten
# team 0 finished first but the round was played regularly to the end
# (hence round_index == 3 and bot_id is None)
# nothing happens anymore
gm.play_round()
self.assertEqual(gm.universe.bots[0].current_pos, (6,1))
self.assertEqual(gm.universe.bots[1].current_pos, (1,2))
self.assertEqual(gm.game_state["round_index"], 3)
self.assertTrue(gm.game_state["bot_id"] is None)
self.assertEqual(gm.game_state["finished"], True)
self.assertEqual(gm.game_state["team_wins"], None)
self.assertEqual(gm.game_state["game_draw"], True)
# nothing happens anymore
gm.play_round()
self.assertEqual(gm.universe.bots[0].current_pos, (6,1))
self.assertEqual(gm.universe.bots[1].current_pos, (1,2))
self.assertEqual(gm.game_state["round_index"], 3)
self.assertTrue(gm.game_state["bot_id"] is None)
self.assertEqual(gm.game_state["finished"], True)
self.assertEqual(gm.game_state["team_wins"], None)
self.assertEqual(gm.game_state["game_draw"], True)
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):
initial_pos = [(1, 1), (4, 2)]
universe = create_CTFUniverse(layout, number_bots)
for i, pos in enumerate(initial_pos):
universe.bots[i].initial_pos = pos
if not universe.maze.has_at(Food, (1, 2)):
universe.teams[1]._score_point()
if not universe.maze.has_at(Food, (2, 2)):
universe.teams[1]._score_point()
if not universe.maze.has_at(Food, (3, 1)):
universe.teams[0]._score_point()
return universe
gm = GameMaster(test_start, number_bots, 200)
gm.register_team(SimpleTeam(TestPlayer([east, east, east, south, stop, east])))
gm.register_team(SimpleTeam(TestPlayer([west, west, west, stop, west, west])))
gm.register_viewer(DevNullViewer())
gm.set_initial()
gm.play_round(0)
test_first_round = (
""" ######
# 0. #
#..1 #
###### """)
self.assertEqual(create_TestUniverse(test_first_round), gm.universe)
gm.play_round(1)
test_second_round = (
""" ######
# 0. #
#.1 #
###### """)
self.assertEqual(create_TestUniverse(test_second_round), gm.universe)
gm.play_round(2)
test_third_round = (
""" ######
# . #
#.0 1#
###### """)
self.assertEqual(create_TestUniverse(test_third_round), gm.universe)
gm.play_round(3)
test_fourth_round = (
""" ######
#0 . #
#. 1 #
###### """)
self.assertEqual(create_TestUniverse(test_fourth_round), gm.universe)
gm.play_round(4)
test_fifth_round = (
""" ######
# 0. #
#.1 #
###### """)
self.assertEqual(create_TestUniverse(test_fifth_round), gm.universe)
gm.play_round(5)
test_sixth_round = (
""" ######
# 0 #
#.1 #
###### """)
self.assertEqual(create_TestUniverse(test_sixth_round), gm.universe)
# now play the full game
gm = GameMaster(test_start, number_bots, 200)
gm.register_team(SimpleTeam(TestPlayer([east, east, east, south, stop, east])))
gm.register_team(SimpleTeam(TestPlayer([west, west, west, stop, west, west])))
gm.play()
test_sixth_round = (
""" ######
# 0 #
#.1 #
###### """)
self.assertEqual(create_TestUniverse(test_sixth_round), gm.universe)
