def update_search(self): search = LauncherSettings.get("config_search").strip().lower() print("search for", search) words = [] special = [] for word in search.split(" "): word = word.strip() if not word: continue if ":" in word[1:-1]: special.append(word) else: words.append(word) terms = GameNameUtil.extract_search_terms(" ".join(words)) terms.update(special) database = Database.get_instance() try: have = int(LauncherSettings.get("database_show_games")) except ValueError: # default is show all downloadable and locally available games have = 1 items = database.find_games_new( " ".join(terms), have=have, list_uuid=LauncherSettings.get("game_list_uuid"), ) self.set_items(items)
def scan_thread(cls): try: with Database.get_instance() as database: cls._scan_thread(database) except Exception as e: cls.error = str(e) traceback.print_exc() # else: # if cls.on_status: # cls.on_status(("", _("Committing data..."))) # database.commit() def on_done(): # FIXME: these should be removed soon LauncherSettings.set("last_scan", str(time.time())) LauncherSettings.set("__config_refresh", str(time.time())) # this must be called from main, since callbacks are broadcast # when settings are changed LauncherSignal.broadcast("scan_done") LauncherConfig.update_kickstart() # call on_done from main thread fsui.call_after(on_done) cls.running = False
def run(self): self.defragment(FileDatabase.get_instance(), "Files.sqlite") self.stop_check() self.defragment(LockerDatabase.instance(), "Locker.sqlite") self.stop_check() self.defragment(fsgs.get_game_database(), "Amiga.sqlite") self.stop_check() self.defragment(Database.get_instance(), "Database.sqlite")
def load_configuration(self, item): if item[str("uuid")]: LauncherSettings.set("parent_uuid", item[str("uuid")]) else: config_path = Database.get_instance().decode_path( item[str("path")]) print("load config from", config_path) LauncherConfig.load_file(config_path) LauncherSettings.set("parent_uuid", "")
def load_configuration(self, item): if item[str("uuid")]: # This triggers the variant browser to load variants for the game. # FIXME: This needs to be moved to config, somehow. get_config(self).set(PARENT_UUID, item["uuid"]) # FIXME: REMOVE # LauncherSettings.set(PARENT_UUID, item["uuid"]) else: config_path = Database.get_instance().decode_path( item[str("path")]) print("load config from", config_path) ConfigLoader(get_config(self)).load_config_file(config_path)
def synchronize(self): if not self.is_authenticated(): print("ListsSynchronizer: not authenticated") return if self.stop_check(): return if "lists" not in self.context.meta: # Haven't looked up synchronization information from the server. return self.set_status(gettext("Updating game lists...")) database = Database.instance() cursor = database.cursor() cursor.execute("SELECT uuid, name, sync FROM game_list") # existing_lists = {} existing_syncs = {} for row in cursor: uuid, name, sync = row # existing_lists[uuid] = { # "name": name, # "sync": sync, # } existing_syncs[uuid] = sync # existing_syncs.sort() for list_uuid, list_info in self.context.meta["lists"].items(): if list_info["sync"] == existing_syncs.get(list_uuid, None): print("[SYNC] List {} already synced".format(list_uuid)) else: self.set_status( gettext("Updating list '{0}'...".format(list_info["name"])) ) self.synchronize_list(database, list_uuid, list_info) for existing_list_uuid in existing_syncs: for list_uuid in self.context.meta["lists"]: if list_uuid == existing_list_uuid: break else: # this old list should be removed self.set_status( gettext("Removing list {0}".format(existing_list_uuid)) ) self.remove_list(database, existing_list_uuid) database.commit()
def populate_list(self): database = Database.instance() self.game_lists = database.get_game_lists() if len(self.game_lists) > 0: self.game_lists.insert(0, ["", self.ITEM_SEPARATOR]) self.game_lists.insert(0, [Database.GAME_LIST_GAMES, gettext("Games")]) self.game_lists.insert( 0, [Database.GAME_LIST_CONFIGS, gettext("Configs")] ) self.game_lists.insert(0, ["", gettext("Configs and Games")]) self.clear() for item in self.game_lists: list_name = item[1] if list_name == "Favorites": list_name = gettext("Favorites") self.add_item(list_name)
def create_game_items(cls, words, args=None, filters=None, list_uuid=None): if filters is None: filters = [] search = " ".join(words) item_list = [] local_game_database = Database.instance() for game in local_game_database.find_games_new(search=search, database_only=True, list_uuid=list_uuid): item = GameItem(game) for filter in filters: pass # if not filter(game): # break else: item_list.append(item) return item_list
def set_rating_for_variant(variant_uuid, rating): # FIXME: Do asynchronously, add to queue client = OGDClient() result = client.rate_variant(variant_uuid, like=rating) like_rating = result.get("like", 0) work_rating = result.get("work", 0) database = Database.instance() cursor = database.cursor() cursor.execute("DELETE FROM rating WHERE game_uuid = ?", (variant_uuid, )) cursor.execute( "INSERT INTO rating (game_uuid, work_rating, like_rating) " "VALUES (?, ?, ?)", (variant_uuid, work_rating, like_rating), ) database.commit() LauncherSettings.set("__variant_rating", str(like_rating))
def activate(self, menu): print("PlatformMenuItem.activate") new_menu = create_item_menu(gettext("Select Platform")) menu_path = self.create_menu_path(menu) new_menu.update_path(menu_path) with Database.instance() as database: cursor = database.cursor() cursor.execute( "SELECT DISTINCT platform FROM game WHERE have >= 3 " "ORDER BY platform") items = [] for row in cursor: if not row[0]: continue item = PlatformItem(row[0]) items.append((item.sort_title, item)) for sort_title, item in sorted(items): new_menu.append(item) return new_menu
def load_game_variant(self, variant_uuid): # game_database = fsgs.get_game_database() # values = game_database.get_game_values_for_uuid(variant_uuid) from .Database import Database database = Database.instance() try: database_name = database.find_game_database_for_game_variant( variant_uuid ) except LookupError: return False try: values = self.game.set_from_variant_uuid( database_name, variant_uuid ) except KeyError: # It is possible that the variant is found without game entry, # which raises a KeyError. return False if not values: return False # print("") # for key in sorted(values.keys()): # print(" * {0} = {1}".format(key, values[key])) # print("") from fsgamesys.platforms.platform import PlatformHandler platform_handler = PlatformHandler.create(self.game.platform.id) loader = platform_handler.get_loader(self) self.config.load(loader.load_values(values)) return True
def get_ordered_game_variants(self, game_uuid): print("get_ordered_game_variants game_uuid =", game_uuid) from .Database import Database database = Database.instance() variants = database.find_game_variants_new(game_uuid=game_uuid) print(variants) # ordered_list = [] # FIXME: Merge code with VariantsBrowser.py sortable_items = [] for i, variant in enumerate(variants): game_database = self.game_database(variant["database"]) ( variant["like_rating"], variant["work_rating"], ) = game_database.get_ratings_for_game(variant["uuid"]) ( variant["personal_rating"], ignored, ) = database.get_ratings_for_game(variant["uuid"]) # variant_uuid = variant["uuid"] name = variant["name"] # FIXME: name replacement needed any more? name = name.replace("\n", " (") name = name.replace(" \u00b7 ", ", ") name += ")" if variant["published"] == 0: primary_sort = 1 variant["name"] = "[UNPUBLISHED] " + variant["name"] else: primary_sort = 0 sort_key = ( primary_sort, 1000000 - variant["like_rating"], 1000000 - variant["work_rating"], name, ) sortable_items.append((sort_key, i, variant)) ordered_list = [x[2] for x in sorted(sortable_items)] print("ordered variant list:") for variant in ordered_list: print("-", variant["name"]) # item.configurations = [x[1] for x in ordered_list] select_index = None if select_index is None: # default index selection for i, variant in enumerate(ordered_list): if variant["personal_rating"] == 5: select_index = i break else: for i, variant in enumerate(ordered_list): if variant["have"] >= 3: select_index = i break else: for i, variant in enumerate(ordered_list): if variant["have"] >= 1: select_index = i break else: if len(ordered_list) > 0: select_index = 0 # return ordered_list[select_index]["uuid"] if select_index and select_index > 0: ordered_list.insert(0, ordered_list.pop(select_index)) return ordered_list
def database(self): return Database.instance()
def on_quit_signal(self): database = Database.get_instance() for key, value in self.cache.items(): database.set_last_game_variant(key, value) database.commit()
def update_list(self, game_uuid): print("VariantsBrowser.update_list, game_uuid=", game_uuid) database = Database.get_instance() items = database.find_game_variants_new(game_uuid, have=0) # items = database.search_configurations(self.search) # FIXME: Merge code with # FSGameSystemContext.py:get_ordered_game_variants sortable_items = [] for i, variant in enumerate(items): name = variant["name"] # assert "\n" not in name # only show variant name (without game name) # name = name.split("\n", 1)[-1] game_database = fsgs.game_database(variant["database"]) ( variant["like_rating"], variant["work_rating"], ) = game_database.get_ratings_for_game(variant["uuid"]) ( variant["personal_rating"], _, ) = database.get_ratings_for_game(variant["uuid"]) if variant["published"] == 0: primary_sort = 1 variant["name"] = "[UNPUBLISHED] " + variant["name"] else: primary_sort = 0 sort_key = ( primary_sort, 1000000 - variant["like_rating"], 1000000 - variant["work_rating"], name, ) sortable_items.append((sort_key, i, variant)) # print(sortable_items) self.items = [x[2] for x in sorted(sortable_items)] self.update() # self.set_items(self.items) # self.set_item_count(len(self.items)) self.select_item(None, signal=False) select_index = None list_uuid = LauncherSettings.get("game_list_uuid") if list_uuid: list_variant_uuid = database.get_variant_for_list_and_game( list_uuid, game_uuid) print("game list", list_uuid, "override variant", list_variant_uuid) else: list_variant_uuid = None if list_variant_uuid: # override variant selection from list if possible for i, variant in enumerate(self.items): print(variant["uuid"], variant["name"], list_variant_uuid) if variant["uuid"] == list_variant_uuid: select_index = i print("override select index", select_index) break if select_index is None: # default index selection for i, variant in enumerate(self.items): if variant["personal_rating"] == 5: if variant["have"] >= 3: select_index = i break else: # FIXME: Add warning here that the favorite variant # could not be selected. pass else: for i, variant in enumerate(self.items): if variant["have"] >= 3: select_index = i break else: for i, variant in enumerate(self.items): if variant["have"] >= 1: select_index = i break else: if len(self.items) > 0: select_index = 0 # self.clear() # for i, variant in enumerate(self.items): # self.add_item(variant["name"], icon=self.get_item_icon(i)) self.set_enabled(len(self.items) > 0) if select_index is not None: print("selecting variant index", select_index) self.select_item(select_index) else: NewConfigButton.new_config(get_config(self))
def run(self): with Database.get_instance() as database: self._run(database)
def get_game_lists(cls): result = [] local_game_database = Database.instance() for list_uuid, list_name in local_game_database.get_game_lists(): result.append((list_name, list_uuid)) return result
def save_config(): print("SaveButton.save_config") config = get_config(self) database = Database.get_instance() name = LauncherSettings.get("config_name").strip() if not name: print("no config_name") # FIXME: notify user return file_name = name + get_extension_for_config(config) path = os.path.join( FSGSDirectories.get_configurations_dir(), file_name ) with io.open(path, "w", encoding="UTF-8") as f: f.write("# FS-UAE configuration saved by FS-UAE Launcher\n") f.write( "# Last saved: {0}\n".format( datetime.datetime.today().strftime("%Y-%m-%d %H:%M:%S") ) ) f.write("\n[fs-uae]\n") keys = sorted(fsgs.config.values.keys()) for key in keys: value = config.get(key) if key.startswith("__"): continue if key in LauncherConfig.no_save_keys_set: continue # elif key == "joystick_port_2_mode" and value == "nothing": # continue # elif key == "joystick_port_3_mode" and value == "nothing": # continue if value == LauncherConfig.default_config.get(key, ""): continue if value: f.write("{0} = {1}\n".format(key, value)) # scanner = ConfigurationScanner() # search = ConfigurationScanner.create_configuration_search(name) # name = scanner.create_configuration_name(name) # print("adding", path) # # deleting the path from the database first in case it already exists # database.delete_configuration(path=path) # database.delete_file(path=path) # database.add_file(path=path) # database.add_configuration( # path=path, uuid="", name=name, scan=0, search=search) file_database = FileDatabase.get_instance() scanner = ConfigurationScanner() print("[save config] adding config", path) file_database.delete_file(path=path) with open(path, "rb") as f: sha1 = hashlib.sha1(f.read()).hexdigest() file_database.add_file(path=path, sha1=sha1) game_id = database.add_configuration( path=path, name=scanner.create_configuration_name(name) ) database.update_game_search_terms( game_id, scanner.create_search_terms(name) ) database.commit() file_database.commit() LauncherSettings.set("__config_refresh", str(time.time())) # Settings.set("config_changed", "0") LauncherConfig.set("__changed", "0")
def main(): Application("fs-uae-game-system") if "--unsupported" in sys.argv: if "--http-server" in sys.argv: from fsgamesys.http.server import http_server_main return http_server_main() if len(sys.argv) < 3: print("") print("usage: fsgs run <game>") print("") print("game:") print(" - search term(s) identifying a single game") print(" - path to a .fsgs file") print(" - path to a recognized cartridge ROM or disk file format") print("") sys.exit(1) assert sys.argv[1] == "run" game_arg = " ".join(sys.argv[2:]) print(game_arg) if os.path.exists(game_arg): load_file(game_arg) else: search = game_arg.lower() database = Database.instance() # cursor.execute("SELECT id FROM game WHERE name like") terms = GameNameUtil.extract_search_terms(search) found_games = database.find_games_new(" ".join(terms)) games = [] for game in found_games: print(list(game)) if game[0]: # only process entries with a game uuid games.append(game) game_uuid = None if len(games) == 0: print("no games found") sys.exit(2) if len(games) > 1: matches = 0 for row in games: if row[1].lower() == search: if game_uuid is None: game_uuid = row[0] matches += 1 if matches != 1: print("") print("More than one game matches:") print("") for row in games: print(" {0} ({1})".format(row[1], row[2])) print(" {0}".format(row[0])) print("") sys.exit(3) game_uuid = games[0][0] assert game_uuid variant_uuid = find_preferred_variant(game_uuid) load_game_variant(variant_uuid) fsgs.run_game()
def config_startup_scan(cls): if cls._config_scanned: return cls._config_scanned = True configs_dir = FSGSDirectories.get_configurations_dir() print("config_startup_scan", configs_dir) print(LauncherSettings.settings) settings_mtime = LauncherSettings.get("configurations_dir_mtime") dir_mtime = cls.get_dir_mtime_str(configs_dir) if settings_mtime == dir_mtime + "+" + str(Database.VERSION): print("... mtime not changed", settings_mtime, dir_mtime) return database = Database.get_instance() file_database = FileDatabase.get_instance() print("... database.find_local_configurations") local_configs = Database.get_instance().find_local_configurations() print("... walk configs_dir") for dir_path, dir_names, file_names in os.walk(configs_dir): for file_name in file_names: # if not file_name.endswith(".fs-uae"): # continue # FIXME: Move extension list somewhere else if not file_name.endswith( ".fs-uae") and not file_name.endswith(".fs-fuse"): continue path = Paths.join(dir_path, file_name) if path in local_configs: local_configs[path] = None # already exists in database continue name, ext = os.path.splitext(file_name) # search = ConfigurationScanner.create_configuration_search( # name) scanner = ConfigurationScanner() print("[startup] adding config", path) file_database.delete_file(path=path) with open(path, "rb") as f: sha1 = hashlib.sha1(f.read()).hexdigest() file_database.add_file(path=path, sha1=sha1) game_id = database.add_configuration( path=path, name=scanner.create_configuration_name(name)) database.update_game_search_terms( game_id, scanner.create_search_terms(name)) for path, config_id in local_configs.items(): if config_id is not None: print("[startup] removing configuration", path) database.delete_game(id=config_id) file_database.delete_file(path=path) print("... commit") database.commit() LauncherSettings.set( "configurations_dir_mtime", cls.get_dir_mtime_str(configs_dir) + "+" + str(Database.VERSION), )