mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-22 14:26:00 +00:00
An opt-in second Steam client (Steam settings, Steam client: x86-64): Valve's x86-64 Linux client, unchanged, runs under FEX in its own home with its own game library and the same sign-in. Linux builds run directly, so titles such as Team Fortress 2 and Half-Life use their Linux versions; Windows games use DroidDeck-Proton as on arm64. The arm64 client stays the default. - droiddeck-steam-x64: FEX and the x86-64 rootfs from DroidDeck-Components (sha256-pinned), client install and sync from Valve's CDN, sign-in shared with the arm64 client, its web helper on the GPU (ANGLE GL over FEX's GL thunk, zink, Turnip), Proton wrappers for the arm64 client's tools, DroidDeck direct for Linux builds, SD-card library (x86-64/ beside the arm64 one), repair. - FEX 2610 built by build-fex.yml with thunks and three patches: an openat2 fallback without openat2 (proot), newer-clang thunkgen, MAP_32BIT exhaustion returning ENOMEM. libblsession resolves RESOLVE_IN_ROOT paths inside the root. - Session: x86-64 gating, shortcuts and compatibility tools per client, logs from the client that ran. - App: client setting with the FEX version, an x86-64 chip on the Games header, the active client's library, art, storage, downloads, repair, Offline Mode, Decky, desktop mode, optional VAC diagnostics; per-client state for art, the content log, repair and leftovers. - Strings in every locale. - Review fixes: the library cache is saved only by the newest scan; an abandoned session's Steam logs come from the client it recorded; distinct VAC console names; FEXInterpreter in CPU pinning; clearer VAC hint in pl, ru, uk, cs and bg.
327 lines
12 KiB
Python
Executable File
327 lines
12 KiB
Python
Executable File
#!/usr/bin/python3
|
|
import json
|
|
import os
|
|
import re
|
|
import runpy
|
|
import subprocess
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
SYNC_KEYS = ("BL_SYNC", "BL_SYNC_FALLBACK", "BL_FSYNC_FIRST", "BL_SYNC_MIN_NOFILE", "PROTON_NO_ESYNC", "PROTON_NO_FSYNC", "PROTON_NO_NTSYNC", "WINEESYNC")
|
|
SEED_REDISTS = "/usr/local/bin/droiddeck-seed-redists"
|
|
PACK_KEYS = ("WINESERVER", "BL_SYNC_PACK", "WINEESYNC", "PROTON_NO_ESYNC", "PROTON_NO_FSYNC")
|
|
|
|
|
|
def game_id(env):
|
|
prefix = env.get("STEAM_COMPAT_DATA_PATH", "").rstrip("/")
|
|
if not prefix:
|
|
return None
|
|
value = prefix.rsplit("/", 1)[-1]
|
|
if not re.fullmatch(r"-?[0-9]+", value):
|
|
return None
|
|
number = int(value)
|
|
if not -(2**31) <= number < 2**32 or number == 0:
|
|
return None
|
|
return str(number % 2**32)
|
|
|
|
|
|
DOTNET_FEX = {
|
|
"FEX_TSOENABLED": "1",
|
|
"FEX_VECTORTSOENABLED": "1",
|
|
"FEX_MEMCPYSETTSOENABLED": "1",
|
|
"FEX_HALFBARRIERTSOENABLED": "1",
|
|
"FEX_X87REDUCEDPRECISION": "0",
|
|
"FEX_MULTIBLOCK": "0",
|
|
}
|
|
|
|
|
|
def game_files(exe):
|
|
"""Lower-cased names of the files next to the game's executable and one directory below."""
|
|
names = set()
|
|
folder = os.path.dirname(exe)
|
|
try:
|
|
with os.scandir(folder) as top:
|
|
for entry in top:
|
|
names.add(entry.name.lower())
|
|
if entry.is_dir(follow_symlinks=False):
|
|
try:
|
|
with os.scandir(entry.path) as inner:
|
|
names.update(e.name.lower() for e in inner)
|
|
except OSError:
|
|
pass
|
|
except OSError:
|
|
pass
|
|
return names
|
|
|
|
|
|
class Game:
|
|
"""What a fix gets to look at: the executable, its launch arguments and the files beside it."""
|
|
|
|
def __init__(self, exe, args):
|
|
self.exe = exe
|
|
self.args = args
|
|
self.stem = os.path.splitext(os.path.basename(exe))[0].lower()
|
|
self.files = game_files(exe)
|
|
|
|
def has_arg(self, name):
|
|
return any(a == name or a.startswith(name + "=") for a in self.args)
|
|
|
|
|
|
FIXES = []
|
|
|
|
|
|
def fix(function):
|
|
FIXES.append(function)
|
|
return function
|
|
|
|
|
|
def is_godot(game):
|
|
return game.stem + ".pck" in game.files or "godotsharp.dll" in game.files
|
|
|
|
|
|
@fix
|
|
def dotnet_memory_ordering(game):
|
|
if "coreclr.dll" in game.files:
|
|
return DOTNET_FEX, [], ".NET runtime: FEX with full TSO and without multiblock"
|
|
|
|
|
|
@fix
|
|
def godot_vulkan(game):
|
|
if is_godot(game) and not game.has_arg("--rendering-driver"):
|
|
return {}, ["--rendering-driver", "vulkan"], "Godot: Vulkan renderer"
|
|
|
|
|
|
@fix
|
|
def godot_sentry(game):
|
|
sentry = sorted(n[:-4] for n in game.files if n.startswith("libsentry.windows.") and n.endswith(".dll"))
|
|
if is_godot(game) and sentry:
|
|
return {"WINEDLLOVERRIDES": ";".join(n + "=d" for n in sentry)}, [], "Godot: Sentry crash handler off"
|
|
|
|
|
|
@fix
|
|
def arkham_city_x87(game):
|
|
"""Batman: Arkham City (BatmanAC.exe, also started through BmLauncher.exe beside it) leans on x87
|
|
and stops with Unreal's "Fatal error!" right after start when FEX reduces its precision."""
|
|
if "batmanac.exe" in game.files:
|
|
return {"FEX_X87REDUCEDPRECISION": "0"}, [], "Batman: Arkham City: FEX with full x87 precision"
|
|
|
|
|
|
def skip_red_launcher(command):
|
|
"""Cyberpunk 2077's prelauncher opens REDlauncher, a Qt WebEngine window that hands over to the
|
|
game half a minute later and then stays up beside it, well over a core busy for as long as the
|
|
game runs. The game is started itself instead; the prelauncher's own --launcher-skip started it
|
|
twice."""
|
|
if len(command) > 2 and os.path.basename(command[2]).lower() == "redprelauncher.exe":
|
|
game = os.path.join(os.path.dirname(command[2]), "bin", "x64", "Cyberpunk2077.exe")
|
|
if os.path.isfile(game):
|
|
print("droiddeck-game-env: REDlauncher skipped", file=sys.stderr)
|
|
return command[:2] + [game] + command[3:]
|
|
return command
|
|
|
|
|
|
def engine_fixes(exe, args):
|
|
"""Environment and extra arguments a game needs because of what it is built with."""
|
|
game = Game(exe, args)
|
|
env, extra, notes = {}, [], []
|
|
for check in FIXES:
|
|
found = check(game)
|
|
if found:
|
|
env.update(found[0])
|
|
extra += found[1]
|
|
notes.append(found[2])
|
|
return env, extra, notes
|
|
|
|
|
|
def win_components(compat, app_id):
|
|
"""The game's Windows components put into its prefix; returns their WINEDLLOVERRIDES entries."""
|
|
if not compat:
|
|
return ""
|
|
try:
|
|
module = runpy.run_path(str(Path(__file__).resolve().parent / "droiddeck-wincomponents"))
|
|
names, notes = module["apply"](compat.rstrip("/"), app_id)
|
|
for note in notes:
|
|
print("droiddeck-game-env: " + note, file=sys.stderr)
|
|
return module["overrides_value"](names)
|
|
except Exception as error:
|
|
print("droiddeck-game-env: Windows components not applied (%s)" % error, file=sys.stderr)
|
|
return ""
|
|
|
|
|
|
def apply_config(env, config, app_id, fixes=None):
|
|
if config.get("version") != 1:
|
|
raise ValueError("unsupported environment configuration")
|
|
result = env.copy()
|
|
entries = dict(config.get("shared", {}))
|
|
for name, value in (fixes or {}).items():
|
|
if name == "WINEDLLOVERRIDES" and entries.get(name, env.get(name)):
|
|
value = entries.get(name, env.get(name)) + ";" + value
|
|
entries[name] = value
|
|
entries.update(config.get("games", {}).get(app_id, {}))
|
|
for name, value in entries.items():
|
|
if not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", name):
|
|
raise ValueError("invalid environment name")
|
|
if value is None:
|
|
result.pop(name, None)
|
|
elif isinstance(value, str) and "\0" not in value and len(value) <= 8192:
|
|
result[name] = value
|
|
else:
|
|
raise ValueError("invalid environment value")
|
|
game_dxvk = config.get("dxvkConfigGames", {})
|
|
if not isinstance(game_dxvk, dict):
|
|
raise ValueError("invalid game dxvk configuration")
|
|
dxvk = game_dxvk.get(app_id, config.get("dxvkConfig"))
|
|
if dxvk is not None:
|
|
if not isinstance(dxvk, str) or "\0" in dxvk or len(dxvk) > 8192:
|
|
raise ValueError("invalid dxvk configuration")
|
|
if dxvk:
|
|
own = result.get("DXVK_CONFIG", "").strip().rstrip(";").strip()
|
|
result["DXVK_CONFIG"] = own + "; " + dxvk if own else dxvk
|
|
return result
|
|
|
|
|
|
def sync_config(config, app_id):
|
|
games = config.get("games", {})
|
|
return {
|
|
"version": config.get("version"),
|
|
"shared": {name: value for name, value in config.get("shared", {}).items() if name in SYNC_KEYS},
|
|
"games": {app_id: {name: value for name, value in games.get(app_id, {}).items() if name in SYNC_KEYS}},
|
|
}
|
|
|
|
|
|
def load_sync():
|
|
try:
|
|
return runpy.run_path(str(Path(__file__).resolve().parent / "droiddeck-esync"))
|
|
except Exception as error:
|
|
print("droiddeck-game-env: sync selection failed (%s); stock launch" % error, file=sys.stderr)
|
|
return None
|
|
|
|
|
|
def select_sync(command, env, sync=None):
|
|
try:
|
|
sync = sync if sync is not None else load_sync()
|
|
if sync is None:
|
|
return command, env
|
|
chosen, chosen_env = sync["select"](command, env)
|
|
if chosen and all(isinstance(value, str) for value in chosen) and isinstance(chosen_env, dict):
|
|
return list(chosen), dict(chosen_env)
|
|
except Exception as error:
|
|
print("droiddeck-game-env: sync selection failed (%s); stock launch" % error, file=sys.stderr)
|
|
return command, env
|
|
|
|
|
|
def record_stock(sync, command, env):
|
|
try:
|
|
if sync is not None and "record" in sync:
|
|
sync["record"](command, env)
|
|
except Exception as error:
|
|
print("droiddeck-game-env: stock launch not recorded (%s)" % error, file=sys.stderr)
|
|
|
|
|
|
def without_pack(chosen_env, env):
|
|
result = dict(chosen_env)
|
|
for name in PACK_KEYS:
|
|
if name in env:
|
|
result[name] = env[name]
|
|
else:
|
|
result.pop(name, None)
|
|
return result
|
|
|
|
|
|
SSBS_LIB = "/usr/local/lib/libssbs.so"
|
|
|
|
|
|
def force_ssbs(command, env):
|
|
"""DROIDDECK_FORCE_SSBS=1 (a game's or the shared environment): preload libssbs.so into this
|
|
Proton's Wine, which then keeps PSTATE.SSBS set across signal returns - speculative store
|
|
bypass stays allowed, as force_ssbs.diff does inside a rebuilt ntdll. ARM64 Protons only: the
|
|
library is aarch64 and only arm64 Wine has the signal path it fixes."""
|
|
if env.get("DROIDDECK_FORCE_SSBS", "").lower() not in ("1", "on", "true", "yes"):
|
|
return env
|
|
proton = os.path.dirname(command[0]) if command else ""
|
|
if not os.path.isdir(os.path.join(proton, "files/lib/wine/aarch64-unix")):
|
|
print("droiddeck-game-env: force SSBS asked for, but this Proton is not an ARM64 one; left off", file=sys.stderr)
|
|
return env
|
|
if not os.path.isfile(SSBS_LIB):
|
|
print("droiddeck-game-env: force SSBS asked for, but %s is missing; left off" % SSBS_LIB, file=sys.stderr)
|
|
return env
|
|
parts = [p for p in re.split(r"[:\s]+", env.get("LD_PRELOAD", "")) if p]
|
|
if SSBS_LIB not in parts:
|
|
env = dict(env, LD_PRELOAD=":".join(parts + [SSBS_LIB]))
|
|
print("droiddeck-game-env: force SSBS on (libssbs.so preloaded)", file=sys.stderr)
|
|
return env
|
|
|
|
|
|
EVALUATOR_SCRIPT = re.compile(r"(?:^|[\\/])evaluatorscript_[0-9]+\.vdf$", re.IGNORECASE)
|
|
|
|
|
|
def mark_install_scripts(command, env):
|
|
"""The client is about to run a game's install scripts (iscriptevaluator.exe): mark every process
|
|
in them but a Vulkan runtime installer as already run first, so no redistributable installer
|
|
starts - on first launch the shared ones may still be downloading, and on ARM64 Proton the VC++
|
|
ones stop with an error."""
|
|
if not any(arg.lower().replace("\\", "/").endswith("iscriptevaluator.exe") for arg in command):
|
|
return
|
|
root = env.get("BL_X64_STEAM_ROOT") or env.get("STEAM_COMPAT_CLIENT_INSTALL_PATH") or str(Path.home() / ".local/share/Steam")
|
|
scripts = [str(Path(root) / arg.replace("\\", "/")) for arg in command if EVALUATOR_SCRIPT.search(arg)]
|
|
scripts = [path for path in scripts if os.path.isfile(path)]
|
|
if not scripts:
|
|
return
|
|
try:
|
|
subprocess.run([SEED_REDISTS, root], env=dict(env, DROIDDECK_SEED_SCRIPTS="\n".join(scripts)),
|
|
stdout=sys.stderr, timeout=60, check=False)
|
|
except (OSError, subprocess.SubprocessError) as error:
|
|
print("droiddeck-game-env: install scripts not marked (%s)" % error, file=sys.stderr)
|
|
|
|
|
|
def main():
|
|
command = sys.argv[1:]
|
|
if not command:
|
|
return 2
|
|
env = os.environ.copy()
|
|
mic_enabled = env.get("BL_MIC_ENABLED")
|
|
mark_install_scripts(command, env)
|
|
app_id = game_id(env)
|
|
if app_id:
|
|
waiting = len(command) > 1 and command[1] == "waitforexitandrun"
|
|
fixes = {}
|
|
if waiting:
|
|
command = skip_red_launcher(command)
|
|
fixes, extra, notes = engine_fixes(command[2], command[3:]) if len(command) > 2 else ({}, [], [])
|
|
for note in notes:
|
|
print("droiddeck-game-env: " + note, file=sys.stderr)
|
|
command += extra
|
|
components = win_components(env.get("STEAM_COMPAT_DATA_PATH", ""), app_id)
|
|
if components:
|
|
own = fixes.get("WINEDLLOVERRIDES")
|
|
fixes["WINEDLLOVERRIDES"] = components + ";" + own if own else components
|
|
path = Path.home() / ".config/droiddeck/game-environment.json"
|
|
try:
|
|
with path.open(encoding="utf-8") as source:
|
|
config = json.load(source)
|
|
if waiting:
|
|
env = apply_config(env, config, app_id, fixes)
|
|
else:
|
|
env = apply_config(env, sync_config(config, app_id), app_id)
|
|
except FileNotFoundError:
|
|
if waiting:
|
|
env = apply_config(env, {"version": 1}, app_id, fixes)
|
|
except (OSError, ValueError, TypeError, AttributeError):
|
|
print("droiddeck-game-env: invalid configuration; using inherited environment", file=sys.stderr)
|
|
if mic_enabled == "0":
|
|
env["BANNER_AUDIO_DIRECT_MIC"] = "0"
|
|
env = force_ssbs(command, env)
|
|
sync = load_sync()
|
|
launch, launch_env = select_sync(command, env, sync)
|
|
if launch[0] != command[0]:
|
|
try:
|
|
os.execvpe(launch[0], launch, launch_env)
|
|
except OSError as error:
|
|
print("droiddeck-game-env: %s could not start (%s); stock launch" % (launch[0], error), file=sys.stderr)
|
|
launch, launch_env = command, without_pack(launch_env, env)
|
|
record_stock(sync, launch, launch_env)
|
|
os.execvpe(launch[0], launch, launch_env)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|