def main():
# GAME 1
# Create strategies
strategy_A = StaticStrategy('The Destroyer', [51, 47, 2], shuffle=False)
strategy_B = StaticStrategy('The Shuffling Destroyer', [51, 47, 2],
shuffle=True)
strategy_C = CounterStrategy('The Counter')
# Run games
gm = GameManager(strategy_A,
strategy_C,
num_fields=3,
num_runs=100,
total_score=True)
gm.run()
gm.plot_results()
gm.declare_winner()
# Run games
gm = GameManager(strategy_B,
strategy_C,
num_fields=3,
num_runs=100,
total_score=True)
gm.run()
gm.plot_results()
gm.declare_winner()
def main():
# GAME 1
# Create strategies
strategy_A = StaticStrategy('The Great Destroyer', [33, 33, 34],
shuffle=True)
strategy_B = StaticStrategy('The Even More Destroyer', [51, 47, 2])
# Set up game
gm = GameManager(strategy_A,
strategy_B,
num_fields=3,
num_runs=100,
total_score=True)
gm.run()
gm.plot_results()
gm.declare_winner()
# GAME 2
# Create strategies
strategy_A = StaticStrategy('The Great Destroyer 2', [33, 33, 34],
shuffle=True)
strategy_B = StaticStrategy('The Even More Destroyer 2', [51, 47, 2])
# Set up game
gm = GameManager(strategy_A,
strategy_B,
num_fields=3,
num_runs=100,
total_score=False)
gm.run()
gm.plot_results()
gm.declare_winner()
def __init__(self):
self.IMAGE_HEIGHT = 30
self.IMAGE_WIDTH = 30
BOARD_SIZE = 100
BOARD_SIGMA = 10
self.channels = 3
self.game_list = []
output_size = 30
self.model = Model(self.IMAGE_HEIGHT, self.IMAGE_WIDTH, self.channels,
"Fred", output_size)
self.init_model = Model(self.IMAGE_HEIGHT, self.IMAGE_WIDTH,
self.channels, "Terry", output_size)
self.saved_batches = []
self.MAX_SAVED_BATCH_SIZE = 100
self.saved_batch_index = 1
self.need_reset = False
self.saved_batches_in_use = True
np.random.seed(33127436)
expansion_levels = (15, 18, 30)
self.expanders = []
for expansion_index in range(len(expansion_levels)):
if 0 == expansion_index:
self.expanders.append(
np.random.random_sample(
(expansion_levels[expansion_index], 11)))
else:
self.expanders.append(
np.random.random_sample(
(expansion_levels[expansion_index],
expansion_levels[expansion_index - 1])))
np.random.seed()
self.compressors = []
for expander in self.expanders[::-1]:
self.compressors.append(np.linalg.pinv(expander))
self.game = GameManager(BOARD_SIZE, BOARD_SIGMA)
def managerMaker(jsonStuff):
names = jsonStuff[0]
floor = jsonStuff[1]
natural = jsonStuff[2]
ptList = jsonStuff[3]
actorMoveLL = moves_parser(jsonStuff[4])
levelMade = floorMaker(floor)
testState = GameState([levelMade])
manager = GameManager(testState)
users = []
index = 0
for name in names:
newUser = LocalPlayer(name, "player", index)
newUser.set_moves(actorMoveLL[index])
manager.register_player_user(newUser)
testState.move_player_via_id(index, translate_to_xy(ptList[index]))
newUser.set_moves(actorMoveLL[index])
users.append(newUser)
index = index + 1
while index < len(ptList):
adverse = Adversary(3, index, name_list[index],
monster_types[index - 2], 3)
manager.add_adversary(adverse)
testState.move_character(adverse, translate_to_xy(ptList[index]))
index = index + 1
return (manager, natural, users)
def test_lobby_password(self):
game_manager = GameManager()
game_manager.create_lobby("TEST", password="******")
lobbies = game_manager.get_lobbies_list()
self.assertTrue(lobbies[0]["hasPassword"])
def test_GameManagerInputs(self):
"""
Tests GameManager input data prompter and respondents and GET abilities of those props
"""
gameManager = GameManager("Jonathan", ["Omar", "Joey", "Salekh"])
self.assertEqual((str==type(gameManager.get_prompter()[0])), True)
self.assertEqual((list==type(gameManager.get_respondents())), True)
def __init__(self, discrete=True):
global locker
global global_port
locker.acquire(True)
this_port = global_port
global_port += 1
locker.release()
#self.client = AirSimClient(port=this_port)
#self.client.confirmConnection()
#self.client.enableApiControl(True)
#self.client.armDisarm(True)
self.log_file = open('logs.txt', 'w')
self.acc_file = open('accs.txt', 'w')
self.episodes = 0
self.fps = 60
self.max_iter = 15 * self.fps
self.t = np.matrix([10.0, 0.0, 0.0])
self.o = np.matrix([0.0, 0.0, 0.0])
self.c = np.matrix([0.0, 0.0, 0.0])
self.v = np.matrix([0.0, 0.0, 0.0])
self.v_t = np.matrix([0.0, 0.0, 0.0])
self.r = np.matrix([0.0, 0.0, 0.0])
self.queue_len = 4
self.coord_queue = None
self.width = 256
self.height = 144
self.image = None
self.iteration = 0
#self._render()
self.current_state = self._get_obs()
self.reset()
self.viewer = None
self.discrete = discrete
if self.discrete:
self.action_space = spaces.Discrete(27)
self.observation_space = spaces.Box(
low=np.zeros(self.current_state.shape),
high=np.zeros(self.current_state.shape) + 1)
else:
self.action_space = spaces.Box(-1, 1, shape=(4, ))
self.observation_space = spaces.Box(
low=np.zeros(self.current_state.shape),
high=np.zeros(self.current_state.shape) + 1)
self.current_state = None
self.nb_frames = Config.STACKED_FRAMES
self.frame_q = Queue(maxsize=self.nb_frames)
self.previous_state = None
self.current_state = None
self.total_reward = 0
self.game = GameManager('AirSim',
display=Config.PLAY_MODE,
custom_env=self)
self._seed()
def test_start_game(self):
g = GameManager()
room = 'ASDFGHJ'
g.locks[room] = Lock()
socket = 'socket'
timer = '1'
username = '******'
g.socket_to_room[socket] = room
g.socket_to_username[socket] = username
reason = 'AAAAAAA does not exist'
expected = [(socket, {
'type': 'Started',
'room_name': 'AAAAAAA',
'status': 'failed',
'reason': reason,
'spy': False,
'list_of_words': None,
'specific_word': None
})]
self.assertEquals(g.start_game(['AAAAAAA', '1'], socket), expected)
g.rooms['AAAAAAA'] = []
reason = 'User is not a part of the game'
expected = [(socket, {
'type': 'Started',
'room_name': 'AAAAAAA',
'status': 'failed',
'reason': reason,
'spy': False,
'list_of_words': None,
'specific_word': None
})]
self.assertEquals(g.start_game(['AAAAAAA', '1'], socket), expected)
g.rooms[room] = [(False, None, 'user1'), (False, socket, username)]
reason = room + ' has less than ' + str(
g.min_people_to_start_game) + ' people. You need at least ' + str(
g.min_people_to_start_game) + ' to start a game'
expected = [(socket, {
'type': 'Started',
'room_name': room,
'status': 'failed',
'reason': reason,
'spy': False,
'list_of_words': None,
'specific_word': None
})]
self.assertEquals(g.start_game([room, '1'], socket), expected)
self.assertEquals(room in g.games_in_progress, False)
data = [room, timer]
g.rooms[room].append((False, None, 'user3'))
g.start_game(data, socket)
words, selected_word = g.words_for_room[room]
self.assertEquals(len(words), g.num_words_in_game)
self.assertEquals(selected_word in words, True)
self.assertEquals(room in g.games_in_progress, True)
def setUp(self, mock_gm_app):
self.auto_clicker_1 = AutoClickers('Factory', 5.0, 15.0, 0)
self.auto_clicker_2 = AutoClickers('Farm', 10.0, 50.0, 3)
self.auto_clicker_3 = AutoClickers('House', 20.0, 100.0, 5)
self.game_manager = GameManager(auto_clickers=[
self.auto_clicker_1, self.auto_clicker_2, self.auto_clicker_3
])
self.game_manager.app = mock_gm_app
def test_lobby_password_encrypted(self):
game_manager = GameManager()
lobby_key = game_manager.create_lobby("TEST", password="******")
lobby: Lobby = game_manager.get_lobby(lobby_key)
self.assertNotEqual(lobby.password_encrypted, "test")
self.assertTrue(lobby.check_password_correct("test"))
def __init__(self):
self.game = GameManager(Config.DATA_FRAME, display=Config.PLAY_MODE)
# self.nb_frames = Config.STACKED_FRAMES
# self.frame_q = Queue(maxsize=self.nb_frames)
self.previous_state = None
self.current_state = None
self.total_reward = 0
self.reset()
def Run(isDebugging=False):
if isDebugging == False:
device = Device("127.0.0.1:62001")
device.Connect()
profile = Profile("GaChien")
profile.Load()
gameManager = GameManager(device, profile)
screenManager = ScreenManager()
while True:
screenshot = device.CaptureScreen()
if screenshot.image is None:
print("Can not capture screenshot. Retry...")
time.sleep(5)
continue
screen = screenManager.GetScreen(screenshot)
screen.ShowName()
gameManager.SetScreen(screen)
gameManager.Play()
print("")
time.sleep(5)
else:
device = Device(None)
device.Connect()
profile = Profile("GaChien")
profile.Load()
gameManager = GameManager(device, profile)
screenManager = ScreenManager()
print("Debugging...")
filePath = os.path.abspath("PendingScreens/Screenshot.png")
screenshot = ScreenShot(filePath)
screen = screenManager.GetScreen(screenshot)
screen.ShowName()
gameManager.SetScreen(screen)
gameManager.Play()
def main():
args = parse_arguments()
if args.Terminal:
game = GameManager()
game.start()
else:
game = Gui()
game.start()
game.stop()
def __init__(self):
self.game = GameManager()
self.nb_frames = Config.STACKED_FRAMES
self.frame_q = Queue(maxsize=self.nb_frames)
self.previous_state = None
self.current_state = None
self.total_reward = 0
self.reset()
def test_lobby_create(self):
game_manager = GameManager()
lobby_key = game_manager.create_lobby("TEST")
lobbies = game_manager.get_lobbies_list()
self.assertTrue(len(lobbies) == 1)
self.assertEqual(lobbies[0]["key"], lobby_key)
self.assertEqual(lobbies[0]["name"], "TEST")
def test_lobby_random_salt(self):
game_manager = GameManager()
all_keys = []
for i in range(10):
lobby_key = game_manager.create_lobby("TEST{}".format(i))
all_keys.append(lobby_key)
# remove duplicates with set, it should be equal
removed_duplicates = list(set(all_keys))
self.assertEqual(sorted(all_keys), sorted(removed_duplicates))
def test_gamemanager_query_get(self):
gameManager = GameManager("Jonathan", ["Omar", "Joey", "Salekh"])
q = gameManager.get_suggestions("dogfish")
# Check that the keys() of answers received correspond to the respondents
del q['Jonathan']
del q['if_valid']
self.assertEqual(sorted(q.keys()),sorted(gameManager.get_respondents()))
# Check to see if suggestions are shuffled:
p1, p2, p3 = q.keys()
self.assertEqual( (q[p1] != q[p2] != q[p3]), True)
def test_check_password_correct(self):
game_manager = GameManager()
lobby_key = game_manager.create_lobby("TEST", password="******")
lobby: Lobby = game_manager.get_lobby(lobby_key)
# password is encrypted
self.assertNotEqual(lobby.password_encrypted, "test")
# correct password is working and others are not
self.assertTrue(lobby.check_password_correct("test"))
self.assertFalse(lobby.check_password_correct("test1"))
self.assertFalse(lobby.check_password_correct("1234"))
def testRegisterUsers(self):
example = [[1 for i in range(10)] for j in range(10)]
hall = Hallway((14, 5), (20, 5), [])
zHall = Hallway((14, 14), (20, 10), [(17, 14), (17, 10)])
room = Room(example, (5, 5))
room2 = Room(example, (20, 5))
floor = Floor([room, room2], [hall, zHall])
game = GameState([floor])
gm = GameManager(game)
gm.register_player_user(self.LocalPlayer1)
gm.register_player_user(self.LocalPlayer2)
self.assertEqual(2, len(gm.ID_to_user_character))
def test_leave_session(self):
g = GameManager()
room_name = 'AAAAAAA'
g.locks[room_name] = Lock()
socket = 'socket'
g.rooms[room_name] = [(False, None, 'user1'), (False, None, 'user2'),
(False, None, 'user3')]
reason = 'User is not a part of any game'
expected = [(socket, {
'type': 'Leave_Session',
'room_name': room_name,
'status': 'failed',
'reason': reason,
'end': False
})]
self.assertEquals(g.leave_session(room_name, socket), expected)
username = '******'
g.rooms['BBBBBBB'] = [(False, socket, username)]
g.socket_to_username[socket] = username
reason = g.socket_to_username[socket] + ' is not a part of the game'
expected = [(socket, {
'type': 'Leave_Session',
'room_name': room_name,
'status': 'failed',
'reason': reason,
'end': False
})]
self.assertEquals(g.leave_session(room_name, socket), expected)
g.rooms['BBBBBBB'] = []
g.join_room(room_name, username, socket)
self.assertEquals(len(g.rooms[room_name]), 4)
self.assertEquals(g.socket_to_room[socket], room_name)
self.assertEquals(g.socket_to_username[socket], username)
g.leave_session(room_name, socket)
self.assertEquals(len(g.rooms[room_name]), 3)
self.assertEquals(socket in g.socket_to_room, False)
self.assertEquals(socket in g.socket_to_username, False)
g.rooms['ASDFQWER'] = [(False, None, 'user1'),
(False, socket, 'user2'),
(False, None, 'user3')]
g.socket_to_username[socket] = 'user2'
g.socket_to_room[socket] = 'ASDFQWER'
g.locks['ASDFQWER'] = Lock()
g.games_in_progress.add('ASDFQWER')
g.leave_session('Room Name Not Given', socket)
self.assertEquals('ASDFQWER' not in g.games_in_progress, True)
self.assertEquals(g.username_used('user2', 'ASDFQWER'), False)
def game_loop():
manager = GameManager()
while manager.game_state != GameState.PAUSED:
# handle quit
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
manager.update()
def test_join_room(self):
g = GameManager()
room = 'ASDFGHJ'
username = '******'
socket = 'None'
reason = 'room name does not exist'
g.locks[room] = Lock()
self.assertEquals(g.join_room(room, username, socket),
[(socket, {
'type': 'Joined',
'room_name': 'ASDFGHJ',
'usernames': [username],
'status': 'failed',
'reason': reason
})])
g.rooms[room] = [(None, socket, username)]
reason = 'The username: '******' is already taken'
self.assertEquals(g.join_room(room, username, socket),
[(socket, {
'type': 'Joined',
'room_name': 'ASDFGHJ',
'usernames': [username],
'status': 'failed',
'reason': reason
})])
g.socket_to_room[socket] = 'OTHERRM'
g.rooms[room] = [(False, None, 'user1')]
reason = 'user is already a part of a room'
self.assertEquals(g.join_room(room, username, socket),
[(socket, {
'type': 'Joined',
'room_name': 'ASDFGHJ',
'usernames': [username],
'status': 'failed',
'reason': reason
})])
del g.socket_to_room[socket]
expected = [(socket, {
'type': 'Joined',
'room_name': 'ASDFGHJ',
'usernames': [username],
'status': 'failed',
'reason': reason
})]
g.join_room(room, username, socket)
self.assertEquals(g.socket_to_room[socket], room)
self.assertEquals(g.socket_to_username[socket], username)
self.assertEquals(g.rooms[room], [(False, None, 'user1'),
(False, socket, username)])
def main():
# GAME 1
# Create strategies
strategy_A = RandomStrategy('The Great Destroyer', [1/3.0, 1/3.0, 1/3.0], shuffle=True)
strategy_B = RandomStrategy('The Even More Destroyer', [0.4, 0.4, 0.2])
# Set up game
gm = GameManager(strategy_A, strategy_B, num_fields=3, num_runs=1000, total_score=True)
gm.run()
gm.plot_results()
gm.declare_winner()
# GAME 2
# Create strategies
strategy_A = RandomStrategy('The Great Destroyer 2', [0.51, 0.48, 0.01], shuffle=True)
strategy_B = RandomStrategy('The Even More Destroyer 2', [0.5, 0.5, 0.0], shuffle=True)
# Set up game
gm = GameManager(strategy_A, strategy_B, num_fields=3, num_runs=1000, total_score=False)
gm.run()
gm.plot_results()
gm.declare_winner()
def main():
# Add you own strategy here instead of StaticStrategy
my_strat = StaticStrategy('MyStrat', [25, 25, 25, 25, 0, 0, 0, 0], shuffle=True)
# Create opponent
opponent = RandomStrategy('RandomStrategy', style=RandomStyle.UNIFORM)
# Set up game
gm = GameManager(my_strat, opponent, num_fields=8, num_runs=1)
gm.run()
# Uncomment this if you have matplotlib
# gm.plot_results()
gm.declare_winner()
def main():
from Strategies.RandomStrategy import RandomStrategy, RandomStyle
from GameManager import GameManager
strategy_a = SnoopDog("Snoop!")
strategy_b = RandomStrategy("Rando", [0.4, 0.4, 0.2],
shuffle=True,
style=RandomStyle.NUMBER)
gm = GameManager(strategy_a, strategy_b, 3, 30, total_score=False)
gm.run()
gm.plot_results()
gm.declare_winner()
def test_p1(subject):
temp = GameManager(prev_player=subject, train=False)
loss = 0
wins = 0
for i in range(10000):
temp.simulate()
if temp.check_win() == 2:
loss += 1
else:
wins += 1
temp.reset()
return (wins / (wins + loss)) * 100
def changeSceneToSingleplayer(self):
pygame.mixer.music.stop()
self.view = QtWidgets.QGraphicsView(self.scene)
self.view.setSceneRect(90, 90, 1250, 738)
self.view.setViewportUpdateMode(
QtWidgets.QGraphicsView.NoViewportUpdate)
self.view.setInteractive(False)
self.setCentralWidget(self.view)
self.gm = GameManager({PlayerType.player1: "Player"})
self.gm.isTournament = False
self.levelItem = pli.PlayerLevelInformation(self.gm)
self.remainingAsteriodsItem = pra.PlayerRemainingAsteroids(self.gm)
mng.Managers.getInstance().scene.AddItem(self.levelItem)
mng.Managers.getInstance().scene.AddItem(self.remainingAsteriodsItem)
def __init__(self, display=Config.SHOW_MODE):
self.game = GameManager(display=display)
self.previous_state = None
self.current_state = None
self.available = None
self.total_reward = 0
self.envs_mean = None
self.envs_std = None
self.num_steps = 0
self.state_mean = 0
self.state_std = 0
self.alpha = 0.9999
self.num_steps = 0
def config(self):
'''
:return: The game settings
'''
ui = None
oponent = None
board = Board(int(self.__settings['width']),
int(self.__settings['height']))
gm = GameManager(board, int(self.__settings['difficulty']))
if self.__settings['ui'] == Constants.CONSOLE:
ui = Console(gm)
if self.__settings['ui'] == Constants.GUI:
ui = GUI(gm)
return ui
def main():
# Add you own strategy here instead of StaticStrategy
camz = CamzBattle('Camz',
"/home/cameron/Code/Blotto/data/camz_strategy.json")
snoop = SnoopDogg('Snoop')
# Create opponent
scroggs = Scroggs('Scroggs')
# Set up game
gm = GameManager(snoop, scroggs, num_fields=8, num_runs=1000)
gm.run()
# Uncomment this if you have matplotlib
gm.plot_results()
gm.declare_winner()
