def on_game_quit(self):
"""Restore some settings and cleanup after game quit."""
if self.prelaunch_executor and self.prelaunch_executor.is_running:
logger.info("Stopping prelaunch script")
self.prelaunch_executor.stop()
self.heartbeat = None
if self.state != self.STATE_STOPPED:
logger.warning("Game still running (state: %s)", self.state)
self.stop()
# Check for post game script
postexit_command = self.runner.system_config.get("postexit_command")
if postexit_command:
command_array = shlex.split(postexit_command)
if system.path_exists(command_array[0]):
logger.info("Running post-exit command: %s", postexit_command)
postexit_thread = MonitoredCommand(
command_array,
include_processes=[os.path.basename(postexit_command)],
env=self.game_runtime_config["env"],
cwd=self.directory,
)
postexit_thread.start()
quit_time = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime())
logger.debug("%s stopped at %s", self.name, quit_time)
self.lastplayed = int(time.time())
self.save(save_config=False)
os.chdir(os.path.expanduser("~"))
if self.antimicro_thread:
self.antimicro_thread.stop()
if self.resolution_changed or self.runner.system_config.get(
"reset_desktop"):
DISPLAY_MANAGER.set_resolution(self.original_outputs)
if self.compositor_disabled:
self.set_desktop_compositing(True)
if self.screen_saver_inhibitor_cookie is not None:
SCREEN_SAVER_INHIBITOR.uninhibit(
self.screen_saver_inhibitor_cookie)
self.screen_saver_inhibitor_cookie = None
if self.runner.system_config.get("use_us_layout"):
with subprocess.Popen(["setxkbmap"], env=os.environ) as setxkbmap:
setxkbmap.communicate()
if self.runner.system_config.get("restore_gamma"):
restore_gamma()
self.process_return_codes()
def on_game_quit(self):
"""Restore some settings and cleanup after game quit."""
if self.prelaunch_executor and self.prelaunch_executor.is_running:
logger.info("Stopping prelaunch script")
self.prelaunch_executor.stop()
self.heartbeat = None
if self.state != self.STATE_STOPPED:
logger.warning("Game still running (state: %s)", self.state)
self.stop()
# Check for post game script
postexit_command = self.runner.system_config.get("postexit_command")
if system.path_exists(postexit_command):
logger.info("Running post-exit command: %s", postexit_command)
postexit_thread = MonitoredCommand(
[postexit_command],
include_processes=[os.path.basename(postexit_command)],
env=self.game_runtime_config["env"],
cwd=self.directory,
)
postexit_thread.start()
if self.discord_presence.available:
self.discord_presence.clear_discord_rich_presence()
quit_time = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime())
logger.debug("%s stopped at %s", self.name, quit_time)
self.lastplayed = int(time.time())
self.save(metadata_only=True)
os.chdir(os.path.expanduser("~"))
if self.resolution_changed or self.runner.system_config.get(
"reset_desktop"):
DISPLAY_MANAGER.set_resolution(self.original_outputs)
if self.compositor_disabled:
self.set_desktop_compositing(True)
if self.runner.system_config.get("use_us_layout"):
subprocess.Popen(["setxkbmap"], env=os.environ).communicate()
if self.runner.system_config.get("restore_gamma"):
restore_gamma()
self.process_return_codes()
if self.exit_main_loop:
exit()
def __init__(self, installer, parent):
super().__init__()
self.target_path = None
self.parent = parent
self.service = parent.service if parent else None
self.appid = parent.appid if parent else None
self.game_dir_created = False # Whether a game folder was created during the install
# Extra files for installers, either None if the extras haven't been checked yet.
# Or a list of IDs of extras to be downloaded during the install
self.extras = None
self.game_disc = None
self.game_files = {}
self.cancelled = False
self.abort_current_task = None
self.user_inputs = []
self.current_command = 0 # Current installer command when iterating through them
self.runners_to_install = []
self.installer = LutrisInstaller(installer,
self,
service=self.service,
appid=self.appid)
if not self.installer.script:
raise ScriptingError(
_("This installer doesn't have a 'script' section"))
script_errors = self.installer.get_errors()
if script_errors:
raise ScriptingError(
_("Invalid script: \n{}").format("\n".join(script_errors)),
self.installer.script)
self.current_resolution = DISPLAY_MANAGER.get_current_resolution()
self._check_binary_dependencies()
self._check_dependency()
if self.installer.creates_game_folder:
self.target_path = self.get_default_target()
def get_output_choices():
"""Return list of outputs for drop-downs"""
displays = DISPLAY_MANAGER.get_display_names()
output_choices = list(zip(displays, displays))
output_choices.insert(0, ("Off", "off"))
output_choices.insert(1, ("Primary", "primary"))
return output_choices
def __init__(self, installer, parent):
super().__init__()
self.target_path = None
self.parent = parent
self.game_dir_created = False # Whether a game folder was created during the install
self.game_disc = None
self.game_files = {}
self.cancelled = False
self.abort_current_task = None
self.user_inputs = []
self.current_command = 0 # Current installer command when iterating through them
self.runners_to_install = []
self.installer = LutrisInstaller(installer, self)
if not self.installer.script:
raise ScriptingError("This installer doesn't have a 'script' section")
script_errors = self.installer.get_errors()
if script_errors:
raise ScriptingError(
"Invalid script: \n{}".format("\n".join(script_errors)), self.installer.script
)
self.current_resolution = DISPLAY_MANAGER.get_current_resolution()
self._check_binary_dependencies()
self._check_dependency()
if self.installer.creates_game_folder:
self.target_path = self.get_default_target()
def get_resolution_choices():
"""Return list of available resolutions as label, value tuples
suitable for inclusion in drop-downs.
"""
resolutions = DISPLAY_MANAGER.get_resolutions()
resolution_choices = list(zip(resolutions, resolutions))
resolution_choices.insert(0, ("Keep current", "off"))
return resolution_choices
def get_output_list():
"""Return a list of output with their index.
This is used to indicate to SDL 1.2 which monitor to use.
"""
choices = [("Off", "off")]
displays = DISPLAY_MANAGER.get_display_names()
for index, output in enumerate(displays):
# Display name can't be used because they might not be in the right order
# Using DISPLAYS to get the number of connected monitors
choices.append((output, str(index)))
return choices
def get_params(self): # pylint: disable=too-many-branches
params = []
model = self.runner_config.get("model")
cpumodel = self.runner_config.get("cpumodel")
fmemory = self.runner_config.get("fmemory")
ziiimem = self.runner_config.get("ziiimem")
fdvolume = self.runner_config.get("fdvolume")
fdspeed = self.runner_config.get("fdspeed")
grafixcard = self.runner_config.get("grafixcard")
grafixmemory = self.runner_config.get("grafixmemory")
kickstart_file = self.runner_config.get("kickstart_file")
if kickstart_file:
params.append("--kickstart_file=%s" % kickstart_file)
kickstart_ext_file = self.runner_config.get("kickstart_ext_file")
if kickstart_ext_file:
params.append("--kickstart_ext_file=%s" % kickstart_ext_file)
if model:
params.append("--amiga_model=%s" % model)
if cpumodel:
params.append("--cpu=%s" % cpumodel)
if fmemory:
params.append("--fast_memory=%s" % fmemory)
if ziiimem:
params.append("--zorro_iii_memory=%s" % ziiimem)
if fdvolume:
params.append("--floppy_drive_volume=%s" % fdvolume)
if fdspeed:
params.append("--floppy_drive_speed=%s" % fdspeed)
if grafixcard:
params.append("--graphics_card=%s" % grafixcard)
if grafixmemory:
params.append("--graphics_memory=%s" % grafixmemory)
if self.runner_config.get("gfx_fullscreen_amiga"):
width = int(DISPLAY_MANAGER.get_current_resolution()[0])
params.append("--fullscreen")
# params.append("--fullscreen_mode=fullscreen-window")
params.append("--fullscreen_mode=fullscreen")
params.append("--fullscreen_width=%d" % width)
if self.runner_config.get("jitcompiler"):
params.append("--jit_compiler=1")
if self.runner_config.get("bsdsocket"):
params.append("--bsdsocket_library=1")
if self.runner_config.get("gamemode"):
params.append("--game_mode=0")
if self.runner_config.get("govwarning"):
params.append("--governor_warning=0")
if self.runner_config.get("scanlines"):
params.append("--scanlines=1")
return params
def play(self):
"""Runs the game"""
rom = self.game_config.get("main_file") or ""
machine = self.game_config.get("machine") or ""
fullscreen = self.runner_config.get("fs") or "0"
if fullscreen is True:
fullscreen = "1"
elif fullscreen is False:
fullscreen = "0"
stretch = self.runner_config.get("stretch") or "0"
scaler = self.runner_config.get("scaler") or DEFAULT_MEDNAFEN_SCALER
sound_device = self.runner_config.get("sound_device")
xres, yres = DISPLAY_MANAGER.get_current_resolution()
options = [
"-fs",
fullscreen,
"-force_module",
machine,
"-sound.device",
sound_device,
"-" + machine + ".xres",
xres,
"-" + machine + ".yres",
yres,
"-" + machine + ".stretch",
stretch,
"-" + machine + ".special",
scaler,
"-" + machine + ".videoip",
"1",
]
joy_ids = self.find_joysticks()
dont_map_controllers = self.runner_config.get("dont_map_controllers")
if joy_ids and not dont_map_controllers:
controls = self.set_joystick_controls(joy_ids, machine)
for control in controls:
options.append(control)
if not system.path_exists(rom):
return {"error": "FILE_NOT_FOUND", "file": rom}
command = [self.get_executable()]
for option in options:
command.append(option)
command.append(rom)
return {"command": command}
def set_virtual_desktop(self, enabled):
"""Enable or disable wine virtual desktop.
The Lutris virtual desktop is refered to as 'WineDesktop', in Wine the
virtual desktop name is 'default'.
"""
path = self.hkcu_prefix + "/Software/Wine/Explorer"
if enabled:
self.set_registry_key(path, "Desktop", "WineDesktop")
default_resolution = "x".join(DISPLAY_MANAGER.get_current_resolution())
logger.debug("Enabling wine virtual desktop with default resolution of %s", default_resolution)
self.set_registry_key(
self.hkcu_prefix + "/Software/Wine/Explorer/Desktops",
"WineDesktop",
default_resolution
)
else:
self.clear_registry_key(path)
def play(self):
"""Runs the game"""
rom = self.game_config.get("main_file") or ""
machine = self.game_config.get("machine") or ""
fullscreen = self.runner_config.get("fs") or "0"
if fullscreen is True:
fullscreen = "1"
elif fullscreen is False:
fullscreen = "0"
stretch = self.runner_config.get("stretch") or "0"
scaler = self.runner_config.get("scaler") or "hq4x"
xres, yres = DISPLAY_MANAGER.get_current_resolution()
options = [
"-fs",
fullscreen,
"-force_module",
machine,
"-" + machine + ".xres",
xres,
"-" + machine + ".yres",
yres,
"-" + machine + ".stretch",
stretch,
"-" + machine + ".special",
scaler,
"-" + machine + ".videoip",
"1",
]
joy_ids = self.find_joysticks()
dont_map_controllers = self.runner_config.get("dont_map_controllers")
if joy_ids and not dont_map_controllers:
controls = self.set_joystick_controls(joy_ids, machine)
for control in controls:
options.append(control)
if not system.path_exists(rom):
return {"error": "FILE_NOT_FOUND", "file": rom}
command = [self.get_executable()]
for option in options:
command.append(option)
command.append(rom)
return {"command": command}
def set_virtual_desktop(self, enabled):
"""Enable or disable wine virtual desktop.
The Lutris virtual desktop is refered to as 'WineDesktop', in Wine the
virtual desktop name is 'default'.
"""
path = self.hkcu_prefix + "/Software/Wine/Explorer"
if enabled:
self.set_registry_key(path, "Desktop", "WineDesktop")
default_resolution = "x".join(DISPLAY_MANAGER.get_current_resolution())
logger.debug("Enabling wine virtual desktop with default resolution of %s",
default_resolution)
self.set_registry_key(
self.hkcu_prefix + "/Software/Wine/Explorer/Desktops",
"WineDesktop",
default_resolution
)
else:
self.clear_registry_key(path)
def restrict_to_display(self, display):
outputs = DISPLAY_MANAGER.get_config()
if display == "primary":
display = None
for output in outputs:
if output.primary:
display = output.name
break
if not display:
logger.warning("No primary display set")
else:
found = any(output.name == display for output in outputs)
if not found:
logger.warning("Selected display %s not found", display)
display = None
if display:
turn_off_except(display)
time.sleep(3)
return True
return False
def get_params(self):
params = []
model = self.runner_config.get("model")
fmemory = self.runner_config.get("fmemory")
fdvolume = self.runner_config.get("fdvolume")
fdspeed = self.runner_config.get("fdspeed")
grafixcard = self.runner_config.get("grafixcard")
grafixmemory = self.runner_config.get("grafixmemory")
kickstart_file = self.runner_config.get("kickstart_file")
if kickstart_file:
params.append("--kickstart_file=%s" % kickstart_file)
kickstart_ext_file = self.runner_config.get("kickstart_ext_file")
if kickstart_ext_file:
params.append("--kickstart_ext_file=%s" % kickstart_ext_file)
if model:
params.append("--amiga_model=%s" % model)
if fmemory:
params.append("--fast_memory=%s" % fmemory)
if fdvolume:
params.append("--floppy_drive_volume_empty=%s" % fdvolume)
if fdspeed:
params.append("--floppy_drive_volume_empty=%s" % fdspeed)
if grafixcard:
params.append("--graphics_card=%s" % grafixcard)
if grafixmemory:
params.append("--graphics_memory=%s" % grafixmemory)
if self.runner_config.get("gfx_fullscreen_amiga"):
width = int(DISPLAY_MANAGER.get_current_resolution()[0])
params.append("--fullscreen")
# params.append("--fullscreen_mode=fullscreen-window")
params.append("--fullscreen_mode=fullscreen")
params.append("--fullscreen_width=%d" % width)
if self.runner_config.get("jitcompiler"):
params.append("--jit_compiler=1")
if self.runner_config.get("jitcompiler"):
params.append("--bsdsocket_library=1")
if self.runner_config.get("scanlines"):
params.append("--scanlines=1")
return params
def get_params(self):
params = []
model = self.runner_config.get("model")
fmemory = self.runner_config.get("fmemory")
fdvolume = self.runner_config.get("fdvolume")
fdspeed = self.runner_config.get("fdspeed")
grafixcard = self.runner_config.get("grafixcard")
grafixmemory = self.runner_config.get("grafixmemory")
kickstart_file = self.runner_config.get("kickstart_file")
if kickstart_file:
params.append("--kickstart_file=%s" % kickstart_file)
kickstart_ext_file = self.runner_config.get("kickstart_ext_file")
if kickstart_ext_file:
params.append("--kickstart_ext_file=%s" % kickstart_ext_file)
if model:
params.append("--amiga_model=%s" % model)
if fmemory:
params.append("--fast_memory=%s" % fmemory)
if fdvolume:
params.append("--floppy_drive_volume_empty=%s" % fdvolume)
if fdspeed:
params.append("--floppy_drive_volume_empty=%s" % fdspeed)
if grafixcard:
params.append("--graphics_card=%s" % grafixcard)
if grafixmemory:
params.append("--graphics_memory=%s" % grafixmemory)
if self.runner_config.get("gfx_fullscreen_amiga"):
width = int(DISPLAY_MANAGER.get_current_resolution()[0])
params.append("--fullscreen")
# params.append("--fullscreen_mode=fullscreen-window")
params.append("--fullscreen_mode=fullscreen")
params.append("--fullscreen_width=%d" % width)
if self.runner_config.get("jitcompiler"):
params.append("--jit_compiler=1")
if self.runner_config.get("jitcompiler"):
params.append("--bsdsocket_library=1")
if self.runner_config.get("scanlines"):
params.append("--scanlines=1")
return params
def get_params(self): # pylint: disable=too-many-branches
params = []
option_params = {
"kickstart_file": "--kickstart_file=%s",
"kickstart_ext_file": "--kickstart_ext_file=%s",
"model": "--amiga_model=%s",
"cpumodel": "--cpu=%s",
"fmemory": "--fast_memory=%s",
"ziiimem": "--zorro_iii_memory=%s",
"fdvolume": "--floppy_drive_volume=%s",
"fdspeed": "--floppy_drive_speed=%s",
"grafixcard": "--graphics_card=%s",
"grafixmemory": "--graphics_memory=%s",
}
for option, param in option_params.items():
option_value = self.runner_config.get(option)
if option_value:
params.append(param % option_value)
if self.runner_config.get("gfx_fullscreen_amiga"):
width = int(DISPLAY_MANAGER.get_current_resolution()[0])
params.append("--fullscreen")
# params.append("--fullscreen_mode=fullscreen-window")
params.append("--fullscreen_mode=fullscreen")
params.append("--fullscreen_width=%d" % width)
if self.runner_config.get("jitcompiler"):
params.append("--jit_compiler=1")
if self.runner_config.get("bsdsocket"):
params.append("--bsdsocket_library=1")
if self.runner_config.get("gamemode"):
params.append("--game_mode=0")
if self.runner_config.get("govwarning"):
params.append("--governor_warning=0")
if self.runner_config.get("scanlines"):
params.append("--scanlines=1")
return params
def __init__(self, installer, parent):
self.error = None
self.errors = []
self.target_path = None
self.parent = parent
self.game_dir_created = False # Whether a game folder was created during the install
self.game_files = {}
self.game_disc = None
self.cancelled = False
self.abort_current_task = None
self.user_inputs = []
self.steam_data = {}
self.gog_data = {}
self.script = installer.get("script")
if not self.script:
raise ScriptingError("This installer doesn't have a 'script' section")
self.script_pretty = json.dumps(self.script, indent=4)
self.install_start_time = None # Time of the start of the install
self.steam_poll = None # Reference to the Steam poller that checks if games are downloaded
self.current_command = None # Current installer command when iterating through them
self.current_file_id = None # Current file when downloading / gathering files
self.runners_to_install = []
self.prev_states = [] # Previous states for the Steam installer
self.version = installer["version"]
self.slug = installer["slug"]
self.year = installer.get("year")
self.runner = installer["runner"]
self.game_name = self.script.get("custom-name") or installer["name"]
self.game_slug = installer["game_slug"]
self.steamid = installer.get("steamid")
self.gogid = installer.get("gogid")
if not self.is_valid():
raise ScriptingError(
"Invalid script: \n{}".format("\n".join(self.errors)), self.script
)
self.files = [
InstallerFile(self.game_slug, file_id, file_meta)
for file_desc in self.script.get("files", [])
for file_id, file_meta in file_desc.items()
]
self.requires = self.script.get("requires")
self.extends = self.script.get("extends")
self.current_resolution = DISPLAY_MANAGER.get_current_resolution()
self._check_binary_dependencies()
self._check_dependency()
if self.creates_game_folder:
self.target_path = self.get_default_target()
# If the game is in the library and uninstalled, the first installation
# updates it
existing_game = pga.get_game_by_field(self.game_slug, "slug")
if existing_game and not existing_game["installed"]:
self.game_id = existing_game["id"]
else:
self.game_id = None
def __init__(self, installer, parent):
self.error = None
self.errors = []
self.target_path = None
self.parent = parent
self.game_dir_created = False # Whether a game folder was created during the install
self.game_files = {}
self.game_disc = None
self.cancelled = False
self.abort_current_task = None
self.user_inputs = []
self.steam_data = {}
self.gog_data = {}
self.script = installer.get("script")
if not self.script:
raise ScriptingError(
"This installer doesn't have a 'script' section")
self.script_pretty = json.dumps(self.script, indent=4)
self.install_start_time = None # Time of the start of the install
self.steam_poll = None # Reference to the Steam poller that checks if games are downloaded
self.current_command = None # Current installer command when iterating through them
self.current_file_id = None # Current file when downloading / gathering files
self.runners_to_install = []
self.prev_states = [] # Previous states for the Steam installer
self.version = installer["version"]
self.slug = installer["slug"]
self.year = installer.get("year")
self.runner = installer["runner"]
self.game_name = self.script.get("custom-name") or installer["name"]
self.game_slug = installer["game_slug"]
self.steamid = installer.get("steamid")
self.gogid = installer.get("gogid")
if not self.is_valid():
raise ScriptingError(
"Invalid script: \n{}".format("\n".join(self.errors)),
self.script)
self.files = [
InstallerFile(self.game_slug, file_id, file_meta)
for file_desc in self.script.get("files", [])
for file_id, file_meta in file_desc.items()
]
self.requires = self.script.get("requires")
self.extends = self.script.get("extends")
self.current_resolution = DISPLAY_MANAGER.get_current_resolution()
self._check_binary_dependencies()
self._check_dependency()
if self.creates_game_folder:
self.target_path = self.get_default_target()
# If the game is in the library and uninstalled, the first installation
# updates it
existing_game = pga.get_game_by_field(self.game_slug, "slug")
if existing_game and not existing_game["installed"]:
self.game_id = existing_game["id"]
else:
self.game_id = None
def configure_game(self, prelaunched, error=None):
"""Get the game ready to start, applying all the options
This methods sets the game_runtime_config attribute.
"""
if error:
logger.error(error)
dialogs.ErrorDialog(str(error))
if not prelaunched:
logger.error("Game prelaunch unsuccessful")
dialogs.ErrorDialog("An error prevented the game from running")
self.state = self.STATE_STOPPED
self.emit("game-stop")
return
system_config = self.runner.system_config
self.original_outputs = DISPLAY_MANAGER.get_config()
gameplay_info = self.runner.play()
if "error" in gameplay_info:
self.show_error_message(gameplay_info)
self.state = self.STATE_STOPPED
self.emit("game-stop")
return
logger.debug("Launching %s: %s", self.name, gameplay_info)
logger.debug("Game info: %s", json.dumps(gameplay_info, indent=2))
env = {}
sdl_gamecontrollerconfig = system_config.get(
"sdl_gamecontrollerconfig")
if sdl_gamecontrollerconfig:
path = os.path.expanduser(sdl_gamecontrollerconfig)
if system.path_exists(path):
with open(path, "r") as controllerdb_file:
sdl_gamecontrollerconfig = controllerdb_file.read()
env["SDL_GAMECONTROLLERCONFIG"] = sdl_gamecontrollerconfig
sdl_video_fullscreen = system_config.get("sdl_video_fullscreen") or ""
env["SDL_VIDEO_FULLSCREEN_DISPLAY"] = sdl_video_fullscreen
restrict_to_display = system_config.get("display")
if restrict_to_display != "off":
if restrict_to_display == "primary":
restrict_to_display = None
for output in self.original_outputs:
if output.primary:
restrict_to_display = output.name
break
if not restrict_to_display:
logger.warning("No primary display set")
else:
found = False
for output in self.original_outputs:
if output.name == restrict_to_display:
found = True
break
if not found:
logger.warning("Selected display %s not found",
restrict_to_display)
restrict_to_display = None
if restrict_to_display:
turn_off_except(restrict_to_display)
time.sleep(3)
self.resolution_changed = True
resolution = system_config.get("resolution")
if resolution != "off":
DISPLAY_MANAGER.set_resolution(resolution)
time.sleep(3)
self.resolution_changed = True
if system_config.get("reset_pulse"):
audio.reset_pulse()
self.killswitch = system_config.get("killswitch")
if self.killswitch and not system.path_exists(self.killswitch):
# Prevent setting a killswitch to a file that doesn't exists
self.killswitch = None
# Command
launch_arguments = gameplay_info["command"]
optimus = system_config.get("optimus")
if optimus == "primusrun" and system.find_executable("primusrun"):
launch_arguments.insert(0, "primusrun")
elif optimus == "optirun" and system.find_executable("optirun"):
launch_arguments.insert(0, "virtualgl")
launch_arguments.insert(0, "-b")
launch_arguments.insert(0, "optirun")
elif optimus == "pvkrun" and system.find_executable("pvkrun"):
launch_arguments.insert(0, "pvkrun")
xephyr = system_config.get("xephyr") or "off"
if xephyr != "off":
if not system.find_executable("Xephyr"):
raise GameConfigError(
"Unable to find Xephyr, install it or disable the Xephyr option"
)
xephyr_depth = "8" if xephyr == "8bpp" else "16"
xephyr_resolution = system_config.get(
"xephyr_resolution") or "640x480"
xephyr_command = [
"Xephyr",
":2",
"-ac",
"-screen",
xephyr_resolution + "x" + xephyr_depth,
"-glamor",
"-reset",
"-terminate",
]
if system_config.get("xephyr_fullscreen"):
xephyr_command.append("-fullscreen")
xephyr_thread = MonitoredCommand(xephyr_command)
xephyr_thread.start()
time.sleep(3)
env["DISPLAY"] = ":2"
if system_config.get("use_us_layout"):
setxkbmap_command = [
"setxkbmap", "-model", "pc101", "us", "-print"
]
xkbcomp_command = ["xkbcomp", "-", os.environ.get("DISPLAY", ":0")]
xkbcomp = subprocess.Popen(xkbcomp_command, stdin=subprocess.PIPE)
subprocess.Popen(setxkbmap_command,
env=os.environ,
stdout=xkbcomp.stdin).communicate()
xkbcomp.communicate()
if system_config.get("aco"):
env["RADV_PERFTEST"] = "aco"
pulse_latency = system_config.get("pulse_latency")
if pulse_latency:
env["PULSE_LATENCY_MSEC"] = "60"
vk_icd = system_config.get("vk_icd")
if vk_icd and vk_icd != "off" and system.path_exists(vk_icd):
env["VK_ICD_FILENAMES"] = vk_icd
fps_limit = system_config.get("fps_limit") or ""
if fps_limit:
strangle_cmd = system.find_executable("strangle")
if strangle_cmd:
launch_arguments = [strangle_cmd, fps_limit] + launch_arguments
else:
logger.warning(
"libstrangle is not available on this system, FPS limiter disabled"
)
prefix_command = system_config.get("prefix_command") or ""
if prefix_command:
launch_arguments = (
shlex.split(os.path.expandvars(prefix_command)) +
launch_arguments)
single_cpu = system_config.get("single_cpu") or False
if single_cpu:
logger.info("The game will run on a single CPU core")
launch_arguments.insert(0, "0")
launch_arguments.insert(0, "-c")
launch_arguments.insert(0, "taskset")
terminal = system_config.get("terminal")
if terminal:
terminal = system_config.get("terminal_app",
system.get_default_terminal())
if terminal and not system.find_executable(terminal):
dialogs.ErrorDialog("The selected terminal application "
"could not be launched:\n"
"%s" % terminal)
self.state = self.STATE_STOPPED
self.emit("game-stop")
return
# Env vars
game_env = gameplay_info.get("env") or self.runner.get_env()
env.update(game_env)
env["game_name"] = self.name
# Prime vars
prime = system_config.get("prime")
if prime:
env["__NV_PRIME_RENDER_OFFLOAD"] = "1"
env["__GLX_VENDOR_LIBRARY_NAME"] = "nvidia"
env["__VK_LAYER_NV_optimus"] = "NVIDIA_only"
# LD_PRELOAD
ld_preload = gameplay_info.get("ld_preload")
if ld_preload:
env["LD_PRELOAD"] = ld_preload
# Feral gamemode
gamemode = system_config.get("gamemode")
if gamemode:
env["LD_PRELOAD"] = ":".join([
path for path in [
env.get("LD_PRELOAD"),
"libgamemodeauto.so",
] if path
])
# LD_LIBRARY_PATH
game_ld_libary_path = gameplay_info.get("ld_library_path")
if game_ld_libary_path:
ld_library_path = env.get("LD_LIBRARY_PATH")
if not ld_library_path:
ld_library_path = "$LD_LIBRARY_PATH"
env["LD_LIBRARY_PATH"] = ":".join(
[game_ld_libary_path, ld_library_path])
include_processes = shlex.split(
system_config.get("include_processes", ""))
exclude_processes = shlex.split(
system_config.get("exclude_processes", ""))
self.game_runtime_config = {
"args": launch_arguments,
"env": env,
"terminal": terminal,
"include_processes": include_processes,
"exclude_processes": exclude_processes,
}
if system_config.get("disable_compositor"):
self.set_desktop_compositing(False)
prelaunch_command = system_config.get("prelaunch_command")
if system.path_exists(prelaunch_command):
self.prelaunch_executor = MonitoredCommand(
[prelaunch_command],
include_processes=[os.path.basename(prelaunch_command)],
env=self.game_runtime_config["env"],
cwd=self.directory,
)
self.prelaunch_executor.start()
logger.info("Running %s in the background", prelaunch_command)
if system_config.get("prelaunch_wait"):
self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY,
self.prelaunch_beat)
else:
self.start_game()
def configure_game(self, prelaunched, error=None): # noqa: C901
"""Get the game ready to start, applying all the options
This methods sets the game_runtime_config attribute.
"""
if error:
logger.error(error)
dialogs.ErrorDialog(str(error))
if not prelaunched:
logger.error("Game prelaunch unsuccessful")
dialogs.ErrorDialog(_("An error prevented the game from running"))
self.state = self.STATE_STOPPED
self.emit("game-stop")
return
gameplay_info = self.get_gameplay_info()
if not gameplay_info:
return
command, env = get_launch_parameters(self.runner, gameplay_info)
env["game_name"] = self.name # What is this used for??
self.game_runtime_config = {
"args": command,
"env": env,
"terminal": self.get_terminal(),
"include_processes": shlex.split(self.runner.system_config.get("include_processes", "")),
"exclude_processes": shlex.split(self.runner.system_config.get("exclude_processes", "")),
}
# Audio control
if self.runner.system_config.get("reset_pulse"):
audio.reset_pulse()
# Input control
if self.runner.system_config.get("use_us_layout"):
self.set_keyboard_layout("us")
# Display control
self.original_outputs = DISPLAY_MANAGER.get_config()
if self.runner.system_config.get("disable_compositor"):
self.set_desktop_compositing(False)
if self.runner.system_config.get("disable_screen_saver"):
self.screen_saver_inhibitor_cookie = SCREEN_SAVER_INHIBITOR.inhibit(self.name)
if self.runner.system_config.get("display") != "off":
self.resolution_changed = self.restrict_to_display(self.runner.system_config.get("display"))
resolution = self.runner.system_config.get("resolution")
if resolution != "off":
DISPLAY_MANAGER.set_resolution(resolution)
time.sleep(3)
self.resolution_changed = True
xephyr = self.runner.system_config.get("xephyr") or "off"
if xephyr != "off":
env["DISPLAY"] = self.start_xephyr()
# Execution control
self.killswitch = self.get_killswitch()
if self.runner.system_config.get("prelaunch_command"):
self.start_prelaunch_command()
if self.runner.system_config.get("prelaunch_wait"):
# Monitor the prelaunch command and wait until it has finished
self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.prelaunch_beat)
else:
self.start_game()
