def test_too_many_registered_teams(self): test_layout_4 = ( """ ################## #0#. . # . # #2##### #####1# # . # . .#3# ################## """) team_1 = SimpleTeam(SteppingPlayer([]), SteppingPlayer([])) team_2 = SimpleTeam(SteppingPlayer([]), SteppingPlayer([])) team_3 = SimpleTeam(SteppingPlayer([]), SteppingPlayer([])) with pytest.raises(ValueError): GameMaster(test_layout_4, [team_1, team_2, team_3], 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_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_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_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_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
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_too_few_registered_teams(self): test_layout_4 = (""" ################## #0#. . # . # #2##### #####1# # . # . .#3# ################## """) team_1 = SimpleTeam(TestPlayer([]), TestPlayer([])) self.assertRaises(ValueError, GameMaster, test_layout_4, [team_1], 4, 200)
def test_too_many_registered_teams(self): test_layout_4 = ( """ ################## #0#. . # . # #2##### #####1# # . # . .#3# ################## """) game_master = GameMaster(test_layout_4, 4, 200) team_1 = SimpleTeam(TestPlayer([]), TestPlayer([])) team_2 = SimpleTeam(TestPlayer([]), TestPlayer([])) team_3 = SimpleTeam(TestPlayer([]), TestPlayer([])) game_master.register_team(team_1) game_master.register_team(team_2) game_master.register_team(team_3) self.assertEqual(len(game_master.universe.teams), 2) self.assertRaises(IndexError, game_master.play)
def test_failing_bots_do_not_crash_server_in_set_initial(self): layout = """ ########## # # #0 .. 1# ########## """ server = SimpleServer(layout_string=layout, rounds=5, players=2, timeout_length=0.3) 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 ThisIsAnExpectedException(Exception): pass class FailingPlayer(AbstractPlayer): def set_initial(self): raise ThisIsAnExpectedException() def get_move(self): raise ThisIsAnExpectedException() old_timeout = pelita.simplesetup.DEAD_CONNECTION_TIMEOUT pelita.simplesetup.DEAD_CONNECTION_TIMEOUT = 0.3 client1 = SimpleClient(SimpleTeam("team1", FailingPlayer()), address=client1_address) client2 = SimpleClient(SimpleTeam("team2", FailingPlayer()), address=client2_address) client1.autoplay_process() client2.autoplay_process() server.run() server.shutdown() pelita.simplesetup.DEAD_CONNECTION_TIMEOUT = old_timeout
def test_team_names_in_simpleteam(self): test_layout = ( """ ################## #0#. . # . # #2##### #####1# # . # . .#3# ################## """) game_master = GameMaster(test_layout, 4, 200) team_1 = SimpleTeam('team1', TestPlayer([]), TestPlayer([])) team_2 = SimpleTeam('team2', TestPlayer([]), TestPlayer([])) game_master.register_team(team_1) game_master.register_team(team_2) game_master.set_initial() self.assertEqual(game_master.universe.teams[0].name, "team1") self.assertEqual(game_master.universe.teams[1].name, "team2")
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 defender_factory(): memory = CollectiveMemory() bot1 = AwesomePlayer(walkie_talkie=memory, attacker=PossessiveItalianRole(), defender=PossessiveItalianRole()) bot2 = AwesomePlayer(walkie_talkie=memory, attacker=ExtremelyHungryRole(), defender=ExtremelyHungryRole()) # bot2 = AwesomePlayer(walkie_talkie=memory, attacker=PossessiveItalianRole(), defender=PossessiveItalianRole()) # bot1 = AwesomePlayer(walkie_talkie=memory, attacker=ExtremelyHungryRole(), defender=ExtremelyHungryRole()) # bot2 = AwesomePlayer(walkie_talkie=memory, attacker=ExtremelyHungryRole(), defender=ExtremelyHungryRole()) return SimpleTeam("popyourstash", bot1, bot2)
def test_my_player_is_not_moving(self): my_team = SimpleTeam("test", MyPlayer(), MyPlayer()) 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 gm.register_team(SimpleTeam(RandomPlayer(), RandomPlayer())) # 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_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_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_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 factory(): memory = CollectiveMemory() bot1 = AwesomePlayer(walkie_talkie=memory, attacker=ExtremelyHungryRole(), defender=PossessiveItalianRole()) bot2 = AwesomePlayer(walkie_talkie=memory, attacker=ExtremelyHungryRole(), defender=PossessiveItalianRole()) # bot2 = AwesomePlayer(walkie_talkie=memory, attacker=PossessiveItalianRole(), defender=PossessiveItalianRole()) # # bot1 = MemoryPlayer() # bot2 = MemoryPlayer() # print('Creating bots {b1} and {b2}'.format(b1 = bot1.__repr__, b2 = bot2.__repr__)) # m = CollectiveMemory(bot1, bot2) # bot1 = DrunkPlayer() # bot2 = DrunkPlayer() return SimpleTeam("popyourstash", bot1, bot2)
def factory(): return SimpleTeam("Random Explorer Players", RandomExplorerPlayer(), RandomExplorerPlayer())
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)
#!/usr/bin/python from pelita.game_master import GameMaster from pelita.player import StoppingPlayer, SimpleTeam from pelita.viewer import AsciiViewer from players import RandomPlayer, NQRandomPlayer if __name__ == '__main__': layout = (""" ################## #0#. . # . # #2##### #####1# # . # . .#3# ################## """) gm = GameMaster(layout, 4, 200) gm.register_team(SimpleTeam(StoppingPlayer(), NQRandomPlayer())) gm.register_team(SimpleTeam(NQRandomPlayer(), NQRandomPlayer())) gm.register_viewer(AsciiViewer()) gm.play()
#.. . . #. . #. # # ## ##### # # ## #### #.## # # . . . ..# #.. .. # # # # ##### ##### ##### ##### # # # # .. ..# #.. . . . # # ##.# #### ## # # ##### ## # # .# . .# . . ..# #. . . .## # #### ## # ## # ######### # . # . # #.# # ## # . # # # .# #0##### # # ### # # ## # #2 # # #. # ...# ################################## """ server = SimpleServer(layout_string=layout, rounds=3000) def star_to_localhost(str): # server might publish to tcp://* in which case we simply try localhost for the clients return str.replace("*", "localhost") client = SimpleClient(SimpleTeam("the good ones", NQRandomPlayer(), BFSPlayer()), address=star_to_localhost(server.bind_addresses[0])) client.autoplay_process() client2 = SimpleClient(SimpleTeam("the bad ones", BFSPlayer(), BasicDefensePlayer()), address=star_to_localhost(server.bind_addresses[1])) client2.autoplay_process() server.run() print(server.game_master.universe.pretty) print(server.game_master.game_state)
#!/usr/bin/env python # -*- coding: utf-8 -*- """ This file demonstrates setting up a server and two clients using local connections. """ from pelita.simplesetup import SimpleClient, SimpleServer from pelita.player import SimpleTeam, StoppingPlayer from players import RandomPlayer, BFSPlayer, NQRandomPlayer, BasicDefensePlayer client = SimpleClient(SimpleTeam("the good ones", NQRandomPlayer(), BFSPlayer()), address="ipc:///tmp/pelita-client1") client.autoplay_process() client2 = SimpleClient(SimpleTeam("the bad ones", BFSPlayer(), BasicDefensePlayer()), address="ipc:///tmp/pelita-client2") client2.autoplay_process() layout = """ ################################## #... # .# # # 3# # ## # # ### # # #####1# #. # # # . # ## # #.# # . # . # ######### # ## # ## #### # ##. . . .# #.. . . #. . #. # # ## ##### # # ## #### #.## # # . . . ..# #.. .. # # # # ##### ##### ##### ##### # # # # .. ..#
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 factory(): return SimpleTeam("Drunk and hungry team", DrunkPlayer(), HungryPlayer())
def factory(): return SimpleTeam("My Team", MyPlayer(), MyPlayer())
def factory(): return SimpleTeam("The Food Eating Players", FoodEatingPlayer(), FoodEatingPlayer())
from pelita.player import SimpleTeam from pelita.player import RandomPlayer, BFSPlayer from pelita.simplesetup import SimpleClient import logging try: import colorama MAGENTA = colorama.Fore.MAGENTA RESET = colorama.Fore.RESET except ImportError: MAGENTA = "" RESET = "" FORMAT = '[%(asctime)s,%(msecs)03d][%(name)s][%(levelname)s][%(funcName)s]' + MAGENTA + ' %(message)s' + RESET #logging.basicConfig(format=FORMAT, datefmt="%H:%M:%S", level=logging.WARNING) team1 = SimpleTeam("the good ones", BFSPlayer(), BFSPlayer()) client1 = SimpleClient(team1, address="tcp://localhost:50007") team2 = SimpleTeam("the bad ones", BFSPlayer(), BFSPlayer()) client2 = SimpleClient(team2, address="tcp://localhost:50008") client1.autoplay_process() client2.autoplay_process()
def factory(): return SimpleTeam("The Random Players", RandomPlayer(), NQRandomPlayer())