#!/usr/bin/env python3 import os, re import json import shutil import binascii import ctypes import gzip import zipfile import time import sys import subprocess import sqlite3 import csv from urllib.request import urlopen from urllib.request import urlretrieve from urllib.parse import quote from base64 import b64encode import xml.etree.ElementTree as ET # Check the value of the DBUS_SESSION_BUS_ADDRESS environment variable dbus_address = os.environ.get('DBUS_SESSION_BUS_ADDRESS') if not dbus_address or not dbus_address.startswith('unix:path='): # Set the value of the DBUS_SESSION_BUS_ADDRESS environment variable dbus_address = f'unix:path=/run/user/{os.getuid()}/bus' os.environ['DBUS_SESSION_BUS_ADDRESS'] = dbus_address # Path to the env_vars file env_vars_path = f"{os.environ['HOME']}/.config/systemd/user/env_vars" # Check if the env_vars file exists if not os.path.exists(env_vars_path): print(f"Error: {env_vars_path} does not exist.") sys.exit(1) # Read variables from the file with open(env_vars_path, 'r') as f: lines = f.readlines() for line in lines: if line.startswith('export '): line = line[7:] # Remove 'export ' name, value = line.strip().split('=', 1) os.environ[name] = value # Store the value of separate_appids before deleting it separate_appids = None # Delete env_vars entries for Chrome shortcuts so that they're only added once with open(env_vars_path, 'w') as f: for line in lines: if 'export separate_appids=false' in line: separate_appids = line.split('=')[1].strip() if line.find('chromelaunchoptions') == -1 and line.find('websites_str') == -1: f.write(line) # Variables from NonSteamLaunchers.sh steamid3 = os.environ['steamid3'] logged_in_home = os.environ['logged_in_home'] compat_tool_name = os.environ['compat_tool_name'] python_version = os.environ['python_version'] #Scanner Variables epic_games_launcher = os.environ.get('epic_games_launcher', '') ubisoft_connect_launcher = os.environ.get('ubisoft_connect_launcher', '') ea_app_launcher = os.environ.get('ea_app_launcher', '') gog_galaxy_launcher = os.environ.get('gog_galaxy_launcher', '') bnet_launcher = os.environ.get('bnet_launcher', '') amazon_launcher = os.environ.get('amazon_launcher', '') itchio_launcher = os.environ.get('itchio_launcher', '') legacy_launcher = os.environ.get('legacy_launcher', '') #Variables of the Launchers # Define the path of the Launchers epicshortcutdirectory = os.environ.get('epicshortcutdirectory') gogshortcutdirectory = os.environ.get('gogshortcutdirectory') uplayshortcutdirectory = os.environ.get('uplayshortcutdirectory') battlenetshortcutdirectory = os.environ.get('battlenetshortcutdirectory') eaappshortcutdirectory = os.environ.get('eaappshortcutdirectory') amazonshortcutdirectory = os.environ.get('amazonshortcutdirectory') itchioshortcutdirectory = os.environ.get('itchioshortcutdirectory') legacyshortcutdirectory = os.environ.get('legacyshortcutdirectory') humbleshortcutdirectory = os.environ.get('humbleshortcutdirectory') indieshortcutdirectory = os.environ.get('indieshortcutdirectory') rockstarshortcutdirectory = os.environ.get('rockstarshortcutdirectory') glyphshortcutdirectory = os.environ.get('glyphshortcutdirectory') psplusshortcutdirectory = os.environ.get('psplusshortcutdirectory') vkplayshortcutdirectory = os.environ.get('vkplayshortcutdirectory') hoyoplayshortcutdirectory = os.environ.get('hoyoplayshortcutfirectory') nexonshortcutdirectory = os.environ.get('nexonshortcutdirectory') repaireaappshortcutdirectory = os.environ.get('repaireaappshortcutdirectory') #Streaming chromedirectory = os.environ.get('chromedirectory') websites_str = os.environ.get('custom_websites_str') custom_websites = websites_str.split(', ') if websites_str else [] # Define the parent folder parent_folder = f"{logged_in_home}/.config/systemd/user/Modules" sys.path.insert(0, os.path.expanduser(f"{logged_in_home}/.config/systemd/user/Modules")) print(sys.path) # Now that the requests module has been downloaded, you can import it sys.path.insert(0, parent_folder) import requests import vdf from steamgrid import SteamGridDB print(sys.path) #Set Up nslgamescanner.service # Define the paths service_path = f"{logged_in_home}/.config/systemd/user/nslgamescanner.service" # Define the service file content service_content = f""" [Unit] Description=NSL Game Scanner [Service] ExecStart=/usr/bin/python3 '{logged_in_home}/.config/systemd/user/NSLGameScanner.py' Restart=always RestartSec=10 StartLimitBurst=40 StartLimitInterval=240 [Install] WantedBy=default.target """ # Check if the service file already exists if not os.path.exists(service_path): # Create the service file with open(service_path, 'w') as f: f.write(service_content) print("Service file created.") # Check if the service is already running result = subprocess.run(['systemctl', '--user', 'is-active', 'nslgamescanner.service'], stdout=subprocess.PIPE) if result.stdout.decode('utf-8').strip() != 'active': # Reload the systemd manager configuration subprocess.run(['systemctl', '--user', 'daemon-reload']) # Enable the service to start on boot subprocess.run(['systemctl', '--user', 'enable', 'nslgamescanner.service']) # Start the service immediately subprocess.run(['systemctl', '--user', 'start', 'nslgamescanner.service']) print("Service started.") else: print("Service is already running.") #Code def get_steam_shortcut_id(exe_path, display_name): unique_id = "".join([exe_path, display_name]) id_int = binascii.crc32(str.encode(unique_id)) | 0x80000000 signed = ctypes.c_int(id_int) # print(f"Signed ID: {signed.value}") return signed.value def get_unsigned_shortcut_id(signed_shortcut_id): unsigned = ctypes.c_uint(signed_shortcut_id) # print(f"Unsigned ID: {unsigned.value}") return unsigned.value # Initialize an empty dictionary to serve as the cache api_cache = {} #API KEYS FOR NONSTEAMLAUNCHER USE ONLY BASE_URL = 'https://myproxycache-203e9b0bbe5b.herokuapp.com/api' #GLOBAL VARS created_shortcuts = [] new_shortcuts_added = False shortcuts_updated = False shortcut_id = None # Initialize shortcut_id decky_shortcuts = {} gridp64 = "" grid64 = "" logo64 = "" hero64 = "" def create_empty_shortcuts(): return {'shortcuts': {}} def write_shortcuts_to_file(shortcuts_file, shortcuts): with open(shortcuts_file, 'wb') as file: file.write(vdf.binary_dumps(shortcuts)) os.chmod(shortcuts_file, 0o755) # Define the path to the shortcuts file shortcuts_file = f"{logged_in_home}/.steam/root/userdata/{steamid3}/config/shortcuts.vdf" # Check if the file exists if os.path.exists(shortcuts_file): # If the file is not executable, write the shortcuts dictionary and make it executable if not os.access(shortcuts_file, os.X_OK): print("The file is not executable. Writing an empty shortcuts dictionary and making it executable.") shortcuts = create_empty_shortcuts() write_shortcuts_to_file(shortcuts_file, shortcuts) else: # Load the existing shortcuts with open(shortcuts_file, 'rb') as file: try: shortcuts = vdf.binary_loads(file.read()) except vdf.VDFError as e: print(f"Error reading file: {e}. The file might be corrupted or unreadable.") print("Exiting the program. Please check the shortcuts.vdf file.") sys.exit(1) else: print("The shortcuts.vdf file does not exist.") sys.exit(1) # Open the config.vdf file with open(f"{logged_in_home}/.steam/root/config/config.vdf", 'r') as file: config_data = vdf.load(file) def get_sgdb_art(game_id, app_id): global grid64 global gridp64 global logo64 global hero64 print(f"Downloading icons artwork...") download_artwork(game_id, "icons", app_id) print(f"Downloading logos artwork...") logo64 = download_artwork(game_id, "logos", app_id) print(f"Downloading heroes artwork...") hero64 = download_artwork(game_id, "heroes", app_id) print("Downloading grids artwork of size 600x900...") gridp64 = download_artwork(game_id, "grids", app_id, "600x900") print("Downloading grids artwork of size 920x430...") grid64 = download_artwork(game_id, "grids", app_id, "920x430") def download_artwork(game_id, art_type, shortcut_id, dimensions=None): if game_id is None: print("Invalid game ID. Skipping download.") return cache_key = (game_id, art_type, dimensions) if dimensions is not None: filename = get_file_name(art_type, shortcut_id, dimensions) else: filename = get_file_name(art_type, shortcut_id) file_path = f"{logged_in_home}/.steam/root/userdata/{steamid3}/config/grid/{filename}" directory = os.path.dirname(file_path) if not os.path.exists(directory): os.makedirs(directory) if os.path.exists(file_path): print(f"Artwork for {game_id} already exists. Skipping download.") with open(file_path, 'rb') as image_file: return b64encode(image_file.read()).decode('utf-8') if cache_key in api_cache: data = api_cache[cache_key] else: try: print(f"Game ID: {game_id}") url = f"{BASE_URL}/{art_type}/game/{game_id}" if dimensions: url += f"?dimensions={dimensions}" print(f"Request URL: {url}") response = requests.get(url) response.raise_for_status() data = response.json() print(f"Response data: {data}") api_cache[cache_key] = data except Exception as e: print(f"Error making API call: {e}") api_cache[cache_key] = None return if data is None: print(f"No data available for {game_id}. Skipping download.") return for artwork in data['data']: image_url = artwork['thumb'] print(f"Downloading image from: {image_url}") try: response = requests.get(image_url, stream=True) response.raise_for_status() if response.status_code == 200: with open(file_path, 'wb') as file: file.write(response.content) return b64encode(response.content).decode('utf-8') except requests.exceptions.RequestException as e: print(f"Error downloading image: {e}") if art_type == 'icons': download_artwork(game_id, 'icons_ico', shortcut_id) if data is None: print(f"No data available for {game_id}. Skipping download.") return for artwork in data['data']: image_url = artwork['thumb'] print(f"Downloading image from: {image_url}") try: response = requests.get(image_url, stream=True) response.raise_for_status() if response.status_code == 200: with open(file_path, 'wb') as file: file.write(response.content) return b64encode(response.content).decode('utf-8') except requests.exceptions.RequestException as e: print(f"Error downloading image: {e}") if art_type == 'icons': download_artwork(game_id, 'icons_ico', shortcut_id) def get_game_id(game_name): print(f"Searching for game ID for: {game_name}") try: encoded_game_name = quote(game_name) url = f"{BASE_URL}/search/{encoded_game_name}" print(f"Encoded game name: {encoded_game_name}") print(f"Request URL: {url}") response = requests.get(url) response.raise_for_status() data = response.json() print(f"Response data: {data}") if data['data']: game_id = data['data'][0]['id'] print(f"Found game ID: {game_id}") return game_id print(f"No game ID found for game name: {game_name}") return None except Exception as e: print(f"Error searching for game ID: {e}") return None def get_file_name(art_type, shortcut_id, dimensions=None): singular_art_type = art_type.rstrip('s') if art_type == 'icons': if os.path.exists(f"{logged_in_home}/.steam/root/userdata/{steamid3}/config/grid/{shortcut_id}-{singular_art_type}.png"): return f"{shortcut_id}-{singular_art_type}.png" else: return f"{shortcut_id}-{singular_art_type}.ico" elif art_type == 'grids': if dimensions == '600x900': return f"{shortcut_id}p.png" else: return f"{shortcut_id}.png" elif art_type == 'heroes': return f"{shortcut_id}_hero.png" elif art_type == 'logos': return f"{shortcut_id}_logo.png" else: return f"{shortcut_id}.png" def is_match(name1, name2): if name1 and name2: return name1.lower() in name2.lower() or name2.lower() in name1.lower() else: return False # Add or update the proton compatibility settings def add_compat_tool(app_id, launchoptions): if 'CompatToolMapping' not in config_data['InstallConfigStore']['Software']['Valve']['Steam']: config_data['InstallConfigStore']['Software']['Valve']['Steam']['CompatToolMapping'] = {} print(f"CompatToolMapping key not found in config.vdf, creating.") # Combine checks for 'chrome' and 'PROTONPATH' if 'chrome' in launchoptions or 'PROTONPATH' in launchoptions: if 'PROTONPATH' in launchoptions: print("PROTONPATH found in launch options. Skipping compatibility tool update.") return False elif str(app_id) in config_data['InstallConfigStore']['Software']['Valve']['Steam']['CompatToolMapping']: config_data['InstallConfigStore']['Software']['Valve']['Steam']['CompatToolMapping'][str(app_id)]['name'] = f'{compat_tool_name}' config_data['InstallConfigStore']['Software']['Valve']['Steam']['CompatToolMapping'][str(app_id)]['config'] = '' config_data['InstallConfigStore']['Software']['Valve']['Steam']['CompatToolMapping'][str(app_id)]['priority'] = '250' print(f"Updated CompatToolMapping entry for appid: {app_id}") return compat_tool_name else: # Skip if the shortcut has already been processed by UMU if app_id in umu_processed_shortcuts: print(f"CompatTool update skipped for {app_id} because it was already processed by UMU.") return None config_data['InstallConfigStore']['Software']['Valve']['Steam']['CompatToolMapping'][str(app_id)] = {'name': f'{compat_tool_name}', 'config': '', 'priority': '250'} print(f"Created new CompatToolMapping entry for appid: {app_id}") return compat_tool_name def check_if_shortcut_exists(shortcut_id, display_name, exe_path, start_dir, launch_options): # Check if the game already exists in the shortcuts using the id if any(s.get('appid') == shortcut_id for s in shortcuts['shortcuts'].values()): print(f"Existing shortcut found based on shortcut ID for game {display_name}. Skipping creation.") return True # Check if the game already exists in the shortcuts using the fields (probably unnecessary) if any(s.get('appname') == display_name and s.get('exe') == exe_path and s.get('StartDir') == start_dir and s.get('LaunchOptions') == launch_options for s in shortcuts['shortcuts'].values()): print(f"Existing shortcut found based on matching fields for game {display_name}. Skipping creation.") return True if any(s.get('AppName') == display_name and s.get('Exe') == exe_path and s.get('StartDir') == start_dir and s.get('LaunchOptions') == launch_options for s in shortcuts['shortcuts'].values()): print(f"Existing shortcut found based on matching fields for game {display_name}. Skipping creation.") return True #End of Code #Start of Refactoring code from the .sh file sys.path.insert(0, os.path.expanduser(f"{logged_in_home}/Downloads/NonSteamLaunchersInstallation/lib/python{python_version}/site-packages")) print(sys.path) # Create an empty dictionary to store the app IDs app_ids = {} def get_next_available_key(shortcuts): key = 0 while str(key) in shortcuts['shortcuts']: key += 1 return str(key) def create_new_entry(shortcutdirectory, appname, launchoptions, startingdir): global new_shortcuts_added global shortcuts_updated global created_shortcuts global decky_shortcuts global grid64 global gridp64 global logo64 global hero64 global counter # Add this line to access the counter variable # Check if the launcher is installed if not shortcutdirectory or not appname or not launchoptions or not startingdir: print(f"{appname} is not installed. Skipping.") return exe_path = f"{shortcutdirectory}" signed_shortcut_id = get_steam_shortcut_id(exe_path, appname) unsigned_shortcut_id = get_unsigned_shortcut_id(signed_shortcut_id) # **Intercept and modify the shortcut based on UMU data** exe_path, startingdir, launchoptions = modify_shortcut_for_umu(appname, exe_path, launchoptions, startingdir) # Check if the shortcut has already been processed by UMU and skip compat tool if so if unsigned_shortcut_id in umu_processed_shortcuts: print(f"Skipping compatibility tool for {appname}, as it has already been processed by UMU.") compatTool = None # Skip adding compatibility tool else: compatTool = add_compat_tool(unsigned_shortcut_id, launchoptions) # Only store the app ID for specific launchers if appname in ['Epic Games', 'Gog Galaxy', 'Ubisoft Connect', 'Battle.net', 'EA App', 'Amazon Games', 'itch.io', 'Legacy Games', 'Humble Bundle', 'IndieGala Client', 'Rockstar Games Launcher', 'Glyph', 'Playstation Plus', 'VK Play', 'HoYoPlay', 'Nexon Launcher']: app_ids[appname] = unsigned_shortcut_id # Check if the game already exists in the shortcuts if check_if_shortcut_exists(signed_shortcut_id, appname, exe_path, startingdir, launchoptions): # Check if proton needs applying or updating if add_compat_tool(unsigned_shortcut_id, launchoptions): shortcuts_updated = True return # Skip artwork download for specific shortcuts if appname not in ['NonSteamLaunchers', 'Repair EA App']: # Get artwork game_id = get_game_id(appname) if game_id is not None: get_sgdb_art(game_id, unsigned_shortcut_id) # Create a new entry for the Steam shortcut, only adding the compat tool if it's not processed by UMU new_entry = { 'appid': str(signed_shortcut_id), 'appname': appname, 'exe': exe_path, 'StartDir': startingdir, 'icon': f"{logged_in_home}/.steam/root/userdata/{steamid3}/config/grid/{get_file_name('icons', unsigned_shortcut_id)}", 'ShortcutPath': "", 'LaunchOptions': launchoptions, 'IsHidden': 0, 'AllowDesktopConfig': 1, 'AllowOverlay': 1, 'OpenVR': 0, 'Devkit': 0, 'DevkitGameID': "", 'DevkitOverrideAppID': 0, 'LastPlayTime': 0, 'FlatpakAppID': "", 'tags': { '0': 'NonSteamLaunchers' } } # Create the decky entry, only including the compatTool if not processed by UMU decky_entry = { 'appname': appname, 'exe': exe_path, 'StartDir': startingdir, 'icon': f"{logged_in_home}/.steam/root/userdata/{steamid3}/config/grid/{get_file_name('icons', unsigned_shortcut_id)}", 'LaunchOptions': launchoptions, 'CompatTool': compatTool, # This will be None if UMU has processed the shortcut 'WideGrid': grid64, 'Grid': gridp64, 'Hero': hero64, 'Logo': logo64, } # Add the new entry to the shortcuts dictionary and add proton key = get_next_available_key(shortcuts) shortcuts['shortcuts'][key] = new_entry print(f"Added new entry for {appname} to shortcuts.") new_shortcuts_added = True created_shortcuts.append(appname) # Mark it as processed by UMU (if it wasn't already processed) if compatTool is not None: umu_processed_shortcuts[unsigned_shortcut_id] = True add_compat_tool(unsigned_shortcut_id, launchoptions) # UMU-related functions umu_processed_shortcuts = {} CSV_URL = "https://raw.githubusercontent.com/Open-Wine-Components/umu-database/main/umu-database.csv" # Global variable to store CSV data csv_data = [] def fetch_and_parse_csv(): global csv_data try: response = requests.get(CSV_URL) response.raise_for_status() # Raise an HTTPError for bad responses csv_data = [row for row in csv.DictReader(response.text.splitlines())] print("Successfully fetched and parsed CSV data.") except requests.exceptions.RequestException as e: print(f"Error fetching UMU data: {e}") return csv_data def list_all_entries(): global csv_data if not csv_data: csv_data = fetch_and_parse_csv() return csv_data def extract_umu_id_from_launch_options(launchoptions): if 'STEAM_COMPAT_DATA_PATH=' not in launchoptions: return None # EA match = re.search(r'offerIds=(\d+)', launchoptions) if match: return match.group(1) # Amazon match = re.search(r'(amzn1\.adg\.product\.\S+)', launchoptions) if match: return match.group(1).rstrip("'") # Epic match = re.search(r'com\.epicgames\.launcher://apps/(\w+)[?&]', launchoptions) if match: return match.group(1).lower() if not match.group(1).isdigit() else match.group(1) # Ubisoft match = re.search(r'uplay://launch/(\d+)/\d+', launchoptions) if match: return match.group(1) # GOG match = re.search(r'/gameId=(\d+)', launchoptions) if match: return match.group(1) return None def extract_base_path(launchoptions): match = re.search(r'STEAM_COMPAT_DATA_PATH="([^"]+)"', launchoptions) if match: return match.group(1) raise ValueError("STEAM_COMPAT_DATA_PATH not found in launch options") def modify_shortcut_for_umu(appname, exe, launchoptions, startingdir): # Skip processing if STEAM_COMPAT_DATA_PATH is not present if 'STEAM_COMPAT_DATA_PATH=' not in launchoptions: print(f"Launch options for {appname} do not contain STEAM_COMPAT_DATA_PATH. Skipping modification.") return exe, startingdir, launchoptions codename = extract_umu_id_from_launch_options(launchoptions) if not codename: print(f"No codename found in launch options for {appname}. Trying to match appname.") entries = list_all_entries() if not entries: print(f"No entries found in UMU database. Skipping modification for {appname}.") return exe, startingdir, launchoptions if not codename: for entry in entries: if entry.get('TITLE') and entry['TITLE'].lower() == appname.lower(): codename = entry['CODENAME'] break if codename: for entry in entries: if entry['CODENAME'] == codename: umu_id = entry['UMU_ID'].replace("umu-", "") # Remove the "umu-" prefix base_path = extract_base_path(launchoptions) new_exe = f'"{logged_in_home}/bin/umu-run" {exe}' new_start_dir = f'"{logged_in_home}/bin/"' # Update only the launchoptions part for different game types updated_launch = launchoptions if "origin2://game/launch?offerIds=" in launchoptions: updated_launch = f'"origin2://game/launch?offerIds={codename}"' elif "amazon-games://play/amzn1.adg.product." in launchoptions: updated_launch = f"-'amazon-games://play/{codename}'" elif "com.epicgames.launcher://apps/" in launchoptions: updated_launch = f"-'com.epicgames.launcher://apps/{codename}?action=launch&silent=true'" elif "uplay://launch/" in launchoptions: updated_launch = f'"uplay://launch/{codename}/0"' elif "/command=runGame /gameId=" in launchoptions: updated_launch = f'/command=runGame /gameId={codename} /path={launchoptions.split("/path=")[1]}' new_launch_options = ( f'STEAM_COMPAT_DATA_PATH="{base_path}" ' f'WINEPREFIX="{base_path}pfx" ' f'GAMEID="{umu_id}" ' f'PROTONPATH="{logged_in_home}/.steam/root/compatibilitytools.d/{compat_tool_name}" ' f'%command% {updated_launch}' ) umu_processed_shortcuts[umu_id] = True return new_exe, new_start_dir, new_launch_options print(f"No UMU entry found for {appname}. Skipping modification.") return exe, startingdir, launchoptions create_new_entry(os.environ.get('epicshortcutdirectory'), 'Epic Games', os.environ.get('epiclaunchoptions'), os.environ.get('epicstartingdir')) create_new_entry(os.environ.get('gogshortcutdirectory'), 'GOG Galaxy', os.environ.get('goglaunchoptions'), os.environ.get('gogstartingdir')) create_new_entry(os.environ.get('uplayshortcutdirectory'), 'Ubisoft Connect', os.environ.get('uplaylaunchoptions'), os.environ.get('uplaystartingdir')) create_new_entry(os.environ.get('battlenetshortcutdirectory'), 'Battle.net', os.environ.get('battlenetlaunchoptions'), os.environ.get('battlenetstartingdir')) create_new_entry(os.environ.get('eaappshortcutdirectory'), 'EA App', os.environ.get('eaapplaunchoptions'), os.environ.get('eaappstartingdir')) create_new_entry(os.environ.get('amazonshortcutdirectory'), 'Amazon Games', os.environ.get('amazonlaunchoptions'), os.environ.get('amazonstartingdir')) create_new_entry(os.environ.get('itchioshortcutdirectory'), 'itch.io', os.environ.get('itchiolaunchoptions'), os.environ.get('itchiostartingdir')) create_new_entry(os.environ.get('legacyshortcutdirectory'), 'Legacy Games', os.environ.get('legacylaunchoptions'), os.environ.get('legacystartingdir')) create_new_entry(os.environ.get('humbleshortcutdirectory'), 'Humble Bundle', os.environ.get('humblelaunchoptions'), os.environ.get('humblestartingdir')) create_new_entry(os.environ.get('indieshortcutdirectory'), 'IndieGala Client', os.environ.get('indielaunchoptions'), os.environ.get('indiestartingdir')) create_new_entry(os.environ.get('rockstarshortcutdirectory'), 'Rockstar Games Launcher', os.environ.get('rockstarlaunchoptions'), os.environ.get('rockstarstartingdir')) create_new_entry(os.environ.get('glyphshortcutdirectory'), 'Glyph', os.environ.get('glyphlaunchoptions'), os.environ.get('glyphstartingdir')) create_new_entry(os.environ.get('psplusshortcutdirectory'), 'Playstation Plus', os.environ.get('pspluslaunchoptions'), os.environ.get('psplusstartingdir')) create_new_entry(os.environ.get('vkplayshortcutdirectory'), 'VK Play', os.environ.get('vkplaylaunchoptions'), os.environ.get('vkplaystartingdir')) create_new_entry(os.environ.get('hoyoplayshortcutdirectory'), 'HoYoPlay', os.environ.get('hoyoplaylaunchoptions'), os.environ.get('hoyoplaystartingdir')) create_new_entry(os.environ.get('nexonshortcutdirectory'), 'Nexon Launcher', os.environ.get('nexonlaunchoptions'), os.environ.get('nexonstartingdir')) create_new_entry(os.environ.get('repaireaappshortcutdirectory'), 'Repair EA App', os.environ.get('repaireaapplaunchoptions'), os.environ.get('repaireaappstartingdir')) create_new_entry(os.environ.get('chromedirectory'), 'Xbox Game Pass', os.environ.get('xboxchromelaunchoptions'), os.environ.get('chrome_startdir')) create_new_entry(os.environ.get('chromedirectory'), 'GeForce Now', os.environ.get('geforcechromelaunchoptions'), os.environ.get('chrome_startdir')) create_new_entry(os.environ.get('chromedirectory'), 'Netflix', os.environ.get('netflixchromelaunchoptions'), os.environ.get('chrome_startdir')) create_new_entry(os.environ.get('chromedirectory'), 'Hulu', os.environ.get('huluchromelaunchoptions'), os.environ.get('chrome_startdir')) create_new_entry(os.environ.get('chromedirectory'), 'Disney+', os.environ.get('disneychromelaunchoptions'), os.environ.get('chrome_startdir')) create_new_entry(os.environ.get('chromedirectory'), 'Amazon Prime Video', os.environ.get('amazonchromelaunchoptions'), os.environ.get('chrome_startdir')) create_new_entry(os.environ.get('chromedirectory'), 'Youtube', os.environ.get('youtubechromelaunchoptions'), os.environ.get('chrome_startdir')) create_new_entry(os.environ.get('chromedirectory'), 'Amazon Luna', os.environ.get('lunachromelaunchoptions'), os.environ.get('chrome_startdir')) create_new_entry(os.environ.get('chromedirectory'), 'Twitch', os.environ.get('twitchchromelaunchoptions'), os.environ.get('chrome_startdir')) create_new_entry(os.environ.get('chromedirectory'), 'Fortnite', os.environ.get('fortnitechromelaunchoptions'), os.environ.get('chrome_startdir')) create_new_entry(os.environ.get('chromedirectory'), 'WebRcade', os.environ.get('webrcadechromelaunchoptions'), os.environ.get('chrome_startdir')) create_new_entry(os.environ.get('chromedirectory'), 'WebRcade Editor', os.environ.get('webrcadeeditchromelaunchoptions'), os.environ.get('chrome_startdir')) create_new_entry(os.environ.get('chromedirectory'), 'Plex', os.environ.get('plexchromelaunchoptions'), os.environ.get('chrome_startdir')) create_new_entry(os.environ.get('chromedirectory'), 'Apple TV+', os.environ.get('applechromelaunchoptions'), os.environ.get('chrome_startdir')) create_new_entry(os.environ.get('chromedirectory'), 'Crunchyroll', os.environ.get('crunchychromelaunchoptions'), os.environ.get('chrome_startdir')) # Iterate over each custom website for custom_website in custom_websites: # Check if the custom website is not an empty string if custom_website: # Remove any leading or trailing spaces from the custom website URL custom_website = custom_website.strip() # Remove the 'http://' or 'https://' prefix and the 'www.' prefix, if present clean_website = custom_website.replace('http://', '').replace('https://', '').replace('www.', '') # Define a regular expression pattern to extract the game name from the URL pattern = r'/games/([\w-]+)' # Use the regular expression to search for the game name in the custom website URL match = re.search(pattern, custom_website) # Check if a match was found if match: # Extract the game name from the match object game_name = match.group(1) # Replace hyphens with spaces game_name = game_name.replace('-', ' ') # Capitalize the first letter of each word in the game name game_name = game_name.title() else: # Use the entire URL as the entry name game_name = clean_website # Define the launch options for this website chromelaunch_options = f'run --branch=stable --arch=x86_64 --command=/app/bin/chrome --file-forwarding com.google.Chrome @@u @@ --window-size=1280,800 --force-device-scale-factor=1.00 --device-scale-factor=1.00 --start-fullscreen https://{clean_website}/ --no-first-run --enable-features=OverlayScrollbar' # Call the create_new_entry function for this website create_new_entry(os.environ['chromedirectory'], game_name, chromelaunch_options, os.environ['chrome_startdir']) #End of Creating Launcher Shortcuts #Custom Shortcut for NSL # Define the parameters for the new shortcut nslshortcutdirectory = f"\"{logged_in_home}/.local/share/Steam/steamapps/compatdata/NonSteamLaunchers/\"" nslappname = "NonSteamLaunchers" nsllaunchoptions = f"STEAM_COMPAT_DATA_PATH=\"{logged_in_home}/.local/share/Steam/steamapps/compatdata/NonSteamLaunchers/\" %command%" nslstartingdir = f"\"{logged_in_home}/.local/share/Steam/steamapps/compatdata/NonSteamLaunchers/\"" print(f"nslshortcutdirectory: {nslshortcutdirectory}") # Debug print print(f"nslappname: {nslappname}") # Debug print print(f"nsllaunchoptions: {nsllaunchoptions}") # Debug print # Check if separate_appids is set to 'false' if separate_appids == 'false': print("separate_appids is set to 'false'. Creating new shortcut...") # Debug print # Call the function to create the new shortcut and store the returned appid appid = create_new_entry(nslshortcutdirectory, nslappname, nsllaunchoptions, nslstartingdir) app_ids[nslappname] = appid print(f"appid: {appid}") # Debug print else: print("separate_appids is not set to 'false'. Skipping shortcut creation.") # Debug print # Iterate over each launcher in the app_ids dictionary for launcher_name, appid in app_ids.items(): print(f"The app ID for {launcher_name} is {appid}") # Get the app ID for the first launcher that the user chose to install if app_ids: appid = app_ids.get(launcher_name) print(f"App ID for the chosen launcher: {appid}") # Create User Friendly Symlinks for the launchers # Define the path to the compatdata directory compatdata_dir = f'{logged_in_home}/.local/share/Steam/steamapps/compatdata' print(f"Compatdata directory: {compatdata_dir}") # Define a dictionary of original folder names folder_names = { 'Epic Games': 'EpicGamesLauncher', 'Gog Galaxy': 'GogGalaxyLauncher', 'Ubisoft Connect': 'UplayLauncher', 'Battle.net': 'Battle.netLauncher', 'EA App': 'TheEAappLauncher', 'Amazon Games': 'AmazonGamesLauncher', 'itch.io': 'itchioLauncher', 'Legacy Games': 'LegacyGamesLauncher', 'Humble Bundle': 'HumbleGamesLauncher', 'IndieGala Client': 'IndieGalaLauncher', 'Rockstar Games Launcher': 'RockstarGamesLauncher', 'Glyph': 'GlyphLauncher', 'Playstation Plus': 'PlaystationPlusLauncher', 'VK Play': 'VKPlayLauncher', 'HoYoPlay': 'HoYoPlayLauncher', 'Nexon Launcher': 'NexonLauncher', } # Iterate over each launcher in the folder_names dictionary for launcher_name, folder in folder_names.items(): # Define the current path of the folder current_path = os.path.join(compatdata_dir, folder) print(f"Current path for {launcher_name}: {current_path}") # Check if the folder exists if os.path.exists(current_path): print(f'{launcher_name}: {folder} exists') # Get the app ID for this launcher from the app_id_to_name dictionary appid = app_ids.get(launcher_name) print(f"App ID for {launcher_name}: {appid}") # If appid is not None, proceed with renaming and symlink creation if appid is not None: # Define the new path of the folder new_path = os.path.join(compatdata_dir, str(appid)) print(f"New path for {launcher_name}: {new_path}") # Check if the new path already exists if os.path.exists(new_path): print(f'{new_path} already exists. Skipping renaming and symlinking.') else: # Rename the folder os.rename(current_path, new_path) print(f"Renamed {current_path} to {new_path}") # Define the path of the symbolic link symlink_path = os.path.join(compatdata_dir, folder) print(f"Symlink path for {launcher_name}: {symlink_path}") # Create a symbolic link to the renamed folder os.symlink(new_path, symlink_path) print(f"Created symlink at {symlink_path} to {new_path}") else: print(f'App ID for {launcher_name} is not available yet.') else: print(f'{launcher_name}: {folder} does not exist') # Define the appid for the custom shortcut custom_app_id = 4206469918 print(f"App ID for the custom shortcut: {custom_app_id}") # Check if the NonSteamLaunchers folder exists non_steam_launchers_path = os.path.join(compatdata_dir, 'NonSteamLaunchers') if os.path.exists(non_steam_launchers_path): print("NonSteamLaunchers already exists at the expected path.") # Define the current path of the NonSteamLaunchers folder current_path = os.path.join(compatdata_dir, 'NonSteamLaunchers') print(f"Current path for NonSteamLaunchers: {current_path}") # Check if NonSteamLaunchers is already a symbolic link if os.path.islink(current_path): print('NonSteamLaunchers is already a symbolic link') # Check if NonSteamLaunchers is a symlink to an appid folder if os.readlink(current_path) != os.path.join(compatdata_dir, str(custom_app_id)): print('NonSteamLaunchers is symlinked to a different folder') # Remove the existing symbolic link os.unlink(current_path) print(f'Removed existing symlink at {current_path}') # Create a symbolic link to the correct appid folder os.symlink(os.path.join(compatdata_dir, str(custom_app_id)), current_path) print(f'Created new symlink at {current_path} to {os.path.join(compatdata_dir, str(custom_app_id))}') else: print('NonSteamLaunchers is already correctly symlinked') else: print("NonSteamLaunchers is not a symbolic link.") # Check if the current path exists if os.path.exists(current_path): print("NonSteamLaunchers exists at the current path.") # Define the new path of the NonSteamLaunchers folder new_path = os.path.join(compatdata_dir, str(custom_app_id)) print(f"New path for NonSteamLaunchers: {new_path}") # Check if the new path already exists if os.path.exists(new_path): print(f'{new_path} already exists. Skipping renaming and symlinking.') else: # Move the NonSteamLaunchers folder to the new path shutil.move(current_path, new_path) print(f"Moved NonSteamLaunchers folder to {new_path}") # Define the path of the symbolic link symlink_path = os.path.join(compatdata_dir, 'NonSteamLaunchers') # Create a symbolic link to the renamed NonSteamLaunchers folder os.symlink(new_path, symlink_path) print(f"Created symlink at {symlink_path} to {new_path}") else: print(f"The directory {current_path} does not exist. Skipping.") #End of old refactored Code # Print the existing shortcuts print("Existing Shortcuts:") for shortcut in shortcuts['shortcuts'].values(): if shortcut.get('appname') is None: print(f"AppID for {shortcut.get('AppName')}: {shortcut.get('appid')}") else: print(f"AppID for {shortcut.get('appname')}: {shortcut.get('appid')}") #Scanners # Epic Games Scanner item_dir = f"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{epic_games_launcher}/pfx/drive_c/ProgramData/Epic/EpicGamesLauncher/Data/Manifests/" dat_file_path = f"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{epic_games_launcher}/pfx/drive_c/ProgramData/Epic/UnrealEngineLauncher/LauncherInstalled.dat" if os.path.exists(dat_file_path) and os.path.exists(item_dir): with open(dat_file_path, 'r') as file: dat_data = json.load(file) # Epic Game Scanner for item_file in os.listdir(item_dir): if item_file.endswith('.item'): with open(os.path.join(item_dir, item_file), 'r') as file: item_data = json.load(file) # Initialize variables display_name = item_data['DisplayName'] app_name = item_data['AppName'] exe_path = f"\"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{epic_games_launcher}/pfx/drive_c/Program Files (x86)/Epic Games/Launcher/Portal/Binaries/Win32/EpicGamesLauncher.exe\"" start_dir = f"\"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{epic_games_launcher}/pfx/drive_c/Program Files (x86)/Epic Games/Launcher/Portal/Binaries/Win32/\"" launch_options = f"STEAM_COMPAT_DATA_PATH=\"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{epic_games_launcher}/\" %command% -'com.epicgames.launcher://apps/{app_name}?action=launch&silent=true'" # Check if the game is still installed and if the LaunchExecutable is valid, not content-related, and is a .exe file if item_data['LaunchExecutable'].endswith('.exe') and "Content" not in item_data['DisplayName'] and "Content" not in item_data['InstallLocation']: for game in dat_data['InstallationList']: if game['AppName'] == item_data['AppName']: create_new_entry(exe_path, display_name, launch_options, start_dir) else: print("Epic Games Launcher data not found. Skipping Epic Games Scanner.") # End of the Epic Games Scanner # Ubisoft Connect Scanner def getUplayGameInfo(folderPath, filePath): # Get the game IDs from the folder listOfFiles = os.listdir(folderPath) uplay_ids = [re.findall(r'\d+', str(entry))[0] for entry in listOfFiles if re.findall(r'\d+', str(entry))] # Parse the registry file game_dict = {} with open(filePath, 'r') as file: uplay_id = None game_name = None uplay_install_found = False for line in file: line = line.replace("\\x2019", "’") if "Uplay Install" in line: uplay_id = re.findall(r'Uplay Install (\d+)', line) if uplay_id: uplay_id = uplay_id[0] game_name = None # Reset game_name uplay_install_found = True if "DisplayName" in line and uplay_install_found: game_name = re.findall(r'\"(.+?)\"', line.split("=")[1]) if game_name: game_name = game_name[0] uplay_install_found = False if uplay_id and game_name and uplay_id in uplay_ids: game_dict[game_name] = uplay_id uplay_id = None # Reset uplay_id game_name = None # Reset game_name return game_dict # Define your paths data_folder_path = f"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{ubisoft_connect_launcher}/pfx/drive_c/Program Files (x86)/Ubisoft/Ubisoft Game Launcher/data/" registry_file_path = f"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{ubisoft_connect_launcher}/pfx/system.reg" # Check if the paths exist if not os.path.exists(data_folder_path) or not os.path.exists(registry_file_path): print("One or more paths do not exist.") print("Ubisoft Connect game data not found. Skipping Ubisoft Games Scanner.") else: game_dict = getUplayGameInfo(data_folder_path, registry_file_path) for game, uplay_id in game_dict.items(): if uplay_id: launch_options = f"STEAM_COMPAT_DATA_PATH=\"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{ubisoft_connect_launcher}/\" %command% \"uplay://launch/{uplay_id}/0\"" exe_path = f"\"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{ubisoft_connect_launcher}/pfx/drive_c/Program Files (x86)/Ubisoft/Ubisoft Game Launcher/upc.exe\"" start_dir = f"\"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{ubisoft_connect_launcher}/pfx/drive_c/Program Files (x86)/Ubisoft/Ubisoft Game Launcher/\"" create_new_entry(exe_path, game, launch_options, start_dir) # End of Ubisoft Game Scanner # EA App Game Scanner def get_ea_app_game_info(installed_games, game_directory_path): game_dict = {} for game in installed_games: xml_file = ET.parse(f"{game_directory_path}{game}/__Installer/installerdata.xml") xml_root = xml_file.getroot() ea_ids = None game_name = None for content_id in xml_root.iter('contentID'): ea_ids = content_id.text break # Exit the loop after the first ID is found for game_title in xml_root.iter('gameTitle'): if game_name is None: game_name = game_title.text continue for game_title in xml_root.iter('title'): if game_name is None: game_name = game_title.text continue if game_name is None: game_name = game if ea_ids: # Add the game's info to the dictionary if its ID was found in the folder game_dict[game_name] = ea_ids return game_dict game_directory_path = f"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{ea_app_launcher}/pfx/drive_c/Program Files/EA Games/" if not os.path.isdir(game_directory_path): print("EA App game data not found. Skipping EA App Scanner.") else: installed_games = os.listdir(game_directory_path) # Get a list of game folders game_dict = get_ea_app_game_info(installed_games, game_directory_path) for game, ea_ids in game_dict.items(): launch_options = f"STEAM_COMPAT_DATA_PATH=\"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{ea_app_launcher}/\" %command% \"origin2://game/launch?offerIds={ea_ids}\"" exe_path = f"\"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{ea_app_launcher}/pfx/drive_c/Program Files/Electronic Arts/EA Desktop/EA Desktop/EALaunchHelper.exe\"" start_dir = f"\"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{ea_app_launcher}/pfx/drive_c/Program Files/Electronic Arts/EA Desktop/EA Desktop/\"" create_new_entry(exe_path, game, launch_options, start_dir) #End of EA App Scanner # Gog Galaxy Scanner def getGogGameInfo(filePath): # Check if the file contains any GOG entries with open(filePath, 'r') as file: if "GOG.com" not in file.read(): print("No GOG entries found in the registry file. Skipping GOG Galaxy Games Scanner.") return {} # If GOG entries exist, parse the registry file game_dict = {} with open(filePath, 'r') as file: game_id = None game_name = None exe_path = None depends_on = None launch_command = None start_menu_link = None gog_entry = False for line in file: split_line = line.split("=") if len(split_line) > 1: if "gameid" in line.lower(): game_id = re.findall(r'\"(.+?)\"', split_line[1]) if game_id: game_id = game_id[0] if "gamename" in line.lower(): game_name = re.findall(r'\"(.+?)\"', split_line[1]) if game_name: game_name = bytes(game_name[0], 'utf-8').decode('unicode_escape') game_name = game_name.replace('!22', '™') if "exe" in line.lower() and not "unins000.exe" in line.lower(): exe_path = re.findall(r'\"(.+?)\"', split_line[1]) if exe_path: exe_path = exe_path[0].replace('\\\\', '\\') if "dependson" in line.lower(): depends_on = re.findall(r'\"(.+?)\"', split_line[1]) if depends_on: depends_on = depends_on[0] if "launchcommand" in line.lower(): launch_command = re.findall(r'\"(.+?)\"', split_line[1]) if launch_command: launch_command = launch_command[0] if game_id and game_name and launch_command: game_dict[game_name] = {'id': game_id, 'exe': exe_path} game_id = None game_name = None exe_path = None depends_on = None launch_command = None return game_dict def adjust_dosbox_launch_options(launch_command, game_id): print(f"Adjusting launch options for command: {launch_command}") if "dosbox.exe" in launch_command.lower(): try: # Find the part of the command with DOSBox.exe and its arguments exe_part, args_part = launch_command.split("DOSBox.exe", 1) exe_path = exe_part.strip() + "DOSBox.exe" args = args_part.strip() # Form the launch options string launch_options = f'STEAM_COMPAT_DATA_PATH="{logged_in_home}/.local/share/Steam/steamapps/compatdata/{gog_galaxy_launcher}/" %command% /command=runGame /gameId={game_id} /path="{exe_path}" "{args}"' return launch_options except ValueError as e: print(f"Error adjusting launch options: {e}") return launch_command else: # For non-DOSBox games, return the original launch command without trailing spaces launch_command = launch_command.strip() return f'STEAM_COMPAT_DATA_PATH="{logged_in_home}/.local/share/Steam/steamapps/compatdata/{gog_galaxy_launcher}/" %command% /command=runGame /gameId={game_id} /path="{launch_command}"' # Define your paths gog_games_directory = f"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{gog_galaxy_launcher}/pfx/drive_c/Program Files (x86)/GOG Galaxy/Games" registry_file_path = f"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{gog_galaxy_launcher}/pfx/system.reg" # Check if the paths exist if not os.path.exists(gog_games_directory) or not os.path.exists(registry_file_path): print("One or more paths do not exist.") print("GOG Galaxy game data not found. Skipping GOG Galaxy Games Scanner.") else: game_dict = getGogGameInfo(registry_file_path) for game, game_info in game_dict.items(): if game_info['id']: # Adjust the launch options for DOSBox games launch_options = adjust_dosbox_launch_options(game_info['exe'], game_info['id']) # Format the paths correctly exe_path = f"\"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{gog_galaxy_launcher}/pfx/drive_c/Program Files (x86)/GOG Galaxy/GalaxyClient.exe\"" start_dir = f"\"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{gog_galaxy_launcher}/pfx/drive_c/Program Files (x86)/GOG Galaxy/\"" # Create the new entry create_new_entry(exe_path, game, launch_options, start_dir) # End of Gog Galaxy Scanner #Battle.net Scanner # Define your mapping flavor_mapping = { "RTRO": "Blizzard Arcade Collection", "D1": "Diablo", "OSI": "Diablo II Resurrected", "D3": "Diablo III", "Fen": "Diablo IV", "ANBS": "Diablo Immortal (PC)", "WTCG": "Hearthstone", "Hero": "Heroes of the Storm", "Pro": "Overwatch 2", "S1": "StarCraft", "S2": "StarCraft 2", "W1": "Warcraft: Orcs & Humans", "W2": "Warcraft II: Battle.net Edition", "W3": "Warcraft III: Reforged", "WoW": "World of Warcraft", "WoWC": "World of Warcraft Classic", "GRY": "Warcraft Arclight Rumble", "ZEUS": "Call of Duty: Black Ops - Cold War", "VIPR": "Call of Duty: Black Ops 4", "ODIN": "Call of Duty: Modern Warfare", "AUKS": "Call of Duty", "LAZR": "Call of Duty: MW 2 Campaign Remastered", "FORE": "Call of Duty: Vanguard", "SPOT": "Call of Duty: Modern Warfare III", "WLBY": "Crash Bandicoot 4: It's About Time", # Add more games here... } def parse_battlenet_config(config_file_path): print(f"Opening Battle.net config file at: {config_file_path}") with open(config_file_path, 'r') as file: config_data = json.load(file) games_info = config_data.get("Games", {}) game_dict = {} for game_key, game_data in games_info.items(): print(f"Processing game: {game_key}") if game_key == "battle_net": print("Skipping 'battle_net' entry") continue if "Resumable" not in game_data: print(f"Skipping {game_key}, no 'Resumable' key found") continue if game_data["Resumable"] == "false": print(f"Game {game_key} is not resumable, adding to game_dict") game_dict[game_key] = { "ServerUid": game_data.get("ServerUid", ""), "LastActioned": game_data.get("LastActioned", "") } print(f"Parsed config data: {game_dict}") return game_dict game_dict = {} print("Detected platform: Non-Windows") config_file_path = f"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{bnet_launcher}/pfx/drive_c/users/steamuser/AppData/Roaming/Battle.net/Battle.net.config" print(f"Config file path: {config_file_path}") if os.path.exists(config_file_path): print("Battle.net config file found, parsing...") game_dict = parse_battlenet_config(config_file_path) else: print("Battle.net config file not found. Skipping Battle.net Games Scanner.") if game_dict: for game_key, game_info in game_dict.items(): print(f"Processing game: {game_key}") if game_key == "prometheus": print("Handling 'prometheus' as 'Pro'") game_key = "Pro" elif game_key == "fenris": print("Handling 'fenris' as 'Fen'") game_key = "Fen" game_name = flavor_mapping.get(game_key, "unknown") if game_name == "unknown": game_name = flavor_mapping.get(game_key.upper(), "unknown") print(f"Trying uppercase for {game_key}: {game_name}") if game_name == "unknown": print(f"Game {game_key} remains unknown, skipping...") continue matched_key = next((k for k, v in flavor_mapping.items() if v == game_name), game_key) print(f"Matched key for {game_key}: {matched_key}") if game_name == "Overwatch": game_name = "Overwatch 2" print(f"Renaming 'Overwatch' to 'Overwatch 2'") if game_info['ServerUid'] == "unknown": print(f"Skipping game {game_key} due to unknown ServerUid") continue exe_path = f'"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{bnet_launcher}/pfx/drive_c/Program Files (x86)/Battle.net/Battle.net.exe"' start_dir = f'"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{bnet_launcher}/pfx/drive_c/Program Files (x86)/Battle.net/"' launch_options = f'STEAM_COMPAT_DATA_PATH="{logged_in_home}/.local/share/Steam/steamapps/compatdata/{bnet_launcher}" %command% --exec="launch {matched_key}" battlenet://{matched_key}' print(f"Creating new entry for {game_name} with exe_path: {exe_path}") create_new_entry(exe_path, game_name, launch_options, start_dir) print("Battle.net Games Scanner completed.") # End of Battle.net Scanner # Amazon Games Scanner def get_sqlite_path(): # Specify the full path to the SQLite file path = f"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{amazon_launcher}/pfx/drive_c/users/steamuser/AppData/Local/Amazon Games/Data/Games/Sql/GameInstallInfo.sqlite" if os.path.exists(path): return path else: print(f"Amazon GameInstallInfo.sqlite not found at {path}") return None def get_launcher_path(): # Specify the full path to the Amazon Games launcher executable path = f"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{amazon_launcher}/pfx/drive_c/users/steamuser/AppData/Local/Amazon Games/App/Amazon Games.exe" if os.path.exists(path): return path else: print(f"Could not find Amazon Games.exe at {path}") return None def get_amazon_games(): sqllite_path = get_sqlite_path() launcher_path = get_launcher_path() if sqllite_path is None or launcher_path is None: print("Skipping Amazon Games Scanner due to missing paths.") return [] result = [] connection = sqlite3.connect(sqllite_path) cursor = connection.cursor() cursor.execute("SELECT Id, ProductTitle FROM DbSet WHERE Installed = 1") for row in cursor.fetchall(): id, title = row result.append({"id": id, "title": title, "launcher_path": launcher_path}) return result amazon_games = get_amazon_games() if amazon_games: for game in amazon_games: # Initialize variables display_name = game['title'] exe_path = f"\"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{amazon_launcher}/pfx/drive_c/users/steamuser/AppData/Local/Amazon Games/App/Amazon Games.exe\"" start_dir = f"\"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{amazon_launcher}/pfx/drive_c/users/steamuser/AppData/Local/Amazon Games/App/\"" launch_options = f"STEAM_COMPAT_DATA_PATH=\"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{amazon_launcher}/\" %command% -'amazon-games://play/{game['id']}'" create_new_entry(exe_path, display_name, launch_options, start_dir) #End of Amazon Games Scanner # Itchio Scanner # Set up the path to the Butler database itch_db_location = f"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{itchio_launcher}/pfx/drive_c/users/steamuser/AppData/Roaming/itch/db/butler.db" # Check if the database path exists if not os.path.exists(itch_db_location): print(f"Path not found: {itch_db_location}. Aborting Itch.io scan...") else: # Connect to the SQLite database conn = sqlite3.connect(itch_db_location) cursor = conn.cursor() # Fetch data from the 'caves' table cursor.execute("SELECT * FROM caves;") caves = cursor.fetchall() # Fetch data from the 'games' table cursor.execute("SELECT * FROM games;") games = cursor.fetchall() # Create a dictionary to store game information by game_id games_dict = {game[0]: game for game in games} # List to store final Itch.io game details itchgames = [] # Match game_id between 'caves' and 'games' tables and collect relevant game details for cave in caves: game_id = cave[1] if game_id in games_dict: game_info = games_dict[game_id] cave_info = json.loads(cave[11]) base_path = cave_info['basePath'] candidates = cave_info['candidates'] executable_path = candidates[0]['path'] # Skip games with an executable that ends with '.html' (browser games) if executable_path.endswith('.html'): print(f"Skipping browser game: {game_info[2]}") continue # Extract the game title game_title = game_info[2] # Append the game info (base path, executable path, game title) to the list itchgames.append((base_path, executable_path, game_title)) # Process each game for creating new entries for base_path, executable, game_title in itchgames: base_path_linux = base_path.replace("C:\\", f"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{itchio_launcher}/pfx/drive_c/").replace("\\", "/") exe_path = "\"" + os.path.join(base_path_linux, executable).replace("\\", "/") + "\"" start_dir = "\"" + base_path_linux + "\"" launchoptions = f"STEAM_COMPAT_DATA_PATH=\"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{itchio_launcher}/\" %command%" # Call the provided function to create a new entry for the game create_new_entry(exe_path, game_title, launchoptions, start_dir) # Close the database connection conn.close() # End of Itch.io Scanner #Legacy Games Scanner legacy_dir = f"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{legacy_launcher}/pfx/drive_c/Program Files/Legacy Games/" if not os.path.exists(legacy_dir): print("Legacy directory not found. Skipping creation.") else: user_reg_path = f"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{legacy_launcher}/pfx/user.reg" with open(user_reg_path, 'r') as file: user_reg = file.read() for game_dir in os.listdir(legacy_dir): if game_dir == "Legacy Games Launcher": continue print(f"Processing game directory: {game_dir}") if game_dir == "100 Doors Escape from School": app_info_path = f"{legacy_dir}/100 Doors Escape from School/100 Doors Escape From School_Data/app.info" exe_path = f"{legacy_dir}/100 Doors Escape from School/100 Doors Escape From School.exe" else: app_info_path = os.path.join(legacy_dir, game_dir, game_dir.replace(" ", "") + "_Data", "app.info") exe_path = os.path.join(legacy_dir, game_dir, game_dir.replace(" ", "") + ".exe") if os.path.exists(app_info_path): print("app.info file found.") with open(app_info_path, 'r') as file: lines = file.read().split('\n') game_name = lines[1].strip() print(f"Game Name: {game_name}") else: print("No app.info file found.") if os.path.exists(exe_path): game_exe_reg = re.search(r'\[Software\\\\Legacy Games\\\\' + re.escape(game_dir) + r'\].*?"GameExe"="([^"]*)"', user_reg, re.DOTALL | re.IGNORECASE) if game_exe_reg and game_exe_reg.group(1).lower() == os.path.basename(exe_path).lower(): print(f"GameExe found in user.reg: {game_exe_reg.group(1)}") start_dir = f"{legacy_dir}{game_dir}" launch_options = f"STEAM_COMPAT_DATA_PATH=\"{logged_in_home}/.local/share/Steam/steamapps/compatdata/{legacy_launcher}\" %command%" create_new_entry(f'"{exe_path}"', game_name, launch_options, f'"{start_dir}"') else: print(f"No matching .exe file found for game: {game_dir}") else: print(f"No .exe file found for game: {game_dir}") #End of the Legacy Games Scanner # Only write back to the shortcuts.vdf and config.vdf files if new shortcuts were added or compattools changed if new_shortcuts_added or shortcuts_updated: print(f"Saving new config and shortcuts files") conf = vdf.dumps(config_data, pretty=True) try: with open(f"{logged_in_home}/.steam/root/config/config.vdf", 'w') as file: file.write(conf) except IOError as e: print(f"Error writing to config.vdf: {e}") try: with open(f"{logged_in_home}/.steam/root/userdata/{steamid3}/config/shortcuts.vdf", 'wb') as file: file.write(vdf.binary_dumps(shortcuts)) except IOError as e: print(f"Error writing to shortcuts.vdf: {e}") # Print the created shortcuts if created_shortcuts: print("Created Shortcuts:") for name in created_shortcuts: print(name) # Create the path to the output file output_file_path = f"{logged_in_home}/.config/systemd/user/NSLGameScanner_output.log" # Open the output file in write mode try: with open(output_file_path, 'w') as output_file: for game in decky_shortcuts.values(): # Skip if 'appname' or 'exe' is None if game.get('appname') is None or game.get('exe') is None: continue # Create a dictionary to hold the shortcut information shortcut_info = { 'appname': game.get('appname'), 'exe': game.get('exe'), 'StartDir': game.get('StartDir'), 'icon': game.get('icon'), 'LaunchOptions': game.get('LaunchOptions'), 'CompatTool': game.get('CompatTool'), 'WideGrid': game.get('WideGrid'), 'Grid': game.get('Grid'), 'Hero': game.get('Hero'), 'Logo': game.get('Logo'), } # Print the shortcut information in JSON format message = json.dumps(shortcut_info) print(message, flush=True) # Print to stdout # Print the shortcut information to the output file print(message, file=output_file, flush=True) except IOError as e: print(f"Error writing to output file: {e}") print("All finished!")