def testManualGameImageOutput1():
print("\n== init manual setting game ==")
height = 10
width = 10
game = Game(height, width)
obstacles = [{"x": 1, "y": 1}, {"x": 2, "y": 2}, {"x": 3, "y": 3}]
targets = [{"x": 4, "y": 4}, {"x": 5, "y": 5}, {"x": 6, "y": 6}]
game.setObstacles(obstacles)
game.setTargets(targets)
#game.setScore(100, 10, -0.01, -100)
game.printGodMap()
agents = {
0: Agent(0, 7, 6, height, width, r=3), # id, x, y, height, width
}
game.setAgents(agents)
game.printConsoleMap()
print("\n== 1st round ==")
game.runOneRound([Command(0, -1, -1)]) # (6, 5)
game.printConsoleMap()
print("\n== 2st round ==")
game.runOneRound([Command(0, -1, 0)]) # (5, 5)
game.printConsoleMap()
print("\n== 3st round ==")
game.runOneRound([Command(0, -1, 0)]) #(4, 5)
game.printConsoleMap()
def testManualGameImageOutput2():
print("\n== init manual setting game ==")
height = 50
width = 50
crash = 0
game = Game(height, width)
game.setRandomMap(8, 300, 200) # numbers of agents, targets, obstacles
game.printGodMap()
#agents = game.godmap.agents
'''agents = {
0: Agent(0, 0, 0, height, width, r=5), # id, x, y, height, width
1: Agent(1, width-1 , 0, height, width, r=5), # id, x, y, height, width
2: Agent(2, 0 , height-1 , height, width, r=5), # id, x, y, height, width
#3: Agent(3, width - 1, height- 1, height, width, r = 5)
}'''
#game.setAgents(agents)
##########
game.runOneRoundwithoutMovement()
game.printConsoleMap()
round = 1
while (game.algNext(crash, round)):
round += 1
def init_emulator_and_game(self):
"""Initializes emulator and game objects."""
if not self.emulator_name:
self.setup_gui_first_time()
if self.emulator_type == NoxPlayer.__name__:
self.emulator = NoxPlayer(self.emulator_name)
if self.emulator.get_version(
) and self.emulator.get_version() < LooseVersion('7.0.0.0'):
menu = self.menuBar.addMenu("Emulator")
action = menu.addAction(
f"Make {self.emulator.name} restartable")
action.triggered.connect(self.emulator.set_config_for_bot)
if self.emulator_type == BlueStacks.__name__:
self.emulator = BlueStacks(self.emulator_name)
if not self.emulator.restartable:
self.restart_game_button.setEnabled(False)
self.restart_game_button.setText(
f"{self.restart_game_button.text()}\n"
"[Unavailable (check logs)]")
self.restart_game_button = None
self.game = Game(self.emulator)
self.manager = SyncManager()
self.manager.start()
self.game._modes = self.manager.dict()
if self.game_app_rect:
self.game._game_app_ui.button_rect = Rect(*self.game_app_rect)
def initialGame(self):
#initial the game envirnment for th replay buffer
t = (self.height + self.width) / 2
self.game = Game(self.height, self.width, self.game_round)
self.game.setRandomMap(self.agent_num,
int(t * 0.3)**2,
int(t * 0.1)**2)
self.game.setScore(self.acquisition_sum, self.explored_target_sum,
self.explored_sum, self.time_decrease,
self.crash_time_penalty, self.crash_sum,
self.reg_val)
self.game.runOneRound(
[Command(i, 0, 0) for i in range(self.agent_num)])
self.score = np.array(
[self.game.outputScore() for i in range(self.agent_num)])
self.states = torch.zeros(
[4, self.agent_num, 3, self.height, self.width],
dtype=torch.float32)
s = np.array([
self.game.outputAgentImage(i) for i in range(self.agent_num)
]).astype(np.float32)
s = torch.from_numpy(s)
self.states[3] = s
print('New Game!')
def randomGame():
print("\n== init random game ==")
game = Game(20, 20) # height, width
game.setRandomMap(3, 3, 4) # numbers of agents, targets, obstacles
game.setScore(100, 20, 10, -2, -0.04, -20)
game.printGodInfo()
print("\n== 1st round ==")
commands = []
commands.append(Command(0, 1, 1)) # id, dx, dy
commands.append(Command(1, -1, 1))
commands.append(Command(2, 1, -1))
game.runOneRound(commands)
game.printConsoleInfo()
print("Score: " + str(game.outputScore()))
print("\n== 2ed round ==")
commands = []
commands.append(Command(0, 1, 1))
commands.append(Command(1, -1, 1))
commands.append(Command(2, 1, -1))
game.runOneRound(commands)
game.printConsoleInfo()
print("Score: " + str(game.outputScore()))
def init_emulator_and_game(self):
"""Init emulator and game."""
if not self.emulator_name:
self.setup_gui_first_time()
# TODO: backwards compatability, remove after few updates
if self.emulator_type == "NoxWindow":
self.emulator_type = NoxPlayer.__name__
# TODO: end
if self.emulator_type == NoxPlayer.__name__:
self.emulator = NoxPlayer(self.emulator_name)
if self.emulator.get_version(
) and not self.emulator.get_version().startswith("7."):
menu = self.menuBar.addMenu("Emulator")
action = menu.addAction(
f"Make {self.emulator.name} restartable")
action.triggered.connect(self.emulator.set_config_for_bot)
if self.emulator_type == BlueStacks.__name__:
self.emulator = BlueStacks(self.emulator_name)
if not self.emulator.restartable:
self.restart_game_button.setEnabled(False)
self.restart_game_button.setText(
f"{self.restart_game_button.text()}\n"
"[Unavailable (check logs)]")
self.restart_game_button = None
self.game = Game(self.emulator)
if self.game_app_rect:
self.game.ui['GAME_APP'].button = Rect(*self.game_app_rect)
def manualGame():
print("\n== init manual setting game ==")
height = 20
width = 20
game = Game(height, width)
obstacles = [{"x": 1, "y": 1}, {"x": 2, "y": 2}, {"x": 3, "y": 3}]
targets = [{"x": 10, "y": 10}, {"x": 12, "y": 12}, {"x": 13, "y": 13}]
game.setObstacles(obstacles)
game.setTargets(targets)
agents = {
0: Agent(0, 0, 0, height, width), # id, x, y, height, width
1: Agent(1, 14, 14, height, width),
2: Agent(2, 15, 15, height, width),
}
game.setAgents(agents)
game.setScore(100, 20, 10, -0.0005, 0, -20)
game.printGodInfo()
print("Score: " + str(game.outputScore()))
print("\n== 1st round ==")
commands = []
commands.append(Command(0, 0, 1)) # id, dx, dy
commands.append(Command(1, -1, 1))
commands.append(Command(2, 1, -1))
game.runOneRound(commands)
game.printConsoleInfo()
print("Score: " + str(game.outputScore()))
print("\n== 2ed round ==")
commands = []
commands.append(Command(0, 1, 1))
commands.append(Command(1, -1, 1))
commands.append(Command(2, 1, -1))
game.runOneRound(commands)
game.printConsoleInfo()
print("Score: " + str(game.outputScore()))
print("\n== 3ed round ==")
commands = []
commands.append(Command(0, 1, 1))
commands.append(Command(1, -1, 1))
commands.append(Command(2, -1, 0))
game.runOneRound(commands)
game.printConsoleInfo()
print("Score: " + str(game.outputScore()))
def newGame():
global game
height = int(request.args.get("height"))
width = int(request.args.get("width"))
t = (height + width) / 2
game = Game(height, width)
game.setRandomMap(5, int(t * 0.4)**2, int(t * 0.3)**2)
game.setScore()
game.printGodMap()
game.runOneRoundwithoutMovement()
game.printConsoleMap()
return game.jsonMap()
def testManualGameImageOutput2():
print("\n== init manual setting game ==")
height = 20
width = 20
mode = {0: False, 1: False, 2: False}
#now target = {0:{},1:{},2:{}}
belongs = {0: [], 1: [], 2: []}
game = Game(height, width)
game.setRandomMap(0, 50, 0) # numbers of agents, targets, obstacles
game.setScore(100, 10, -0.01, -100)
game.printGodMap()
agents = {
0: Agent(0, 0, 0, height, width, r=5), # id, x, y, height, width
1: Agent(1, width - 1, 0, height, width,
r=5), # id, x, y, height, width
2: Agent(2, int(width / 2), height - 1, height, width,
r=5), # id, x, y, height, width
}
game.setAgents(agents)
#agents[id].x,game.consolemap.targets
game.printConsoleMap()
game.runOneRound([Command(0, 1, 1), Command(1, -1, 1), Command(2, -1, -1)])
for item in game.consolemap.targets:
index = 0
if target_agent_len(item, agents[index]) > target_agent_len(
item, agents[1]):
index = 1
if target_agent_len(item, agents[index]) > target_agent_len(
item, agents[2]):
index = 2
belongs[index].append(item)
print(belongs)
for i in range(3):
if mode[i] == False:
target_find = belongs[i][0]
for target_list in belongs[i]:
if target_agent_len(target_list, agents[i]) < target_agent_len(
target_find, agents[i]):
target_find = target_list
print(target_find)
mode[i] = True
game.printConsoleMap()
'''for i in range(0, 10):
def __init__(self, emulator):
"""Class initialization.
:param lib.emulators.android_emulator.AndroidEmulator: instance of game emulator.
"""
super().__init__()
self.setupUi(self)
set_default_icon(window=self)
self.emulator = emulator
self.game = Game(self.emulator)
self.screen_image = ScreenImageLabel(widget=self.screen_image_label,
emulator=self.emulator)
self.set_visibility_to_all(True)
self.is_game_opened_q()
self.game_app_rect = None # type: Rect
self.screen_image_label.mousePressEvent = self.screen_click_event
self.ready_to_press = False
def torchGame():
print("\n== init random game ==")
game = Game(128, 128) # height, width
t = 128 + 128 / 2
game.setRandomMap(5, int(t * 0.3)**2, int(t * 0.1)**2)
game.setScore()
# numbers of agents, targets, obstacles
#game.printGodInfo()
print("\n== 1st round ==")
game.torchNext()
print("\n== 2ed round ==")
game.torchNext()
def initialGame(self):
#initial the game envirnment for th replay buffer
t = (self.height + self.width) / 2
self.game = Game(self.height, self.width)
self.game.setRandomMap(self.agent_numbers, int(t * 0.3) ** 2, 1)
self.game.setScore(self.acquisition_sum, self.explored_target_sum, self.explored_sum, self.time_decrease, self.crash_time_penalty, self.crash_sum)
commands = [Command(i, 0, 0) for i in range(self.agent_numbers)]
self.game.runOneRound(commands)
#the memory tensor of the model in the lstm
self.hx = torch.zeros([self.agent_numbers, 512], dtype=torch.float32)
self.cx = torch.zeros([self.agent_numbers, 512], dtype=torch.float32)
self.bot_observe = [self.game.outputAgentImage(i) for i in range(self.agent_numbers)]
self.bot_observe = np.array(self.bot_observe).astype(np.uint8)
print('New Game!')
def testManualGameImageOutput2():
print("\n== init manual setting game ==")
height = 40
width = 40
crash = 0
mode = {
0: False,
1: False,
2: False
} #agents' mode True if agent has target rightnow
found_target = []
now_target = {0: [], 1: [], 2: []}
belongs = {0: [], 1: [], 2: []}
cmd = []
game = Game(height, width)
game.setRandomMap(0, 200, 0) # numbers of agents, targets, obstacles
#game.setScore(100, 10, -0.01, -100)
game.printGodMap()
agents = {
0: Agent(0, 0, 0, height, width, r=5), # id, x, y, height, width
1: Agent(1, width - 1, 0, height, width,
r=5), # id, x, y, height, width
2: Agent(2, int(width / 2), height - 1, height, width,
r=5), # id, x, y, height, width
}
game.setAgents(agents)
##########
game.runOneRoundwithoutMovement()
game.printConsoleMap()
round = 1
while (game.consolemap.targets != []
or haveunseenspace(game.consolemap.areas, height, width)):
print("====the %d round" % round)
found_target = game.consolemap.targets
#print("found:",found_target)
#print("agent mode",mode)
for item in found_target: # cluster the target
index = 0
if target_agent_len(item, agents[index]) > target_agent_len(
item, agents[1]):
index = 1
if target_agent_len(item, agents[index]) > target_agent_len(
item, agents[2]):
index = 2
belongs[index].append(item)
cmd = [] # store the new command for agents
for i in agents:
if mode[i] == False: # assign a target to agent
now_target[i] = []
for target_list in belongs[i]:
if now_target[i] == [] and target_list != []:
now_target[i] = target_list
mode[i] = True
else:
if target_agent_len(target_list,
agents[i]) < target_agent_len(
now_target[i], agents[i]):
now_target[i] = target_list
no_target_command = {
0: {
"dx": 0,
"dy": 0
},
1: {
"dx": 1,
"dy": -1
},
2: {
"dx": -1,
"dy": -1
},
3: {
"dx": -1,
"dy": 1
},
4: {
"dx": 1,
"dy": 1
},
}
if mode[i] == False: # assign the cammand to agent
direction = no_target_walk(game.getmap(), agents[i])
cmd.append(
Command(agents[i].id, no_target_command[direction]["dx"],
no_target_command[direction]["dy"]))
print("agent %d goes" % agents[i].id,
no_target_command[direction]["dx"], "and",
no_target_command[direction]["dy"])
elif mode[i] == True:
cmd.append(walk(now_target[i], agents[i]))
mode[i] = False
game.runOneRound(cmd)
for i in agents: #calculate crash time
for j in range(i + 1, len(agents)):
if agents[i].x == agents[j].x and agents[i].y == agents[j].y:
crash += 1
print(found_target)
game.printConsoleMap()
belongs = {0: [], 1: [], 2: []}
round += 1
print("crush time: %d" % crash)
print("finish")
os.putenv("TERM", "xterm-256color")
show_title_screen()
init()
menu = Menu()
while True:
game = None
menu.songs = []
try:
menu.start()
except SelectedSong as song_exc:
game = Game(song_exc.get_song())
except QuitGame:
break
try:
game.start()
except SheetFinished:
game.stop_music()
show_finish_screen(game)
except GameLost:
game.stop_music()
show_failure_screen(game)
except Back:
game.stop_music()
except QuitGame:
game.stop_music()
from lib.game.missions.timeline import TimelineBattle
from lib.game.missions.world_boss_invasion import WorldBossInvasion
from lib.game.missions.squad_battle import SquadBattle
from lib.game.missions.world_boss import WorldBoss
from lib.game.routines import DailyTrivia, ShieldLab, EnhancePotential
from lib.game.game import Game
logger = logging.get_logger(__name__)
logging.create_file_handler()
if __name__ == '__main__':
nox = NoxPlayer(
"NoxPlayer") # Use your window's name of emulator to get a handle
game = Game(nox)
game.set_mission_team(1) # Setup your team for common missions to get EXP
game.set_timeline_team(2) # Setup your team for PVP missions
game.ACQUIRE_HEROIC_QUEST_REWARDS = True # Setup ability to collect Heroic Quest rewards
# Daily routines
dt = DailyTrivia(game).do_trivia()
sl = ShieldLab(game).collect_antimatter()
# Missions
wbi = WorldBossInvasion(game).do_missions()
dd = DoomsDay(game).do_missions()
botc = BeginningOfTheChaos(game).do_missions()
xm = MutualEnemy(game).do_missions()
fotu = FateOfTheUniverse(game).do_missions()
tw = TwistedWorld(game).do_missions()