def create_system(system, fe="HyperSpin"):
rl = RocketLauncher(system=system)
rl.new_system()
dont_search = [
"Commodore 64", "Commodore VIC-20", "MAME", "Sega CD",
"Sega Dreamcast", "Nintendo DS", "Sony PlayStation"
]
# Build ROM set
platform = System(system=system)
if system in dont_search:
curated_sets = platform.software_lists + platform.nointro + platform.goodset
else:
curated_sets = platform.tosec_dirs(
) + platform.software_lists + platform.nointro + platform.goodset
platform.build_rom_set(source_set=curated_sets)
emu = EmuMovies(system=system)
emu.create_blanks()
# Set up Media
rl.set_up_media(action="link")
if fe == "HyperSpin" or fe == "all":
hs = HyperSpin(system=system)
hs.new_system(action="link", three_d=False)
elif fe == "RetroFE" or fe == "all":
pass
elif fe == "MaLa" or fe == "all":
pass
def __init__(self, system):
Databases.__init__(self, system)
HyperList.__init__(self, system)
System.__init__(self, system)
self.system = system
self.full_sys = {
"name": self.system,
"type": self.platform_type,
"year": self.year,
"manufacturer": self.manufacturer,
"enabled": "true"
}
# Paths
self.rl_ui_path = os.path.join(self.rl_path, "RocketLauncherUI")
self.settings_path = os.path.join(self.rl_path, "Settings",
self.system)
self.modules_path = os.path.join(self.rl_path, "Modules")
# Media
self.media_path = os.path.join(self.rl_path, "Media")
self.artwork_path = os.path.join(self.media_path, "Artwork",
self.system)
self.backgrounds_path = os.path.join(self.media_path, "Backgrounds",
self.system)
self.bezels_path = os.path.join(self.media_path, "Bezels", self.system)
self.controller_path = os.path.join(self.media_path, "Controller",
self.system)
self.fade_path = os.path.join(self.media_path, "Fade", self.system)
self.guides_path = os.path.join(self.media_path, "Guides", self.system)
self.logos_path = os.path.join(self.media_path, "Logos", self.system)
self.manuals_path = os.path.join(self.media_path, "Manuals",
self.system)
self.multi_path = os.path.join(self.media_path, "MultiGame",
self.system)
self.music_path = os.path.join(self.media_path, "Music", self.system)
self.video_path = os.path.join(self.media_path, "Videos", self.system)
self.media_paths = [
self.artwork_path, self.backgrounds_path, self.bezels_path,
self.controller_path, self.fade_path, self.guides_path,
self.logos_path, self.manuals_path, self.multi_path,
self.music_path, self.video_path
]
# UI
self.db_path = os.path.join(self.rl_ui_path, "Databases", self.system)
self.icon_path = os.path.join(self.rl_ui_path, "Media", "Icons")
self.ui_logo_path = os.path.join(self.rl_ui_path, "Media", "Logos")
self.ui_settings_path = os.path.join(self.rl_ui_path, "Settings")
def put(self, system_id):
data = request.get_json()
if data is None or not SystemModel.valid_update_keys(data.keys()):
abort(401)
current_system = SystemModel.get_by_id(system_id)
if not OwnerModel.is_owner_of(current_user, current_system):
abort(401)
try:
current_system.update_from(data)
except ValueError as e:
abort(400, e.message)
return jsonify(current_system.to_json())
def post(self):
data = request.get_json()
system_id = data.get('system_id')
user_email = data.get('user_email')
if None in (system_id, user_email):
abort(400)
system = System.from_system_id(system_id)
user = User.from_email(user_email)
if None in (system, user):
abort(400)
if current_user == user:
abort(400)
if not Owner.is_owner_of(current_user, system):
abort(401)
sec_obj = SecondaryModel.create(user, system)
sec_obj.put()
secondaries = SecondaryModel.from_system(system)
if sec_obj not in secondaries:
secondaries.append(sec_obj)
ret = self.get_response_map_from_secondaries(secondaries)
return jsonify(ret)
def get(self, system_id):
"""
:param system_id:
:return: is_connected, type_id, latest_data
"""
data = SystemModel.get_by_id(system_id)
return jsonify(data.to_json())
def __init__(self, system=None):
Arcade.__init__(self)
System.__init__(self, system)
self.system = system
# HyperSpin Paths
self.db_path = os.path.join(self.hs_path, "Databases", self.system)
self.media_path = os.path.join(self.hs_path, "Media", self.system)
self.settings_path = os.path.join(self.hs_path, "Settings")
# Images
self.images_path = os.path.join(self.media_path, "Images")
self.artwork1_path = os.path.join(self.images_path, "Artwork1")
self.artwork2_path = os.path.join(self.images_path, "Artwork2")
self.artwork3_path = os.path.join(self.images_path, "Artwork3")
self.artwork4_path = os.path.join(self.images_path, "Artwork4")
self.backgrounds_path = os.path.join(self.images_path, "Backgrounds")
self.genre_backgrounds_path = os.path.join(self.images_path, "Genre", "Backgrounds")
self.genre_wheel_path = os.path.join(self.images_path, "Genre", "Wheel")
self.letters_path = os.path.join(self.images_path, "Letters")
self.other_path = os.path.join(self.images_path, "Other")
self.particle_path = os.path.join(self.images_path, "Particle")
self.special_path = os.path.join(self.images_path, "Special")
self.wheel_path = os.path.join(self.images_path, "Wheel")
# Other Media
self.themes_path = os.path.join(self.media_path, "Themes")
self.video_path = os.path.join(self.media_path, "Video")
self.default_systems = ["Atari 5200",
"Atari Lynx",
"Daphne",
"NEC TurboGrafx-16",
"Nintendo 64",
"Nintendo Entertainment System",
"Nintendo Game Boy Advance",
"Panasonic 3DO",
"Sega 32X",
"Sega CD",
"Sega Dreamcast",
"Sega Game Gear",
"Sega Genesis",
"Sega Master System",
"Sega Model 2",
"SNK Neo Geo",
"SNK Neo Geo Pocket Color",
"Sony PlayStation",
"Super Nintendo Entertainment System"]
def _system_ini(self):
"""
"_system_ini" sets default values for the way the System menu looks in HyperSpin and sets the
ROM path and extensions
Args:
self
Returns:
None
Raises:
None
"""
platform = System(system=self.system)
if type(platform.extensions) == list:
extension = "zip, 7z, {}".format(platform.extensions[0])
elif type(platform.extensions) == str:
extension = "zip, 7z, {}".format(platform.extensions)
else:
extension = "zip, 7z"
msg = "HS: Setting {} Defaults".format(self.system)
logger.info(msg)
ini = os.path.join(self.hs_path, "Settings", self.system + ".ini")
if os.path.isfile(ini):
config = configparser.ConfigParser()
config.optionxform = str
config.read(ini)
else:
src_ini = os.path.join(self.hs_path, "Settings", "MAME.ini")
shutil.copy(src_ini, ini)
config = configparser.ConfigParser()
config.optionxform = str
config.read(ini)
config.set("exe info", "rompath", os.path.relpath(os.path.join(self.rom_path, self.system), self.hs_path))
config.set("exe info", "romextension", extension)
config.set("wheel", "alpha", "1")
config.set("wheel", "style", "vertical")
config.set("wheel", "y_rotation", "center")
config.set("wheel", "norm_large", "256")
config.set("wheel", "norm_small", "200")
config.set("wheel", "vert_large", "300")
config.set("wheel", "vert_small", "150")
config.set("wheel", "horz_wheel_y", "575")
config.set("video defaults", "path", os.path.join(self.media_path, "Video"))
config.set("sounds", "game_sounds", "false")
config.set("sounds", "wheel_click", "false")
config.set("navigation", "remove_info_wheel", "true")
config.set("navigation", "remove_info_text", "true")
with open(ini, mode="w") as f:
config.write(f, space_around_delimiters=False)
def get(self, system_id):
system = System.from_system_id(system_id)
if system is None or not Owner.is_owner_of(current_user, system):
abort(400)
secondaries = SecondaryModel.from_system(system)
ret = self.get_response_map_from_secondaries(secondaries)
return jsonify(ret)
def get_system(self, system_id):
"""
:param system_id:
:return: system details
"""
url = "{}/systems/{}/".format(BASE_URL, system_id)
results = self.r.get(url, headers=self._get_auth_header()).json()
return System(**results['systems'])
def update_system(system,
source_set,
update_roms=True,
action="copy",
three_d=False,
fe="HyperSpin",
update_rl_media=False):
# Build ROMs of missing ROMs
platform = System(system=system)
if update_roms:
emu = EmuMovies(system=system)
emu.create_blanks()
if len(source_set) == 0:
curated_sets = platform.tosec_dirs(
) + platform.software_lists + platform.nointro + platform.goodset
platform.build_rom_set(source_set=curated_sets)
else:
platform.build_rom_set(source_set=source_set)
# Update the Media
if update_rl_media:
rl = RocketLauncher(system=system)
rl.set_up_media(action="link")
if fe == "HyperSpin" or fe == "all":
hs = HyperSpin(system=system)
hs.update_system(update_roms=update_roms,
action=action,
three_d=three_d)
elif fe == "RetroFE" or fe == "all":
pass
elif fe == "MaLa" or fe == "all":
pass
def _write_hs_menu(self, sort=False, remove=False):
"""
"write_hs_menu" is a method that adds a system to the Main Menu.xml database, a.k.a. the Main Menu
Args:
self
sort (required): If true, sorts by Manufacturer, Platform Type and Year
remove (optional): If tru, removes the system from the Menu
Returns:
None
Raises:
None
"""
systems = self._read_hs_menu()
if remove:
systems.remove(self.system)
elif self.system not in systems:
systems.append(self.system)
platform = {}
platforms = []
for system in systems:
plat = System(system)
platform["name"] = plat.system
platform["manufacturer"] = plat.manufacturer.lower()
platform["type"] = plat.platform_type.lower()
platform["year"] = plat.year
platforms.append(dict(platform))
# Sort by Manufacturer, then by Platform type, then by Year
if sort:
final_systems = sorted(platforms, key=lambda platform: (
platform["manufacturer"],
platform["type"],
platform["year"]))
else:
final_systems = platforms
xml = os.path.join(self.hs_path, "Databases", "Main Menu", "Main Menu.xml")
try:
shutil.copy(xml, "{}_backup_{}.xml".format(xml, time.strftime("%Y%m%d")))
root = ET.Element("menu")
for name in final_systems:
ET.SubElement(root, "game", name=name["name"])
except FileNotFoundError:
msg = "System Menu does not exist"
logger.info(msg)
root = ET.Element("menu")
for name in final_systems:
ET.SubElement(root, "game", name=name["name"])
pretty = self.prettify(root)
with open(xml, mode="w") as xml:
xml.write(pretty)
def get_systems(self):
"""
:return: list of systems
"""
url = "{}/systems/".format(BASE_URL)
results = self.r.get(url, headers=self._get_auth_header()).json()
systems = []
for system in results['systems']:
systems.append(System(**system))
return systems
def update_device_association(self, serial_number, req_data):
system_id = req_data.get("system_id")
device = DeviceModel.from_serial_number(serial_number)
if device is None:
abort(400, 'No such device.')
if system_id is not None:
system = System.from_system_id(system_id)
return self.associate_device(device, system)
else:
return self.disassociate_device(device)
def put(self, system_id):
data = request.get_json()
if data is None or not SystemModel.valid_update_keys(data.keys()):
abort(401)
ks_status = data.get("ks_enabled")
if ks_status is None:
abort(400)
current_system = SystemModel.get_by_id(system_id)
owner = OwnerModel.is_owner_of(current_user, current_system)
is_sec, _ = SecondaryModel.is_secondary_of(current_user,
current_system)
if not (owner or is_sec):
abort(401)
current_system.ks_enabled = ks_status
current_system.put()
return jsonify(current_system.to_json())
def create_blanks(self, extension="txt"):
"""
"create_blanks" Method creates temporary files in a new directory in your EmuMovies folder.
This proves useful if you would like to use EmuMovies to gather the artwork
and movies for ROMs you may not have.
Args:
extension(optional, default = txt): extension of the file
Returns:
None
Raises:
None
"""
from models.system import System
platform = System(system=self.system)
db = Databases(system=self.system)
system, roms = db.read_system_xml(
db=os.path.join(self.rl_path, "RocketLauncherUI", "Databases",
self.system, "{}.xml".format(self.system)))
temp_dir = os.path.join(self.emu_movies_path, platform.emu_movies_name,
"_Temp")
if not os.path.isdir(temp_dir):
os.makedirs(temp_dir)
num = 0
num_of_roms = len(roms)
for rom in roms:
if num % 100 == 0:
msg = "Creating {} of {} temp ROM Files".format(
num, num_of_roms)
logger.info(msg)
elif num == num_of_roms:
msg = "Creating {} of {} temp ROM Files".format(
num + 1, num_of_roms)
logger.info(msg)
num += 1
tempfile = "{}.{}".format(rom["name"], extension)
fname = os.path.join(temp_dir, tempfile)
with open(fname, mode="w", encoding="UTF-8") as f:
f.write("ROM Name: {}\n".format(rom["name"]))
f.write("Description: {}\n".format(rom["description"]))
f.write("Clone Of: {}\n".format(rom["cloneof"]))
f.write("CRC: {}\n".format(rom["crc"]))
f.write("Manufacturer: {}\n".format(rom["manufacturer"]))
f.write("Year: {}\n".format(rom["year"]))
f.write("Genre: {}\n".format(rom["genre"]))
f.write("Rating: {}\n".format(rom["rating"]))
f.write("Enabled: {}".format(rom["enabled"]))
def get(self, system_id):
system = SystemModel.from_system_id(system_id)
is_owner = OwnerModel.is_owner_of(current_user, system)
is_sec, _ = SecondaryModel.is_secondary_of(current_user, system)
if not (is_owner or is_sec):
abort(401)
frames = system.get_latest_data_frames()
devid_loc = {
f.device_key.get().serial_num: get_download_url(f.location)
for f in frames
}
return jsonify(devid_loc)
def read_database(self):
"""
"read_database" Reads the No Intro XML based databases and sorts the information into a dictionary of
values to be used to create a RocketLauncher Database.
Args:
self
Returns:
Dictionary of ROM names with descriptive info
Raises:
None
"""
root_path = os.path.join(self.clrmamepro, "datfiles", "NoIntro")
files = os.listdir(root_path)
from models.system import System
platform = System(self.system)
db = ""
for fname in files:
no_intro_name = fname.split(" (")
if no_intro_name[0] == platform.nointro_db:
db = os.path.join(root_path, fname)
msg = "Using the database found at {}".format(db)
logger.info(msg)
with open(db, mode="r") as fd:
doc = xmltodict.parse(fd.read())
output = {}
roms = []
data = doc["datafile"]["game"]
for rom_info in data:
output["name"] = rom_info["@name"]
output["crc"] = rom_info["rom"]["@crc"].zfill(8).upper()
output["md5"] = rom_info["rom"]["@md5"]
output["sha1"] = rom_info["rom"]["@sha1"]
roms.append(dict(output))
languages = [
'Cs', 'Da', 'De', 'El', 'En', 'Es', 'Fi', 'Fr', 'Hu', 'It', 'Ja',
'Ko', 'Nl', 'No', 'Pl', 'Pt', 'Ru', 'Sv', 'Tr'
]
regions = [
'Asia', 'Australia', 'Brazil', 'Canada', 'China', 'Denmark',
'Europe', 'Finland', 'France', 'Germany', 'Greece', 'Hong Kong',
'Italy', 'Japan', 'Korea', 'Mexico', 'Netherlands', 'Norway',
'Russia', 'Spain', 'Sweden', 'Taiwan', 'USA', 'Unknown', 'World'
]
bad_dump = "[b]"
bios = "[BIOS]"
for rom in roms:
temp1 = rom["name"].replace(bad_dump, "(b)")
temp2 = temp1.replace(")", "")
rom_list = temp2.split(" (")
rom["short_desc"] = rom_list[0]
if bios in rom_list[0]:
rom["bios"] = True
if len(rom_list[1:]) > 1:
for i in rom_list[1:]:
if i == "b":
rom["bad_dump"] = True
elif i in regions:
rom["region"] = i
elif i == "Demo":
rom["demo"] = True
elif "Kiosk" in i:
rom["Kiosk"] = True
elif i == "Unl":
rom["unl"] = True
elif "Rev" in i:
rom["rev"] = i
elif "NDSi Enhanced" in i:
rom["NDSi Enhanced"] = True
elif "SGB Enhanced" in i:
rom["SGB Enhanced"] = True
elif "GB Compatible" in i:
rom["GB Compatible"] = True
elif "Wii Virtual Console" in i:
rom["Wii Virtual Console"] = True
elif "iQue" in i:
rom["iQue"] = True
elif "Proto" in i:
rom["prototype"] = True
elif "Beta" in i:
rom["beta"] = True
elif i in languages:
rom["language"] = [i]
elif "," in i:
stuff = [x.strip() for x in i.split(',')
] # Split the string and remove whitespace
for j in stuff:
if j in languages:
rom["language"] = stuff
elif j in regions:
rom["region"] = stuff
elif len(rom_list[1:]) == 1:
if "," in rom_list[1]:
stuff = rom_list[1].split(", ")
if stuff[0] in regions:
rom["region"] = stuff
elif rom_list[1] in regions:
rom["region"] = rom_list[1]
return roms
def random_system():
s = System.create(60)
s.put()
yield s
s.key.delete()
plt.close("all")
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
phi_init = 0.0
t_sim_end = 60 # sec
sampling_rate = 100 # Hz
N = t_sim_end * sampling_rate + 1
time = np.linspace(0, t_sim_end, num=N)
''' Define flight plan as below '''
wpt_list = np.array([20., 0., 20., 800.])
wpt_arr = np.ndarray(shape=(2, 2), dtype=float, buffer=wpt_list)
''' Define simulation components '''
sys = System(phi=phi_init, psi=0, use_jac=True)
env = Env(wind_dir_to=np.deg2rad(120), wind_spd=13)
fpl = FlightPlan(wpt_arr)
ac = Aircraft(fpl)
''
sim = Sim(ac, sys, env, time, verbose=False)
#sim.override_roll(np.deg2rad(40))
sim.run_simulation()
fig1 = plt.figure()
wp = ac.flight_plan.wpt_arr
plt.plot(sim.logs['S_x'][:-2], sim.logs['S_y'][:-2], wp[:, 0], wp[:, 1], 'ro',
wp[:, 0], wp[:, 1], 'r')
# plt.plot(time[:-2], sim.logs['x'][:-2])
plt.grid()
N = t_sim_end * sampling_rate + 1
time = np.linspace(0, t_sim_end, num=N)
''' Define flight plan as below '''
# TODO the two mirrored flight plans below demonstrate the twofold effects of the suggested improvements
wpt_list = np.array([0., 0., 0., 80., -20., 40., -20., 300., 200., 300.])
wpt_listA = np.array([0., 0., 0., 80., 20., 40., 20., 300., -200., 300.])
wpt_listB = np.array([0., 0., 0., 80., 150., 80., 150., 300., -200., 300.])
wpt_listC = np.array([0., 0., 0., 80., -150., 80., -150., 300., 200., 300.])
wpt_arr = np.ndarray(shape=(5, 2), dtype=float, buffer=wpt_listA)
''' Define simulation components '''
ac_tas = 15.
env = Env(wind_dir_to=np.deg2rad(90), wind_spd=12)
init = bn.get_wind_corr(track_angle=np.deg2rad(0),
tas=ac_tas,
wind_obs=env.wind_to)
sys = System(phi=phi_init, psi=init[0], use_jac=True)
fpl = FlightPlan(wpt_arr, accept_dist=60)
rreg = RollRegulator(phi_max=42) # default phi_max is 35
nreg = L1NavRegulator(period=20) # default period is 30
ac = Aircraft(fpl, roll_reg=rreg, nav_reg=nreg, tas=ac_tas)
sim = Sim(ac, sys, env, time, verbose=False)
#sim.override_roll(np.deg2rad(40))
sim.run_simulation()
fig1 = plt.figure()
wp = ac.flight_plan.wpt_arr
plt.plot(sim.logs['S_x'][:-2], sim.logs['S_y'][:-2], wp[:, 0], wp[:, 1], 'ro',
wp[:, 0], wp[:, 1], 'r', sim.logs['S_x'][:-2:f * 2],
sim.logs['S_y'][:-2:f * 2], 'gx')
import time
from tkinter import *
from gui.create_table import create_table
from models.system import System, CacheL2, Memory, Lock
from threading import Thread
from utils.utils import format_instruction
lock = Lock()
cache_l2 = CacheL2()
memory = Memory()
system = System(cache_l2, memory, lock)
# system.change_mode(1)
system.start()
def run_gui():
container = Canvas(root, width=940, height=40, bg='#42db8c')
container.place(x=0, y=460)
p_numbers = ["P0", "P1", "P2", "P3"]
p_number_var = StringVar()
p_number_var.set("P0")
p_number = OptionMenu(root, p_number_var, *p_numbers)
p_number.place(x=30, y=470, width=50)
instruction_types = ["READ", "WRITE", "CALC"]
instruction_type_var = StringVar()
instruction_type_var.set("READ")
instruction_type = OptionMenu(root, instruction_type_var,
*instruction_types)
instruction_type.place(x=90, y=470, width=100)
def detect(user_id, system_name, filename):
document_warn_events = []
possible_abnormal_clusters = []
old_result = Result.objects(path=f'{system_name}/{filename}')
if old_result:
events = old_result.get().events
for event in events:
if event.status == 'WARN':
document_warn_events.append(event)
clusters = old_result.get().clusters
for cluster in clusters:
if cluster.num_possible_abnormal_events != 0:
possible_abnormal_clusters.append(cluster)
else:
parser = LogParser(
f'{config.UPLOADS_FOLDER}/{user_id}/{system_name}/{filename}')
events, log_sequences = parser.parse()
extractor = FeatureExtractor(log_sequences, events)
log_sequences = extractor.extract()
clustering = Clustering(log_sequences, events)
log_sequences, clusters = clustering.cluster()
document_clusters = []
for cluster in clusters:
document_clusters.append(
Cluster(centroid=cluster.get('centroid'),
num_possible_abnormal_events=cluster.get(
'num_possible_abnormal_events'),
possible_abnormal_events=cluster.get(
'possible_abnormal_events')))
document_events = []
document_names = []
for name, status in events.items():
document_events.append(Event(name=name, status=status))
document_names.append(name)
system = System.objects(name=system_name).first()
system_events_name = [event.name for event in system.events]
setEvents = set(document_names)
setSystemEventsName = set(system_events_name)
unregisteredEvents = list(setEvents - setSystemEventsName)
document_unregister_events = []
for name, status in events.items():
if name in unregisteredEvents:
document_unregister_events.append(
Event(name=name, status=status))
if status == 'WARN':
document_warn_events.append(Event(name=name, status=status))
system.events = document_unregister_events
system.save()
result = Result(user_id=user_id,
path=f'{system_name}/{filename}',
events=document_events,
clusters=document_clusters)
result.save()
for cluster in document_clusters:
if cluster.num_possible_abnormal_events != 0:
possible_abnormal_clusters.append(cluster)
return jsonify({
'events': document_warn_events,
'clusters': possible_abnormal_clusters
})
def test_system_from_id_none():
assert System.from_system_id(None) is None
def test_system_from_id(random_system):
assert random_system == System.from_system_id(
random_system.key.integer_id())
def loadSystems(self):
self.systems = System.select()
def create(cls, user_obj, grace):
system = System.create(grace)
system.put()
return cls(user_key=user_obj.key, system_key=system.key)
def loadSystems(self):
self.systems = System.select()
