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