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())
