def execute(self, data): """Run an executable file.""" args = [] if isinstance(data, dict): self._check_required_params("file", data, "execute") file_ref = data["file"] args_string = data.get("args", "") for arg in shlex.split(args_string): args.append(self._substitute(arg)) else: file_ref = data # Determine whether 'file' value is a file id or a path exec_path = self._get_file(file_ref) or self._substitute(file_ref) if not exec_path: raise ScriptingError("Unable to find file %s" % file_ref, file_ref) if not os.path.exists(exec_path): raise ScriptingError("Unable to find required executable", exec_path) self.chmodx(exec_path) terminal = data.get("terminal") if terminal: terminal = system.get_default_terminal() command = [exec_path] + args logger.debug("Executing %s" % command) thread = LutrisThread(command, env=runtime.get_env(), term=terminal, cwd=self.target_path) self.abort_current_task = thread.killall thread.run() self.abort_current_task = None
def xboxdrv(self, config): command = ("pkexec xboxdrv --daemon --detach-kernel-driver " "--dbus session --silent %s" % config) logger.debug("xboxdrv command: %s", command) thread = LutrisThread(command) thread.start()
def execute(self, data): """Run an executable file""" args = [] if isinstance(data, dict): self._check_required_params('file', data, 'execute') file_ref = data['file'] args_string = data.get('args', '') for arg in shlex.split(args_string): args.append(self._substitute(arg)) else: file_ref = data # Determine whether 'file' value is a file id or a path exec_path = self._get_file(file_ref) or self._substitute(file_ref) if not exec_path: raise ScriptingError("Unable to find file %s" % file_ref, file_ref) if not os.path.exists(exec_path): raise ScriptingError("Unable to find required executable", exec_path) self.chmodx(exec_path) terminal = data.get('terminal') if terminal: terminal = system.get_default_terminal() command = [exec_path] + args logger.debug("Executing %s" % command) thread = LutrisThread(command, env=get_runtime_env(), term=terminal) thread.run()
def xboxdrv_start(self, config): command = ("pkexec xboxdrv --daemon --detach-kernel-driver " "--dbus session --silent %s" % config) logger.debug("xboxdrv command: %s", command) self.xboxdrv_thread = LutrisThread(command) self.xboxdrv_thread.set_stop_command(self.xboxdrv_stop) self.xboxdrv_thread.start()
def play(self): """Launch the game.""" if not self.runner: dialogs.ErrorDialog("Invalid game configuration: Missing runner") return False if not self.prelaunch(): return False system_config = self.runner.system_config self.original_outputs = display.get_outputs() gameplay_info = self.runner.play() logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: show_error_message(gameplay_info) return False launch_arguments = gameplay_info['command'] restrict_to_display = system_config.get('display') if restrict_to_display: display.turn_off_except(restrict_to_display) self.resolution_changed = True resolution = system_config.get('resolution') if resolution: display.change_resolution(resolution) self.resolution_changed = True if system_config.get('reset_pulse'): audio.reset_pulse() oss_wrapper = system_config.get("oss_wrapper") if audio.get_oss_wrapper(oss_wrapper): launch_arguments.insert(0, audio.get_oss_wrapper(oss_wrapper)) ld_preload = gameplay_info.get('ld_preload') if ld_preload: launch_arguments.insert(0, 'LD_PRELOAD="{}"'.format(ld_preload)) ld_library_path = gameplay_info.get('ld_library_path') if ld_library_path: launch_arguments.insert( 0, 'LD_LIBRARY_PATH="{}"'.format(ld_library_path)) killswitch = system_config.get('killswitch') self.game_thread = LutrisThread(" ".join(launch_arguments), path=self.runner.working_dir, killswitch=killswitch) if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() if 'joy2key' in gameplay_info: self.joy2key(gameplay_info['joy2key']) xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv(xboxdrv_config) if self.runner.is_watchable: # Create heartbeat every self.heartbeat = GLib.timeout_add(5000, self.poke_process)
def xboxdrv_start(self, config): command = [ "pkexec", "xboxdrv", "--daemon", "--detach-kernel-driver", "--dbus", "session", "--silent" ] + config.split() logger.debug("[xboxdrv] %s", ' '.join(command)) self.xboxdrv_thread = LutrisThread(command) self.xboxdrv_thread.set_stop_command(self.xboxdrv_stop) self.xboxdrv_thread.start()
def remove_game_data(self, **kwargs): if not self.is_installed(): installed = self.install_dialog() if not installed: return False appid = self.game_config.get('appid') logger.debug("Launching Wine Steam uninstall of game %s" % appid) command = '"%s" steam://uninstall/%s' % (self.steam_exe, appid) thread = LutrisThread(command, path=self.working_dir) thread.start()
def remove_game_data(self, **kwargs): if not self.is_installed(): installed = self.install_dialog() if not installed: return False appid = self.game_config.get("appid") logger.debug("Launching Wine Steam uninstall of game %s" % appid) command = [self.steam_exe, "steam://uninstall/%s" % appid] thread = LutrisThread(command, runner=self) thread.start()
def remove_game_data(self, appid=None, **kwargs): if not self.is_installed(): installed = self.install_dialog() if not installed: return False appid = appid if appid else self.appid env = self.get_env(full=False) command = self.launch_args + ['steam://uninstall/%s' % appid] self.prelaunch() thread = LutrisThread(command, runner=self, env=env, watch=False) thread.start()
def wineexec(executable, args="", wine_path=None, prefix=None, arch=None, working_dir=None, winetricks_wine='', blocking=False, config=None): """Execute a Wine command.""" detected_arch = detect_prefix_arch(prefix) executable = str(executable) if executable else '' if arch not in ('win32', 'win64'): arch = detected_arch or 'win32' if not wine_path: wine_path = wine().get_executable() if not working_dir: if os.path.isfile(executable): working_dir = os.path.dirname(executable) if executable.endswith(".msi"): executable = 'msiexec /i "%s"' % executable elif executable: executable = '%s' % executable # Create prefix if necessary if not detected_arch: wine_bin = winetricks_wine if winetricks_wine else wine_path create_prefix(prefix, wine_path=wine_bin, arch=arch) env = {'WINEARCH': arch} if winetricks_wine: env['WINE'] = winetricks_wine else: env['WINE'] = wine_path if prefix: env['WINEPREFIX'] = prefix wine_config = config or LutrisConfig(runner_slug='wine') if not wine_config.system_config[ 'disable_runtime'] and not runtime.is_disabled(): env['LD_LIBRARY_PATH'] = ':'.join(runtime.get_paths()) command = [wine_path] if executable: command.append(executable) command += shlex.split(args) if blocking: return system.execute(command, env=env, cwd=working_dir) else: thread = LutrisThread(command, runner=wine(), env=env, cwd=working_dir) thread.start() return thread
def remove_game_data(self, appid=None, **kwargs): if not self.is_installed(): installed = self.install_dialog() if not installed: return False appid = appid if appid else self.appid env = self.get_env(os_env=False) command = self.launch_args + ['steam://uninstall/%s' % appid] self.prelaunch() thread = LutrisThread(command, runner=self, env=env, watch=False) thread.start()
def remove_game_data(self, **kwargs): if not self.is_installed(): installed = self.install_dialog() if not installed: return False appid = self.game_config.get('appid') env = self.get_env() command = self.launch_args + ['steam://uninstall/%s' % appid] self.prepare_launch() thread = LutrisThread(' '.join(command), runner=self, env=env) thread.start()
def remove_game_data(self, appid=None, **kwargs): if not self.is_installed(): installed = self.install_dialog() if not installed: return False appid = appid if appid else self.game_config.get('appid') if appid is None: raise RuntimeError('No appid given for uninstallation ' '(game config=%s)' % self.game_config) logger.debug("Launching Steam uninstall of game %s" % appid) command = [self.get_executable(), 'steam://uninstall/%s' % appid] thread = LutrisThread(command, runner=self) thread.start()
def remove_game_data(self, appid=None, **kwargs): if not self.is_installed(): installed = self.install_dialog() if not installed: return False appid = appid if appid else self.appid if appid is None: raise RuntimeError('No appid given for uninstallation ' '(game config=%s)' % self.game_config) logger.debug("Launching Steam uninstall of game %s" % appid) command = [self.get_executable(), 'steam://uninstall/%s' % appid] thread = LutrisThread(command, runner=self, env=self.get_env(), watch=False) thread.start()
def on_game_quit(self): """Restore some settings and cleanup after game quit.""" self.timer.end_t() self.playtime = self.timer.increment(self.playtime) if self.prelaunch_thread: logger.info("Stopping prelaunch script") self.prelaunch_thread.stop() self.heartbeat = None if self.state != self.STATE_STOPPED: logger.debug("Game thread still running, stopping it (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 = LutrisThread( [postexit_command], include_processes=[os.path.basename(postexit_command)], 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(metadata_only=True) os.chdir(os.path.expanduser('~')) if self.resolution_changed\ or self.runner.system_config.get('reset_desktop'): display.change_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'): display.restore_gamma() self.process_return_codes() if self.exit_main_loop: exit()
def run(self, *args): """Run the runner alone.""" if not self.runnable_alone: return if not self.is_installed(): installed = self.install_dialog() if not installed: return command_data = self.get_run_data() command = command_data.get('command') env = (command_data.get('env') or {}).copy() thread = LutrisThread(command, runner=self, env=env, watch=False) thread.start()
def joy2key(self, config): """ Run a joy2key thread. """ win = "grep %s" % config['window'] if 'notwindow' in config: win = win + ' | grep -v %s' % config['notwindow'] wid = "xwininfo -root -tree | %s | awk '{print $1}'" % win buttons = config['buttons'] axis = "Left Right Up Down" rcfile = "~/.joy2keyrc" command = "sleep 5 " command += "&& joy2key $(%s) -X -rcfile %s -buttons %s -axis %s" % ( wid, rcfile, buttons, axis ) joy2key_thread = LutrisThread(command) self.game_thread.attach_thread(joy2key_thread) joy2key_thread.start()
def wineexec(executable, args="", wine_path=None, prefix=None, arch=None, working_dir=None, winetricks_wine='', blocking=False): """Execute a Wine command.""" detected_arch = detect_prefix_arch(prefix) executable = str(executable) if executable else '' if arch not in ('win32', 'win64'): arch = detected_arch or 'win32' if not wine_path: wine_path = wine().get_executable() if not working_dir: if os.path.isfile(executable): working_dir = os.path.dirname(executable) if executable.endswith(".msi"): executable = 'msiexec /i "%s"' % executable elif executable: executable = '%s' % executable # Create prefix if necessary if not detected_arch: wine_bin = winetricks_wine if winetricks_wine else wine_path create_prefix(prefix, wine_path=wine_bin, arch=arch) env = { 'WINEARCH': arch } if winetricks_wine: env['WINE'] = winetricks_wine else: env['WINE'] = wine_path if prefix: env['WINEPREFIX'] = prefix wine_config = LutrisConfig(runner_slug='wine') if not wine_config.system_config['disable_runtime'] and not runtime.is_disabled(): env['LD_LIBRARY_PATH'] = ':'.join(runtime.get_paths()) command = [wine_path] if executable: command.append(executable) command += shlex.split(args) if blocking: return system.execute(command, env=env, cwd=working_dir) else: thread = LutrisThread(command, runner=wine(), env=env, cwd=working_dir) thread.start() return thread
def play(self): """Launch the game.""" if not self.runner: dialogs.ErrorDialog("Invalid game configuration: Missing runner") return False if not self.prelaunch(): return False system_config = self.runner.system_config self.original_outputs = display.get_outputs() gameplay_info = self.runner.play() logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: show_error_message(gameplay_info) return False launch_arguments = gameplay_info['command'] restrict_to_display = system_config.get('display') if restrict_to_display: display.turn_off_except(restrict_to_display) self.resolution_changed = True resolution = system_config.get('resolution') if resolution: display.change_resolution(resolution) self.resolution_changed = True if system_config.get('reset_pulse'): audio.reset_pulse() oss_wrapper = system_config.get("oss_wrapper") if audio.get_oss_wrapper(oss_wrapper): launch_arguments.insert(0, audio.get_oss_wrapper(oss_wrapper)) ld_preload = gameplay_info.get('ld_preload') if ld_preload: launch_arguments.insert(0, 'LD_PRELOAD="{}"'.format(ld_preload)) ld_library_path = gameplay_info.get('ld_library_path') if ld_library_path: launch_arguments.insert( 0, 'LD_LIBRARY_PATH="{}"'.format(ld_library_path) ) killswitch = system_config.get('killswitch') self.game_thread = LutrisThread(" ".join(launch_arguments), path=self.runner.working_dir, killswitch=killswitch) if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() if 'joy2key' in gameplay_info: self.joy2key(gameplay_info['joy2key']) xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv(xboxdrv_config) if self.runner.is_watchable: # Create heartbeat every self.heartbeat = GLib.timeout_add(5000, self.poke_process)
def remove_game_data(self, **kwargs): if not self.is_installed(): installed = self.install_dialog() if not installed: return False appid = self.game_config.get('appid') prefix = self.game_config.get('prefix') command = [] command.append('WINEARCH=%s ' % self.wine_arch) command.append('WINEPREFIX="%s" ' % self.prefix_path) command += self.launch_args command += ['steam://uninstall/%s' % appid] self.prepare_launch() thread = LutrisThread(' '.join(command), path=self.working_dir) thread.start()
def play(self): """ Launch the game. """ if not self.prelaunch(): return False gameplay_info = self.runner.play() logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if isinstance(gameplay_info, dict): if 'error' in gameplay_info: show_error_message(gameplay_info) return False launch_arguments = gameplay_info['command'] else: logger.error("Old method used for returning gameplay infos") launch_arguments = gameplay_info restrict_to_display = self.game_config.get_system('display') if restrict_to_display: display.turn_off_except(restrict_to_display) self.resolution_changed = True resolution = self.game_config.get_system('resolution') if resolution: display.change_resolution(resolution) self.resolution_changed = True if self.game_config.get_system('reset_pulse'): audio.reset_pulse() if self.game_config.get_system('hide_panels'): self.desktop.hide_panels() oss_wrapper = self.game_config.get_system("oss_wrapper") if oss_wrapper: launch_arguments.insert(0, audio.get_oss_wrapper(oss_wrapper)) ld_preload = gameplay_info.get('ld_preload') if ld_preload: launch_arguments.insert(0, 'LD_PRELOAD="{}"'.format(ld_preload)) ld_library_path = gameplay_info.get('ld_library_path') if ld_library_path: launch_arguments.insert( 0, 'LD_LIBRARY_PATH="{}"'.format(ld_library_path) ) killswitch = self.game_config.get_system('killswitch') self.heartbeat = GLib.timeout_add(5000, self.poke_process) self.game_thread = LutrisThread(" ".join(launch_arguments), path=self.runner.get_game_path(), killswitch=killswitch) if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() if 'joy2key' in gameplay_info: self.joy2key(gameplay_info['joy2key']) xboxdrv_config = self.game_config.get_system('xboxdrv') if xboxdrv_config: self.xboxdrv(xboxdrv_config)
def xboxdrv_start(self, config): command = [ "pkexec", "xboxdrv", "--daemon", "--detach-kernel-driver", "--dbus", "session", "--silent" ] + config.split() logger.debug("xboxdrv command: %s", command) self.xboxdrv_thread = LutrisThread(command) self.xboxdrv_thread.set_stop_command(self.xboxdrv_stop) self.xboxdrv_thread.start()
def xboxdrv_start(self, config): command = [ "pkexec", "xboxdrv", "--daemon", "--detach-kernel-driver", "--dbus", "session", "--silent" ] + config.split() logger.debug("[xboxdrv] %s", ' '.join(command)) self.xboxdrv_thread = LutrisThread(command, include_processes=['xboxdrv']) self.xboxdrv_thread.set_stop_command(self.xboxdrv_stop) self.xboxdrv_thread.start()
def joy2key(self, config): """Run a joy2key thread.""" if not system.find_executable('joy2key'): logger.error("joy2key is not installed") return win = "grep %s" % config['window'] if 'notwindow' in config: win += ' | grep -v %s' % config['notwindow'] wid = "xwininfo -root -tree | %s | awk '{print $1}'" % win buttons = config['buttons'] axis = "Left Right Up Down" rcfile = os.path.expanduser("~/.joy2keyrc") rc_option = '-rcfile %s' % rcfile if os.path.exists(rcfile) else '' command = "sleep 5 " command += "&& joy2key $(%s) -X %s -buttons %s -axis %s" % ( wid, rc_option, buttons, axis) joy2key_thread = LutrisThread(command) self.game_thread.attach_thread(joy2key_thread) joy2key_thread.start()
def on_execute_script_clicked(self, _widget): """Execute the game's associated script""" game = Game(self.view.selected_game) ondemand_command = game.runner.system_config.get("ondemand_command") if path_exists(ondemand_command): LutrisThread( [ondemand_command], include_processes=[os.path.basename(ondemand_command)], cwd=game.directory).start() logger.info("Running %s in the background", ondemand_command)
def execute(self, data): """Run an executable file.""" args = [] terminal = None working_dir = None if isinstance(data, dict): self._check_required_params('file', data, 'execute') file_ref = data['file'] args_string = data.get('args', '') for arg in shlex.split(args_string): args.append(self._substitute(arg)) terminal = data.get('terminal') working_dir = data.get('working_dir') else: file_ref = data # Determine whether 'file' value is a file id or a path exec_path = self._get_file(file_ref) or self._substitute(file_ref) if not exec_path: raise ScriptingError("Unable to find file %s" % file_ref, file_ref) if not os.path.exists(exec_path): raise ScriptingError("Unable to find required executable", exec_path) if not os.access(exec_path, os.X_OK): self.chmodx(exec_path) if terminal: terminal = system.get_default_terminal() if not working_dir or not os.path.exists(working_dir): working_dir = self.target_path command = [exec_path] + args logger.debug("Executing %s" % command) thread = LutrisThread(command, env=runtime.get_env(), term=terminal, cwd=self.target_path, watch=False) self.abort_current_task = thread.killall thread.run() self.abort_current_task = None
def joy2key(self, config): """Run a joy2key thread.""" if not system.find_executable('joy2key'): logger.error("joy2key is not installed") return win = "grep %s" % config['window'] if 'notwindow' in config: win += ' | grep -v %s' % config['notwindow'] wid = "xwininfo -root -tree | %s | awk '{print $1}'" % win buttons = config['buttons'] axis = "Left Right Up Down" rcfile = os.path.expanduser("~/.joy2keyrc") rc_option = '-rcfile %s' % rcfile if os.path.exists(rcfile) else '' command = "sleep 5 " command += "&& joy2key $(%s) -X %s -buttons %s -axis %s" % ( wid, rc_option, buttons, axis ) joy2key_thread = LutrisThread(command) self.game_thread.attach_thread(joy2key_thread) joy2key_thread.start()
def run(self, *args): """Run the runner alone.""" if not self.runnable_alone: return if not self.is_installed(): installed = self.install_dialog() if not installed: return if self.use_runtime(): if runtime.is_outdated() or runtime.is_updating(): result = dialogs.RuntimeUpdateDialog().run() if not result == Gtk.ResponseType.OK: return command_data = self.get_run_data() command = command_data.get('command') env = (command_data.get('env') or {}).copy() if self.use_runtime(): env.update(runtime.get_env()) thread = LutrisThread(command, runner=self, env=env, watch=False) thread.start()
def do_play(self, prelaunched, _error=None): if not prelaunched: self.state = self.STATE_STOPPED return system_config = self.runner.system_config self.original_outputs = display.get_outputs() gameplay_info = self.runner.play() env = {} logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: show_error_message(gameplay_info) self.state = self.STATE_STOPPED return restrict_to_display = system_config.get('display') if restrict_to_display != 'off': display.turn_off_except(restrict_to_display) time.sleep(3) self.resolution_changed = True resolution = system_config.get('resolution') if resolution != 'off': display.change_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 os.path.exists(self.killswitch): # Prevent setting a killswitch to a file that doesn't exists self.killswitch = None # Command launch_arguments = gameplay_info['command'] primusrun = system_config.get('primusrun') if primusrun and system.find_executable('primusrun'): launch_arguments.insert(0, 'primusrun') xephyr = system_config.get('xephyr') or 'off' if xephyr != 'off': if xephyr == '8bpp': xephyr_depth = '8' else: xephyr_depth = '16' xephyr_resolution = system_config.get('xephyr_resolution') or '640x480' xephyr_command = ['Xephyr', ':2', '-ac', '-screen', xephyr_resolution + 'x' + xephyr_depth, '-glamor', '-reset', '-terminate', '-fullscreen'] xephyr_thread = LutrisThread(xephyr_command) xephyr_thread.start() time.sleep(3) env['DISPLAY'] = ':2' pulse_latency = system_config.get('pulse_latency') if pulse_latency: env['PULSE_LATENCY_MSEC'] = '60' prefix_command = system_config.get("prefix_command") or '' if prefix_command.strip(): launch_arguments.insert(0, prefix_command) 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 return # Env vars game_env = gameplay_info.get('env') or {} env.update(game_env) system_env = system_config.get('env') or {} env.update(system_env) ld_preload = gameplay_info.get('ld_preload') if ld_preload: env["LD_PRELOAD"] = ld_preload ld_library_path = [] if self.runner.use_runtime(): env['STEAM_RUNTIME'] = os.path.join(settings.RUNTIME_DIR, 'steam') ld_library_path += runtime.get_paths() game_ld_libary_path = gameplay_info.get('ld_library_path') if game_ld_libary_path: ld_library_path.append(game_ld_libary_path) if ld_library_path: ld_full = ':'.join(ld_library_path) env["LD_LIBRARY_PATH"] = "{}:$LD_LIBRARY_PATH".format(ld_full) # /Env vars self.game_thread = LutrisThread(launch_arguments, runner=self.runner, env=env, rootpid=gameplay_info.get('rootpid'), term=terminal) if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() self.state = self.STATE_RUNNING if 'joy2key' in gameplay_info: self.joy2key(gameplay_info['joy2key']) xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv_start(xboxdrv_config) self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat)
def wineexec(executable, args="", wine_path=None, prefix=None, arch=None, working_dir=None, winetricks_wine='', blocking=False, config=None, include_processes=[], exclude_processes=[], disable_runtime=False, env={}, overrides=None): """ Execute a Wine command. Args: executable (str): wine program to run, pass None to run wine itself args (str): program arguments wine_path (str): path to the wine version to use prefix (str): path to the wine prefix to use arch (str): wine architecture of the prefix working_dir (str): path to the working dir for the process winetricks_wine (str): path to the wine version used by winetricks blocking (bool): if true, do not run the process in a thread config (LutrisConfig): LutrisConfig object for the process context watch (list): list of process names to monitor (even when in a ignore list) Returns: Process results if the process is running in blocking mode or LutrisThread instance otherwise. """ executable = str(executable) if executable else '' if not wine_path: wine_path = wine().get_executable() if not working_dir: if os.path.isfile(executable): working_dir = os.path.dirname(executable) executable, _args, working_dir = get_real_executable(executable, working_dir) if _args: args = '{} "{}"'.format(_args[0], _args[1]) # Create prefix if necessary detected_arch = detect_prefix_arch(prefix) if arch not in ('win32', 'win64'): arch = detected_arch or 'win32' if not detected_arch: wine_bin = winetricks_wine if winetricks_wine else wine_path create_prefix(prefix, wine_path=wine_bin, arch=arch) wineenv = { 'WINEARCH': arch } if winetricks_wine: wineenv['WINE'] = winetricks_wine else: wineenv['WINE'] = wine_path if prefix: wineenv['WINEPREFIX'] = prefix wine_config = config or LutrisConfig(runner_slug='wine') if ( not runtime.RUNTIME_DISABLED and not disable_runtime and not wine_config.system_config['disable_runtime'] ): wineenv['LD_LIBRARY_PATH'] = ':'.join(runtime.get_paths()) if overrides: wineenv['WINEDLLOVERRIDES'] = get_overrides_env(overrides) wineenv.update(env) command = [wine_path] if executable: command.append(executable) command += shlex.split(args) if blocking: return system.execute(command, env=wineenv, cwd=working_dir) else: thread = LutrisThread(command, runner=wine(), env=wineenv, cwd=working_dir, include_processes=include_processes, exclude_processes=exclude_processes) thread.start() return thread
class Game(object): """" This class takes cares about loading the configuration for a game and running it. """ def __init__(self, slug): self.slug = slug self.game_thread = None self.heartbeat = None self.game_config = None game_data = pga.get_game_by_slug(slug) self.runner_name = game_data['runner'] self.directory = game_data['directory'] self.name = game_data['name'] self.is_installed = bool(game_data['installed']) self.load_config() def get_runner(self): """ Return the runner's name """ return self.game_config['runner'] def load_config(self): """ Load the game's configuration. """ self.game_config = LutrisConfig(game=self.slug) if self.is_installed: if not self.game_config.is_valid(): logger.error("Invalid game config for %s" % self.slug) else: runner_class = import_runner(self.runner_name) self.runner = runner_class(self.game_config) def remove(self, from_library=False, from_disk=False): if from_disk: if os.path.exists(self.directory): shutil.rmtree(self.directory) if from_library: pga.delete_game(self.slug) else: pga.set_uninstalled(self.slug) self.game_config.remove() def prelaunch(self): """ Verify that the current game can be launched. """ if not self.runner.is_installed(): question = ("The required runner is not installed.\n" "Do you wish to install it now ?") install_runner_dialog = dialogs.QuestionDialog( {'question': question, 'title': "Required runner unavailable"}) if Gtk.ResponseType.YES == install_runner_dialog.result: self.runner.install() return False if hasattr(self.runner, 'prelaunch'): success = self.runner.prelaunch() return success return True def play(self): """ Launch the game. """ if not self.prelaunch(): return False gameplay_info = self.runner.play() logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if isinstance(gameplay_info, dict): if 'error' in gameplay_info: show_error_message(gameplay_info) return False launch_arguments = gameplay_info['command'] else: logger.error("Old method used for returning gameplay infos") launch_arguments = gameplay_info resolution = self.game_config.get_system('resolution') if resolution: desktop_control.change_resolution(resolution) if self.game_config.get_system('reset_pulse'): desktop_control.reset_pulse() if self.game_config.get_system('hide_panels'): self.desktop.hide_panels() oss_wrapper = self.game_config.get_system("oss_wrapper") if oss_wrapper: launch_arguments.insert(0, audio.get_oss_wrapper(oss_wrapper)) ld_preload = gameplay_info.get('ld_preload') if ld_preload: launch_arguments.insert(0, 'LD_PRELOAD="{}"'.format(ld_preload)) ld_library_path = gameplay_info.get('ld_library_path') if ld_library_path: launch_arguments.insert( 0, 'LD_LIBRARY_PATH="{}"'.format(ld_library_path) ) killswitch = self.game_config.get_system('killswitch') self.heartbeat = GLib.timeout_add(5000, self.poke_process) self.game_thread = LutrisThread(" ".join(launch_arguments), path=self.runner.get_game_path(), killswitch=killswitch) if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() if 'joy2key' in gameplay_info: self.joy2key(gameplay_info['joy2key']) xboxdrv_config = self.game_config.get_system('xboxdrv') if xboxdrv_config: self.xboxdrv(xboxdrv_config) def joy2key(self, config): """ Run a joy2key thread. """ win = "grep %s" % config['window'] if 'notwindow' in config: win = win + ' | grep -v %s' % config['notwindow'] wid = "xwininfo -root -tree | %s | awk '{print $1}'" % win buttons = config['buttons'] axis = "Left Right Up Down" rcfile = "~/.joy2keyrc" command = "sleep 5 " command += "&& joy2key $(%s) -X -rcfile %s -buttons %s -axis %s" % ( wid, rcfile, buttons, axis ) joy2key_thread = LutrisThread(command) self.game_thread.attach_thread(joy2key_thread) joy2key_thread.start() def xboxdrv(self, config): command = ("pkexec xboxdrv --daemon --detach-kernel-driver " "--dbus session --silent %s" % config) logger.debug("xboxdrv command: %s", command) thread = LutrisThread(command) thread.start() def poke_process(self): """ Watch game's process. """ if not self.game_thread.pid: self.quit_game() return False return True def quit_game(self): """ Quit the game and cleanup. """ self.heartbeat = None quit_time = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime()) logger.debug("game has quit at %s" % quit_time) if self.game_config.get_system('resolution'): desktop_control.reset_desktop() if self.game_config.get_system('xboxdrv'): logger.debug("Shutting down xboxdrv") os.system("pkexec xboxdrvctl --shutdown") if self.game_thread: self.game_thread.stop()
def wineexec(executable, args="", wine_path=None, prefix=None, arch=None, working_dir=None, winetricks_wine='', blocking=False, config=None, include_processes=[]): """ Execute a Wine command. Args: executable (str): wine program to run, pass None to run wine itself args (str): program arguments wine_path (str): path to the wine version to use prefix (str): path to the wine prefix to use arch (str): wine architecture of the prefix working_dir (str): path to the working dir for the process winetricks_wine (str): path to the wine version used by winetricks blocking (bool): if true, do not run the process in a thread config (LutrisConfig): LutrisConfig object for the process context watch (list): list of process names to monitor (even when in a ignore list) Returns: Process results if the process is running in blocking mode or LutrisThread instance otherwise. """ detected_arch = detect_prefix_arch(prefix) executable = str(executable) if executable else '' if arch not in ('win32', 'win64'): arch = detected_arch or 'win32' if not wine_path: wine_path = wine().get_executable() if not working_dir: if os.path.isfile(executable): working_dir = os.path.dirname(executable) executable, _args = get_real_executable(executable) if _args: args = '{} "{}"'.format(_args[0], _args[1]) # Create prefix if necessary if not detected_arch: wine_bin = winetricks_wine if winetricks_wine else wine_path create_prefix(prefix, wine_path=wine_bin, arch=arch) env = { 'WINEARCH': arch } if winetricks_wine: env['WINE'] = winetricks_wine else: env['WINE'] = wine_path if prefix: env['WINEPREFIX'] = prefix wine_config = config or LutrisConfig(runner_slug='wine') if not wine_config.system_config['disable_runtime'] and not runtime.is_disabled(): env['LD_LIBRARY_PATH'] = ':'.join(runtime.get_paths()) command = [wine_path] if executable: command.append(executable) command += shlex.split(args) if blocking: return system.execute(command, env=env, cwd=working_dir) else: thread = LutrisThread(command, runner=wine(), env=env, cwd=working_dir, include_processes=include_processes) thread.start() return thread
def play(self): """Launch the game.""" if not self.runner: dialogs.ErrorDialog("Invalid game configuration: Missing runner") return False if not self.prelaunch(): return False system_config = self.runner.system_config self.original_outputs = display.get_outputs() gameplay_info = self.runner.play() logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: show_error_message(gameplay_info) return False launch_arguments = gameplay_info['command'] restrict_to_display = system_config.get('display') if restrict_to_display: display.turn_off_except(restrict_to_display) time.sleep(3) self.resolution_changed = True resolution = system_config.get('resolution') if resolution: display.change_resolution(resolution) time.sleep(3) self.resolution_changed = True if system_config.get('reset_pulse'): audio.reset_pulse() primusrun = system_config.get('primusrun') if primusrun and system.find_executable('primusrun'): launch_arguments.insert(0, 'primusrun') prefix_command = system_config.get("prefix_command", '').strip() if prefix_command: launch_arguments.insert(0, prefix_command) ld_preload = gameplay_info.get('ld_preload') if ld_preload: launch_arguments.insert(0, 'LD_PRELOAD="{}"'.format(ld_preload)) ld_library_path = [] if self.use_runtime(system_config): runtime64_path = os.path.join(settings.RUNTIME_DIR, "lib64") if os.path.exists(runtime64_path): ld_library_path.append(runtime64_path) runtime32_path = os.path.join(settings.RUNTIME_DIR, "lib32") if os.path.exists(runtime32_path): ld_library_path.append(runtime32_path) game_ld_libary_path = gameplay_info.get('ld_library_path') if game_ld_libary_path: ld_library_path.append(game_ld_libary_path) if ld_library_path: ld_full = ':'.join(ld_library_path) ld_arg = 'LD_LIBRARY_PATH="{}:$LD_LIBRARY_PATH"'.format(ld_full) launch_arguments.insert(0, ld_arg) env = gameplay_info.get('env') or [] for var in env: launch_arguments.insert(0, var) killswitch = system_config.get('killswitch') self.game_thread = LutrisThread(" ".join(launch_arguments), path=self.runner.working_dir, killswitch=killswitch) if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() if 'joy2key' in gameplay_info: self.joy2key(gameplay_info['joy2key']) xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv_start(xboxdrv_config) if self.runner.is_watchable: # Create heartbeat every self.heartbeat = GLib.timeout_add(5000, self.poke_process)
class Game(object): """This class takes cares of loading the configuration for a game and running it. """ STATE_IDLE = 'idle' STATE_STOPPED = 'stopped' STATE_RUNNING = 'running' def __init__(self, id=None): self.id = id self.runner = None self.game_thread = None self.heartbeat = None self.config = None self.killswitch = None self.state = self.STATE_IDLE self.exit_main_loop = False game_data = pga.get_game_by_field(id, 'id') self.slug = game_data.get('slug') or '' self.runner_name = game_data.get('runner') or '' self.directory = game_data.get('directory') or '' self.name = game_data.get('name') or '' self.is_installed = bool(game_data.get('installed')) or False self.platform = game_data.get('platform') or '' self.year = game_data.get('year') or '' self.lastplayed = game_data.get('lastplayed') or 0 self.game_config_id = game_data.get('configpath') or '' self.steamid = game_data.get('steamid') or '' self.has_custom_banner = bool(game_data.get('has_custom_banner')) or False self.has_custom_icon = bool(game_data.get('has_custom_icon')) or False self.load_config() self.resolution_changed = False self.compositor_disabled = False self.stop_compositor = self.start_compositor = "" self.original_outputs = None self.log_buffer = Gtk.TextBuffer() self.log_buffer.create_tag("warning", foreground="red") def __repr__(self): return self.__unicode__() def __unicode__(self): value = self.name if self.runner_name: value += " (%s)" % self.runner_name return value def show_error_message(self, message): """Display an error message based on the runner's output.""" if "CUSTOM" == message['error']: message_text = message['text'].replace('&', '&') dialogs.ErrorDialog(message_text) elif "RUNNER_NOT_INSTALLED" == message['error']: dialogs.ErrorDialog('Error the runner is not installed') elif "NO_BIOS" == message['error']: dialogs.ErrorDialog("A bios file is required to run this game") elif "FILE_NOT_FOUND" == message['error']: filename = message['file'] if filename: message_text = "The file {} could not be found".format( filename.replace('&', '&') ) else: message_text = "No file provided" dialogs.ErrorDialog(message_text) elif "NOT_EXECUTABLE" == message['error']: message_text = message['file'].replace('&', '&') dialogs.ErrorDialog("The file %s is not executable" % message_text) def get_browse_dir(self): """Return the path to open with the Browse Files action.""" return self.runner.browse_dir def load_config(self): """Load the game's configuration.""" self.config = LutrisConfig(runner_slug=self.runner_name, game_config_id=self.game_config_id) if not self.is_installed: return if not self.runner_name: logger.error('Incomplete data for %s', self.slug) return try: runner_class = import_runner(self.runner_name) except InvalidRunner: logger.error("Unable to import runner %s for %s", self.runner_name, self.slug) else: self.runner = runner_class(self.config) def desktop_effects(self, enable): if enable: system.execute(self.start_compositor, shell=True) else: if os.environ.get('DESKTOP_SESSION') == "plasma": self.stop_compositor = "qdbus org.kde.KWin /Compositor org.kde.kwin.Compositing.suspend" self.start_compositor = "qdbus org.kde.KWin /Compositor org.kde.kwin.Compositing.resume" elif os.environ.get('DESKTOP_SESSION') == "mate" and system.execute("gsettings get org.mate.Marco.general compositing-manager", shell=True) == 'true': self.stop_compositor = "gsettings set org.mate.Marco.general compositing-manager false" self.start_compositor = "gsettings set org.mate.Marco.general compositing-manager true" elif os.environ.get('DESKTOP_SESSION') == "xfce" and system.execute("xfconf-query --channel=xfwm4 --property=/general/use_compositing", shell=True) == 'true': self.stop_compositor = "xfconf-query --channel=xfwm4 --property=/general/use_compositing --set=false" self.start_compositor = "xfconf-query --channel=xfwm4 --property=/general/use_compositing --set=true" if not (self.compositor_disabled or self.stop_compositor == ""): system.execute(self.stop_compositor, shell=True) self.compositor_disabled = True; def remove(self, from_library=False, from_disk=False): if from_disk and self.runner: logger.debug("Removing game %s from disk" % self.id) self.runner.remove_game_data(game_path=self.directory) # Do not keep multiple copies of the same game existing_games = pga.get_games_where(slug=self.slug) if len(existing_games) > 1: from_library = True if from_library: logger.debug("Removing game %s from library" % self.id) pga.delete_game(self.id) else: pga.set_uninstalled(self.id) self.config.remove() xdg.remove_launcher(self.slug, self.id, desktop=True, menu=True) return from_library def set_platform_from_runner(self): if not self.runner: return self.platform = self.runner.get_platform() def save(self, metadata_only=False): """ Save the game's config and metadata, if `metadata_only` is set to True, do not save the config. This is useful when exiting the game since the config might have changed and we don't want to override the changes. """ if not metadata_only: self.config.save() self.id = pga.add_or_update( name=self.name, runner=self.runner_name, slug=self.slug, platform=self.platform, year=self.year, lastplayed=self.lastplayed, directory=self.directory, installed=self.is_installed, configpath=self.config.game_config_id, steamid=self.steamid, id=self.id ) def prelaunch(self): """Verify that the current game can be launched.""" if not self.runner.is_installed(): installed = self.runner.install_dialog() if not installed: return False if self.runner.use_runtime(): runtime_updater = runtime.RuntimeUpdater() if runtime_updater.is_updating(): logger.warning("Runtime updates: {}".format( runtime_updater.current_updates) ) dialogs.ErrorDialog("Runtime currently updating", "Game might not work as expected") return True def play(self): """Launch the game.""" if not self.runner: dialogs.ErrorDialog("Invalid game configuration: Missing runner") self.state = self.STATE_STOPPED return if not self.prelaunch(): self.state = self.STATE_STOPPED return if hasattr(self.runner, 'prelaunch'): jobs.AsyncCall(self.runner.prelaunch, self.do_play) else: self.do_play(True) def do_play(self, prelaunched, _error=None): if not prelaunched: self.state = self.STATE_STOPPED return system_config = self.runner.system_config self.original_outputs = sorted( display.get_outputs(), key=lambda e: e[0] == system_config.get('display') ) gameplay_info = self.runner.play() logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: self.show_error_message(gameplay_info) self.state = self.STATE_STOPPED return env = {} sdl_gamecontrollerconfig = system_config.get('sdl_gamecontrollerconfig') if sdl_gamecontrollerconfig: path = os.path.expanduser(sdl_gamecontrollerconfig) if os.path.exists(path): with open(path, "r") as f: sdl_gamecontrollerconfig = f.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': display.turn_off_except(restrict_to_display) time.sleep(3) self.resolution_changed = True resolution = system_config.get('resolution') if resolution != 'off': display.change_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 os.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') xephyr = system_config.get('xephyr') or 'off' if xephyr != 'off': if xephyr == '8bpp': xephyr_depth = '8' else: xephyr_depth = '16' xephyr_resolution = system_config.get('xephyr_resolution') or '640x480' xephyr_command = ['Xephyr', ':2', '-ac', '-screen', xephyr_resolution + 'x' + xephyr_depth, '-glamor', '-reset', '-terminate', '-fullscreen'] xephyr_thread = LutrisThread(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() pulse_latency = system_config.get('pulse_latency') if pulse_latency: env['PULSE_LATENCY_MSEC'] = '60' 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 return # Env vars game_env = gameplay_info.get('env') or self.runner.get_env() env.update(game_env) ld_preload = gameplay_info.get('ld_preload') if ld_preload: env["LD_PRELOAD"] = ld_preload 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' ld_library_path = ":".join([game_ld_libary_path, ld_library_path]) env["LD_LIBRARY_PATH"] = ld_library_path # /Env vars include_processes = shlex.split(system_config.get('include_processes', '')) exclude_processes = shlex.split(system_config.get('exclude_processes', '')) monitoring_disabled = system_config.get('disable_monitoring') if monitoring_disabled: show_obnoxious_process_monitor_message() process_watch = not monitoring_disabled if self.runner.system_config.get('disable_compositor'): self.desktop_effects(False) self.game_thread = LutrisThread(launch_arguments, runner=self.runner, env=env, rootpid=gameplay_info.get('rootpid'), watch=process_watch, term=terminal, log_buffer=self.log_buffer, include_processes=include_processes, exclude_processes=exclude_processes) if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() self.state = self.STATE_RUNNING # xboxdrv setup xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv_start(xboxdrv_config) if monitoring_disabled: logger.info("Process monitoring disabled") else: self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat) def xboxdrv_start(self, config): command = [ "pkexec", "xboxdrv", "--daemon", "--detach-kernel-driver", "--dbus", "session", "--silent" ] + config.split() logger.debug("[xboxdrv] %s", ' '.join(command)) self.xboxdrv_thread = LutrisThread(command, include_processes=['xboxdrv']) self.xboxdrv_thread.set_stop_command(self.xboxdrv_stop) self.xboxdrv_thread.start() def xboxdrv_stop(self): os.system("pkexec xboxdrvctl --shutdown") if os.path.exists("/usr/share/lutris/bin/resetxpad"): os.system("pkexec /usr/share/lutris/bin/resetxpad") def beat(self): """Watch the game's process(es).""" if self.game_thread.error: dialogs.ErrorDialog("<b>Error lauching the game:</b>\n" + self.game_thread.error) self.on_game_quit() return False # The killswitch file should be set to a device (ie. /dev/input/js0) # When that device is unplugged, the game is forced to quit. killswitch_engage = ( self.killswitch and not os.path.exists(self.killswitch) ) if not self.game_thread.is_running or killswitch_engage: logger.debug("Game thread stopped") self.on_game_quit() return False return True def stop(self): if self.runner.system_config.get('xboxdrv'): logger.debug("Stopping xboxdrv") self.xboxdrv_thread.stop() if self.game_thread: jobs.AsyncCall(self.game_thread.stop, None, killall=self.runner.killall_on_exit()) self.state = self.STATE_STOPPED def on_game_quit(self): """Restore some settings and cleanup after game quit.""" self.heartbeat = None if self.state != self.STATE_STOPPED: logger.debug("Game thread still running, stopping it (state: %s)", self.state) self.stop() 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.change_resolution(self.original_outputs) if self.compositor_disabled: self.desktop_effects(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'): display.restore_gamma() self.process_return_codes() if self.exit_main_loop: exit() def process_return_codes(self): """Do things depending on how the game quitted.""" if self.game_thread.return_code == 127: # Error missing shared lib error = "error while loading shared lib" error_line = strings.lookup_string_in_text(error, self.game_thread.stdout) if error_line: dialogs.ErrorDialog("<b>Error: Missing shared library.</b>" "\n\n%s" % error_line) if self.game_thread.return_code == 1: # Error Wine version conflict error = "maybe the wrong wineserver" if strings.lookup_string_in_text(error, self.game_thread.stdout): dialogs.ErrorDialog("<b>Error: A different Wine version is " "already using the same Wine prefix.</b>") def notify_steam_game_changed(self, appmanifest): """Receive updates from Steam games and set the thread's ready state accordingly""" if 'Fully Installed' in appmanifest.states and not self.game_thread.ready_state: logger.info("Steam game %s is fully installed", appmanifest.steamid) self.game_thread.ready_state = True elif 'Update Required' in appmanifest.states and self.game_thread.ready_state: logger.info("Steam game %s updating, setting game thread as not ready", appmanifest.steamid) self.game_thread.ready_state = False
class Game(object): """This class takes cares of loading the configuration for a game and running it. """ STATE_IDLE = 'idle' STATE_STOPPED = 'stopped' STATE_RUNNING = 'running' def __init__(self, id=None): self.id = id self.runner = None self.game_thread = None self.heartbeat = None self.config = None self.killswitch = None self.state = self.STATE_IDLE self.game_log = '' self.exit_main_loop = False game_data = pga.get_game_by_field(id, 'id') self.slug = game_data.get('slug') or '' self.runner_name = game_data.get('runner') or '' self.directory = game_data.get('directory') or '' self.name = game_data.get('name') or '' self.is_installed = bool(game_data.get('installed')) or False self.platform = game_data.get('platform') or '' self.year = game_data.get('year') or '' self.game_config_id = game_data.get('configpath') or '' self.steamid = game_data.get('steamid') or '' self.has_custom_banner = bool(game_data.get('has_custom_banner')) or False self.has_custom_icon = bool(game_data.get('has_custom_icon')) or False self.load_config() self.resolution_changed = False self.original_outputs = None def __repr__(self): return self.__unicode__() def __unicode__(self): value = self.name if self.runner_name: value += " (%s)" % self.runner_name return value def show_error_message(self, message): """Display an error message based on the runner's output.""" if "CUSTOM" == message['error']: message_text = message['text'].replace('&', '&') dialogs.ErrorDialog(message_text) elif "RUNNER_NOT_INSTALLED" == message['error']: dialogs.ErrorDialog('Error the runner is not installed') elif "NO_BIOS" == message['error']: dialogs.ErrorDialog("A bios file is required to run this game") elif "FILE_NOT_FOUND" == message['error']: filename = message['file'] if filename: message_text = "The file {} could not be found".format( filename.replace('&', '&') ) else: message_text = "No file provided" dialogs.ErrorDialog(message_text) elif "NOT_EXECUTABLE" == message['error']: message_text = message['file'].replace('&', '&') dialogs.ErrorDialog("The file %s is not executable" % message_text) def get_browse_dir(self): """Return the path to open with the Browse Files action.""" return self.runner.browse_dir def load_config(self): """Load the game's configuration.""" self.config = LutrisConfig(runner_slug=self.runner_name, game_config_id=self.game_config_id) if not self.is_installed: return if not self.runner_name: logger.error('Incomplete data for %s', self.slug) return try: runner_class = import_runner(self.runner_name) except InvalidRunner: logger.error("Unable to import runner %s for %s", self.runner_name, self.slug) else: self.runner = runner_class(self.config) def remove(self, from_library=False, from_disk=False): if from_disk and self.runner: logger.debug("Removing game %s from disk" % self.id) self.runner.remove_game_data(game_path=self.directory) # Do not keep multiple copies of the same game existing_games = pga.get_game_by_field(self.slug, 'slug', all=True) if len(existing_games) > 1: from_library = True if from_library: logger.debug("Removing game %s from library" % self.id) pga.delete_game(self.id) else: pga.set_uninstalled(self.id) self.config.remove() shortcuts.remove_launcher(self.slug, self.id, desktop=True, menu=True) return from_library def save(self): self.config.save() self.id = pga.add_or_update( name=self.name, runner=self.runner_name, slug=self.slug, platform=self.platform, year=self.year, directory=self.directory, installed=self.is_installed, configpath=self.config.game_config_id, steamid=self.steamid, id=self.id ) def prelaunch(self): """Verify that the current game can be launched.""" if not self.runner.is_installed(): installed = self.runner.install_dialog() if not installed: return False if self.runner.use_runtime(): runtime_updater = runtime.RuntimeUpdater() if runtime_updater.is_updating(): logger.warning("Runtime updates: {}".format( runtime_updater.current_updates) ) dialogs.ErrorDialog("Runtime currently updating", "Game might not work as expected") return True def play(self): """Launch the game.""" if not self.runner: dialogs.ErrorDialog("Invalid game configuration: Missing runner") self.state = self.STATE_STOPPED return if not self.prelaunch(): self.state = self.STATE_STOPPED return if hasattr(self.runner, 'prelaunch'): jobs.AsyncCall(self.runner.prelaunch, self.do_play) else: self.do_play(True) def do_play(self, prelaunched, _error=None): if not prelaunched: self.state = self.STATE_STOPPED return system_config = self.runner.system_config self.original_outputs = display.get_outputs() gameplay_info = self.runner.play() env = {} logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: self.show_error_message(gameplay_info) self.state = self.STATE_STOPPED return 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': display.turn_off_except(restrict_to_display) time.sleep(3) self.resolution_changed = True resolution = system_config.get('resolution') if resolution != 'off': display.change_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 os.path.exists(self.killswitch): # Prevent setting a killswitch to a file that doesn't exists self.killswitch = None # Command launch_arguments = gameplay_info['command'] primusrun = system_config.get('primusrun') if primusrun and system.find_executable('primusrun'): launch_arguments.insert(0, 'primusrun') xephyr = system_config.get('xephyr') or 'off' if xephyr != 'off': if xephyr == '8bpp': xephyr_depth = '8' else: xephyr_depth = '16' xephyr_resolution = system_config.get('xephyr_resolution') or '640x480' xephyr_command = ['Xephyr', ':2', '-ac', '-screen', xephyr_resolution + 'x' + xephyr_depth, '-glamor', '-reset', '-terminate', '-fullscreen'] xephyr_thread = LutrisThread(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() pulse_latency = system_config.get('pulse_latency') if pulse_latency: env['PULSE_LATENCY_MSEC'] = '60' prefix_command = system_config.get("prefix_command") or '' if prefix_command.strip(): launch_arguments.insert(0, prefix_command) 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 return # Env vars game_env = gameplay_info.get('env') or {} env.update(game_env) system_env = system_config.get('env') or {} env.update(system_env) ld_preload = gameplay_info.get('ld_preload') or '' env["LD_PRELOAD"] = ld_preload # Runtime management ld_library_path = "" if self.runner.use_runtime(): runtime_env = runtime.get_env() if 'STEAM_RUNTIME' in runtime_env and 'STEAM_RUNTIME' not in env: env['STEAM_RUNTIME'] = runtime_env['STEAM_RUNTIME'] if 'LD_LIBRARY_PATH' in runtime_env: ld_library_path = runtime_env['LD_LIBRARY_PATH'] game_ld_libary_path = gameplay_info.get('ld_library_path') if game_ld_libary_path: if not ld_library_path: ld_library_path = '$LD_LIBRARY_PATH' ld_library_path = ":".join([game_ld_libary_path, ld_library_path]) env["LD_LIBRARY_PATH"] = ld_library_path # /Env vars self.game_thread = LutrisThread(launch_arguments, runner=self.runner, env=env, rootpid=gameplay_info.get('rootpid'), term=terminal) if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() self.state = self.STATE_RUNNING if 'joy2key' in gameplay_info: self.joy2key(gameplay_info['joy2key']) xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv_start(xboxdrv_config) self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat) def joy2key(self, config): """Run a joy2key thread.""" if not system.find_executable('joy2key'): logger.error("joy2key is not installed") return win = "grep %s" % config['window'] if 'notwindow' in config: win += ' | grep -v %s' % config['notwindow'] wid = "xwininfo -root -tree | %s | awk '{print $1}'" % win buttons = config['buttons'] axis = "Left Right Up Down" rcfile = os.path.expanduser("~/.joy2keyrc") rc_option = '-rcfile %s' % rcfile if os.path.exists(rcfile) else '' command = "sleep 5 " command += "&& joy2key $(%s) -X %s -buttons %s -axis %s" % ( wid, rc_option, buttons, axis ) joy2key_thread = LutrisThread(command) self.game_thread.attach_thread(joy2key_thread) joy2key_thread.start() def xboxdrv_start(self, config): command = [ "pkexec", "xboxdrv", "--daemon", "--detach-kernel-driver", "--dbus", "session", "--silent" ] + config.split() logger.debug("[xboxdrv] %s", ' '.join(command)) self.xboxdrv_thread = LutrisThread(command) self.xboxdrv_thread.set_stop_command(self.xboxdrv_stop) self.xboxdrv_thread.start() def xboxdrv_stop(self): os.system("pkexec xboxdrvctl --shutdown") if os.path.exists("/usr/share/lutris/bin/resetxpad"): os.system("pkexec /usr/share/lutris/bin/resetxpad") def beat(self): """Watch the game's process(es).""" if self.game_thread.error: dialogs.ErrorDialog("<b>Error lauching the game:</b>\n" + self.game_thread.error) self.on_game_quit() return False self.game_log = self.game_thread.stdout killswitch_engage = self.killswitch and \ not os.path.exists(self.killswitch) if not self.game_thread.is_running or killswitch_engage: logger.debug("Game thread stopped") self.on_game_quit() return False return True def stop(self): self.state = self.STATE_STOPPED if self.runner.system_config.get('xboxdrv'): self.xboxdrv_thread.stop() if self.game_thread: jobs.AsyncCall(self.game_thread.stop, None, killall=True) def on_game_quit(self): """Restore some settings and cleanup after game quit.""" self.heartbeat = None quit_time = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime()) logger.debug("%s stopped at %s", self.name, quit_time) self.state = self.STATE_STOPPED os.chdir(os.path.expanduser('~')) if self.resolution_changed\ or self.runner.system_config.get('reset_desktop'): display.change_resolution(self.original_outputs) if self.runner.system_config.get('use_us_layout'): subprocess.Popen(['setxkbmap'], env=os.environ).communicate() if self.runner.system_config.get('restore_gamma'): display.restore_gamma() if self.runner.system_config.get('xboxdrv') \ and self.xboxdrv_thread.is_running: self.xboxdrv_thread.stop() if self.game_thread: self.game_thread.stop() self.process_return_codes() if self.exit_main_loop: exit() def process_return_codes(self): """Do things depending on how the game quitted.""" if self.game_thread.return_code == 127: # Error missing shared lib error = "error while loading shared lib" error_line = strings.lookup_string_in_text(error, self.game_thread.stdout) if error_line: dialogs.ErrorDialog("<b>Error: Missing shared library.</b>" "\n\n%s" % error_line) if self.game_thread.return_code == 1: # Error Wine version conflict error = "maybe the wrong wineserver" if strings.lookup_string_in_text(error, self.game_thread.stdout): dialogs.ErrorDialog("<b>Error: A different Wine version is " "already using the same Wine prefix.</b>")
def wineexec(executable, args="", wine_path=None, prefix=None, arch=None, working_dir=None, winetricks_wine='', blocking=False, config=None, include_processes=[]): """ Execute a Wine command. Args: executable (str): wine program to run, pass None to run wine itself args (str): program arguments wine_path (str): path to the wine version to use prefix (str): path to the wine prefix to use arch (str): wine architecture of the prefix working_dir (str): path to the working dir for the process winetricks_wine (str): path to the wine version used by winetricks blocking (bool): if true, do not run the process in a thread config (LutrisConfig): LutrisConfig object for the process context watch (list): list of process names to monitor (even when in a ignore list) Returns: Process results if the process is running in blocking mode or LutrisThread instance otherwise. """ detected_arch = detect_prefix_arch(prefix) executable = str(executable) if executable else '' if arch not in ('win32', 'win64'): arch = detected_arch or 'win32' if not wine_path: wine_path = wine().get_executable() if not working_dir: if os.path.isfile(executable): working_dir = os.path.dirname(executable) if executable.endswith(".msi"): args = '/i "%s"' % executable executable = 'msiexec' # Create prefix if necessary if not detected_arch: wine_bin = winetricks_wine if winetricks_wine else wine_path create_prefix(prefix, wine_path=wine_bin, arch=arch) env = { 'WINEARCH': arch } if winetricks_wine: env['WINE'] = winetricks_wine else: env['WINE'] = wine_path if prefix: env['WINEPREFIX'] = prefix wine_config = config or LutrisConfig(runner_slug='wine') if not wine_config.system_config['disable_runtime'] and not runtime.is_disabled(): env['LD_LIBRARY_PATH'] = ':'.join(runtime.get_paths()) command = [wine_path] if executable: command.append(executable) command += shlex.split(args) if blocking: return system.execute(command, env=env, cwd=working_dir) else: thread = LutrisThread(command, runner=wine(), env=env, cwd=working_dir, include_processes=include_processes) thread.start() return thread
def execute(self, data): """Run an executable file.""" args = [] terminal = None working_dir = None env = {} if isinstance(data, dict): self._check_required_params([('file', 'command')], data, 'execute') if 'command' in data and 'file' in data: raise ScriptingError( 'Parameters file and command can\'t be used ' 'at the same time for the execute command', data) file_ref = data.get('file', '') command = data.get('command', '') args_string = data.get('args', '') for arg in shlex.split(args_string): args.append(self._substitute(arg)) terminal = data.get('terminal') working_dir = data.get('working_dir') if not data.get('disable_runtime', False): # Possibly need to handle prefer_system_libs here env.update(runtime.get_env()) userenv = data.get('env') or {} for key in userenv: env_value = userenv[key] userenv[key] = self._get_file(env_value) env.update(userenv) include_processes = shlex.split(data.get('include_processes', '')) exclude_processes = shlex.split(data.get('exclude_processes', '')) elif isinstance(data, str): command = data include_processes = [] exclude_processes = [] else: raise ScriptingError('No parameters supplied to execute command.', data) if command: file_ref = 'bash' args = ['-c', self._get_file(command.strip())] include_processes.append('bash') else: # Determine whether 'file' value is a file id or a path file_ref = self._get_file(file_ref) exec_path = system.find_executable(file_ref) if not exec_path: raise ScriptingError("Unable to find executable %s" % file_ref) if not os.access(exec_path, os.X_OK): logger.warning("Making %s executable", exec_path) self.chmodx(exec_path) if terminal: terminal = system.get_default_terminal() if not working_dir or not os.path.exists(working_dir): working_dir = self.target_path command = [exec_path] + args logger.debug("Executing %s", command) thread = LutrisThread(command, env=env, term=terminal, cwd=working_dir, include_processes=include_processes, exclude_processes=exclude_processes) thread.start() GLib.idle_add(self.parent.attach_logger, thread) self.heartbeat = GLib.timeout_add(1000, self._monitor_task, thread) return 'STOP'
def execute(self, data): """Run an executable file.""" args = [] terminal = None working_dir = None env = {} if isinstance(data, dict): if 'command' not in data and 'file' not in data: raise ScriptingError('Parameter file or command is mandatory ' 'for the execute command', data) elif 'command' in data and 'file' in data: raise ScriptingError('Parameters file and command can\'t be ' 'used at the same time for the execute ' 'command', data) file_ref = data.get('file', '') command = data.get('command', '') args_string = data.get('args', '') for arg in shlex.split(args_string): args.append(self._substitute(arg)) terminal = data.get('terminal') working_dir = data.get('working_dir') if not data.get('disable_runtime', False): env.update(runtime.get_env()) userenv = data.get('env', {}) for key in userenv: v = userenv[key] userenv[key] = self._get_file(v) or self._substitute(v) env.update(userenv) include_processes = shlex.split(data.get('include_processes', '')) exclude_processes = shlex.split(data.get('exclude_processes', '')) elif isinstance(data, str): command = data include_processes = [] exclude_processes = [] else: raise ScriptingError('No parameters supplied to execute command.', data) if command: command = command.strip() command = self._get_file(command) or self._substitute(command) file_ref = 'bash' args = ['-c', command] include_processes.append('bash') else: # Determine whether 'file' value is a file id or a path file_ref = self._get_file(file_ref) or self._substitute(file_ref) exec_path = system.find_executable(file_ref) if not exec_path: raise ScriptingError("Unable to find executable %s" % file_ref) if not os.access(exec_path, os.X_OK): self.chmodx(exec_path) if terminal: terminal = system.get_default_terminal() if not working_dir or not os.path.exists(working_dir): working_dir = self.target_path command = [exec_path] + args logger.debug("Executing %s" % command) thread = LutrisThread(command, env=env, term=terminal, cwd=working_dir, include_processes=include_processes, exclude_processes=exclude_processes) thread.start() GLib.idle_add(self.parent.attach_logger, thread) self.heartbeat = GLib.timeout_add(1000, self._monitor_task, thread) return 'STOP'
def do_play(self, prelaunched, _error=None): if not prelaunched: self.state = self.STATE_STOPPED return system_config = self.runner.system_config self.original_outputs = display.get_outputs() gameplay_info = self.runner.play() env = {} logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: show_error_message(gameplay_info) self.state = self.STATE_STOPPED return 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': display.turn_off_except(restrict_to_display) time.sleep(3) self.resolution_changed = True resolution = system_config.get('resolution') if resolution != 'off': display.change_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 os.path.exists(self.killswitch): # Prevent setting a killswitch to a file that doesn't exists self.killswitch = None # Command launch_arguments = gameplay_info['command'] primusrun = system_config.get('primusrun') if primusrun and system.find_executable('primusrun'): launch_arguments.insert(0, 'primusrun') xephyr = system_config.get('xephyr') or 'off' if xephyr != 'off': if xephyr == '8bpp': xephyr_depth = '8' else: xephyr_depth = '16' xephyr_resolution = system_config.get('xephyr_resolution') or '640x480' xephyr_command = ['Xephyr', ':2', '-ac', '-screen', xephyr_resolution + 'x' + xephyr_depth, '-glamor', '-reset', '-terminate', '-fullscreen'] xephyr_thread = LutrisThread(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() pulse_latency = system_config.get('pulse_latency') if pulse_latency: env['PULSE_LATENCY_MSEC'] = '60' prefix_command = system_config.get("prefix_command") or '' if prefix_command.strip(): launch_arguments.insert(0, prefix_command) 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 return # Env vars game_env = gameplay_info.get('env') or {} env.update(game_env) system_env = system_config.get('env') or {} env.update(system_env) ld_preload = gameplay_info.get('ld_preload') or '' env["LD_PRELOAD"] = ld_preload # Runtime management ld_library_path = "" if self.runner.use_runtime(): runtime_env = runtime.get_env() if 'STEAM_RUNTIME' in runtime_env and 'STEAM_RUNTIME' not in env: env['STEAM_RUNTIME'] = runtime_env['STEAM_RUNTIME'] if 'LD_LIBRARY_PATH' in runtime_env: ld_library_path = runtime_env['LD_LIBRARY_PATH'] game_ld_libary_path = gameplay_info.get('ld_library_path') if game_ld_libary_path: if not ld_library_path: ld_library_path = '$LD_LIBRARY_PATH' ld_library_path = ":".join(game_ld_libary_path, ld_library_path) env["LD_LIBRARY_PATH"] = ld_library_path # /Env vars self.game_thread = LutrisThread(launch_arguments, runner=self.runner, env=env, rootpid=gameplay_info.get('rootpid'), term=terminal) if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() self.state = self.STATE_RUNNING if 'joy2key' in gameplay_info: self.joy2key(gameplay_info['joy2key']) xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv_start(xboxdrv_config) self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat)
class Game(object): """This class takes cares of loading the configuration for a game and running it. """ STATE_IDLE = 'idle' STATE_STOPPED = 'stopped' STATE_RUNNING = 'running' def __init__(self, id=None): self.id = id self.runner = None self.game_thread = None self.heartbeat = None self.config = None self.killswitch = None self.state = self.STATE_IDLE self.game_log = '' self.exit_main_loop = False game_data = pga.get_game_by_field(id, 'id') self.slug = game_data.get('slug') or '' self.runner_name = game_data.get('runner') or '' self.directory = game_data.get('directory') or '' self.name = game_data.get('name') or '' self.is_installed = bool(game_data.get('installed')) or False self.year = game_data.get('year') or '' self.game_config_id = game_data.get('configpath') or '' self.steamid = game_data.get('steamid') or '' self.has_custom_banner = bool(game_data.get('has_custom_banner')) or False self.has_custom_icon = bool(game_data.get('has_custom_icon')) or False self.load_config() self.resolution_changed = False self.original_outputs = None def __repr__(self): return self.__unicode__() def __unicode__(self): value = self.name if self.runner_name: value += " (%s)" % self.runner_name return value def get_browse_dir(self): """Return the path to open with the Browse Files action.""" return self.runner.browse_dir def load_config(self): """Load the game's configuration.""" self.config = LutrisConfig(runner_slug=self.runner_name, game_config_id=self.game_config_id) if not self.is_installed: return if not self.runner_name: logger.error('Incomplete data for %s', self.slug) return try: runner_class = import_runner(self.runner_name) except InvalidRunner: logger.error("Unable to import runner %s for %s", self.runner_name, self.slug) else: self.runner = runner_class(self.config) def remove(self, from_library=False, from_disk=False): if from_disk and self.runner: logger.debug("Removing game %s from disk" % self.id) self.runner.remove_game_data(game_path=self.directory) # Do not keep multiple copies of the same game existing_games = pga.get_game_by_field(self.slug, 'slug', all=True) if len(existing_games) > 1: from_library = True if from_library: logger.debug("Removing game %s from library" % self.id) pga.delete_game(self.id) else: pga.set_uninstalled(self.id) self.config.remove() shortcuts.remove_launcher(self.slug, self.id, desktop=True, menu=True) return from_library def save(self): self.config.save() self.id = pga.add_or_update( name=self.name, runner=self.runner_name, slug=self.slug, directory=self.directory, installed=self.is_installed, configpath=self.config.game_config_id, steamid=self.steamid, id=self.id ) def prelaunch(self): """Verify that the current game can be launched.""" if not self.runner.is_installed(): installed = self.runner.install_dialog() if not installed: return False if self.runner.use_runtime(): runtime_updater = runtime.RuntimeUpdater() if runtime_updater.is_updating(): logger.warning("Runtime updates: {}".format( runtime_updater.current_updates) ) dialogs.ErrorDialog("Runtime currently updating", "Game might not work as expected") return True def play(self): """Launch the game.""" if not self.runner: dialogs.ErrorDialog("Invalid game configuration: Missing runner") self.state = self.STATE_STOPPED return if not self.prelaunch(): self.state = self.STATE_STOPPED return if hasattr(self.runner, 'prelaunch'): jobs.AsyncCall(self.runner.prelaunch, self.do_play) else: self.do_play(True) def do_play(self, prelaunched, _error=None): if not prelaunched: self.state = self.STATE_STOPPED return system_config = self.runner.system_config self.original_outputs = display.get_outputs() gameplay_info = self.runner.play() env = {} logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: show_error_message(gameplay_info) self.state = self.STATE_STOPPED return 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': display.turn_off_except(restrict_to_display) time.sleep(3) self.resolution_changed = True resolution = system_config.get('resolution') if resolution != 'off': display.change_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 os.path.exists(self.killswitch): # Prevent setting a killswitch to a file that doesn't exists self.killswitch = None # Command launch_arguments = gameplay_info['command'] primusrun = system_config.get('primusrun') if primusrun and system.find_executable('primusrun'): launch_arguments.insert(0, 'primusrun') xephyr = system_config.get('xephyr') or 'off' if xephyr != 'off': if xephyr == '8bpp': xephyr_depth = '8' else: xephyr_depth = '16' xephyr_resolution = system_config.get('xephyr_resolution') or '640x480' xephyr_command = ['Xephyr', ':2', '-ac', '-screen', xephyr_resolution + 'x' + xephyr_depth, '-glamor', '-reset', '-terminate', '-fullscreen'] xephyr_thread = LutrisThread(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() pulse_latency = system_config.get('pulse_latency') if pulse_latency: env['PULSE_LATENCY_MSEC'] = '60' prefix_command = system_config.get("prefix_command") or '' if prefix_command.strip(): launch_arguments.insert(0, prefix_command) 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 return # Env vars game_env = gameplay_info.get('env') or {} env.update(game_env) system_env = system_config.get('env') or {} env.update(system_env) ld_preload = gameplay_info.get('ld_preload') or '' env["LD_PRELOAD"] = ld_preload # Runtime management ld_library_path = "" if self.runner.use_runtime(): runtime_env = runtime.get_env() if 'STEAM_RUNTIME' in runtime_env and 'STEAM_RUNTIME' not in env: env['STEAM_RUNTIME'] = runtime_env['STEAM_RUNTIME'] if 'LD_LIBRARY_PATH' in runtime_env: ld_library_path = runtime_env['LD_LIBRARY_PATH'] game_ld_libary_path = gameplay_info.get('ld_library_path') if game_ld_libary_path: if not ld_library_path: ld_library_path = '$LD_LIBRARY_PATH' ld_library_path = ":".join(game_ld_libary_path, ld_library_path) env["LD_LIBRARY_PATH"] = ld_library_path # /Env vars self.game_thread = LutrisThread(launch_arguments, runner=self.runner, env=env, rootpid=gameplay_info.get('rootpid'), term=terminal) if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() self.state = self.STATE_RUNNING if 'joy2key' in gameplay_info: self.joy2key(gameplay_info['joy2key']) xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv_start(xboxdrv_config) self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat) def joy2key(self, config): """Run a joy2key thread.""" if not system.find_executable('joy2key'): logger.error("joy2key is not installed") return win = "grep %s" % config['window'] if 'notwindow' in config: win += ' | grep -v %s' % config['notwindow'] wid = "xwininfo -root -tree | %s | awk '{print $1}'" % win buttons = config['buttons'] axis = "Left Right Up Down" rcfile = os.path.expanduser("~/.joy2keyrc") rc_option = '-rcfile %s' % rcfile if os.path.exists(rcfile) else '' command = "sleep 5 " command += "&& joy2key $(%s) -X %s -buttons %s -axis %s" % ( wid, rc_option, buttons, axis ) joy2key_thread = LutrisThread(command) self.game_thread.attach_thread(joy2key_thread) joy2key_thread.start() def xboxdrv_start(self, config): command = [ "pkexec", "xboxdrv", "--daemon", "--detach-kernel-driver", "--dbus", "session", "--silent" ] + config.split() logger.debug("[xboxdrv] %s", ' '.join(command)) self.xboxdrv_thread = LutrisThread(command) self.xboxdrv_thread.set_stop_command(self.xboxdrv_stop) self.xboxdrv_thread.start() def xboxdrv_stop(self): os.system("pkexec xboxdrvctl --shutdown") if os.path.exists("/usr/share/lutris/bin/resetxpad"): os.system("pkexec /usr/share/lutris/bin/resetxpad") def beat(self): """Watch the game's process(es).""" if self.game_thread.error: dialogs.ErrorDialog("<b>Error lauching the game:</b>\n" + self.game_thread.error) self.on_game_quit() return False self.game_log = self.game_thread.stdout killswitch_engage = self.killswitch and \ not os.path.exists(self.killswitch) if not self.game_thread.is_running or killswitch_engage: logger.debug("Game thread stopped") self.on_game_quit() return False return True def stop(self): self.state = self.STATE_STOPPED if self.runner.system_config.get('xboxdrv'): self.xboxdrv_thread.stop() if self.game_thread: jobs.AsyncCall(self.game_thread.stop, None, killall=True) def on_game_quit(self): """Restore some settings and cleanup after game quit.""" self.heartbeat = None quit_time = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime()) logger.debug("%s stopped at %s", self.name, quit_time) self.state = self.STATE_STOPPED os.chdir(os.path.expanduser('~')) if self.resolution_changed\ or self.runner.system_config.get('reset_desktop'): display.change_resolution(self.original_outputs) if self.runner.system_config.get('use_us_layout'): subprocess.Popen(['setxkbmap'], env=os.environ).communicate() if self.runner.system_config.get('restore_gamma'): display.restore_gamma() if self.runner.system_config.get('xboxdrv') \ and self.xboxdrv_thread.is_running: self.xboxdrv_thread.stop() if self.game_thread: self.game_thread.stop() self.process_return_codes() if self.exit_main_loop: exit() def process_return_codes(self): """Do things depending on how the game quitted.""" if self.game_thread.return_code == 127: # Error missing shared lib error = "error while loading shared lib" error_line = strings.lookup_string_in_text(error, self.game_thread.stdout) if error_line: dialogs.ErrorDialog("<b>Error: Missing shared library.</b>" "\n\n%s" % error_line) if self.game_thread.return_code == 1: # Error Wine version conflict error = "maybe the wrong wineserver" if strings.lookup_string_in_text(error, self.game_thread.stdout): dialogs.ErrorDialog("<b>Error: A different Wine version is " "already using the same Wine prefix.</b>")
def play(self): """Launch the game.""" if not self.runner: dialogs.ErrorDialog("Invalid game configuration: Missing runner") return False if not self.prelaunch(): return False system_config = self.runner.system_config self.original_outputs = display.get_outputs() gameplay_info = self.runner.play() logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: show_error_message(gameplay_info) return False launch_arguments = gameplay_info['command'] restrict_to_display = system_config.get('display') if restrict_to_display: display.turn_off_except(restrict_to_display) time.sleep(3) self.resolution_changed = True resolution = system_config.get('resolution') if resolution: display.change_resolution(resolution) time.sleep(3) self.resolution_changed = True if system_config.get('reset_pulse'): audio.reset_pulse() primusrun = system_config.get('primusrun') if primusrun and system.find_executable('primusrun'): launch_arguments.insert(0, 'primusrun') prefix_command = system_config.get("prefix_command", '').strip() if prefix_command: launch_arguments.insert(0, prefix_command) env = os.environ.copy() game_env = gameplay_info.get('env') or {} env.update(game_env) ld_preload = gameplay_info.get('ld_preload') if ld_preload: env["LD_PRELOAD"] = ld_preload ld_library_path = [] if self.use_runtime(system_config): runtime64_path = os.path.join(settings.RUNTIME_DIR, "lib64") if os.path.exists(runtime64_path): ld_library_path.append(runtime64_path) runtime32_path = os.path.join(settings.RUNTIME_DIR, "lib32") if os.path.exists(runtime32_path): ld_library_path.append(runtime32_path) game_ld_libary_path = gameplay_info.get('ld_library_path') if game_ld_libary_path: ld_library_path.append(game_ld_libary_path) if ld_library_path: ld_full = ':'.join(ld_library_path) env["LD_LIBRARY_PATH"] = "{}:$LD_LIBRARY_PATH".format(ld_full) self.killswitch = system_config.get('killswitch') if self.killswitch and not os.path.exists(self.killswitch): # Prevent setting a killswitch to a file that doesn't exists self.killswitch = None self.game_thread = LutrisThread(launch_arguments, runner=self.runner, env=env, rootpid=gameplay_info.get('rootpid')) self.state = self.STATE_RUNNING if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() if 'joy2key' in gameplay_info: self.joy2key(gameplay_info['joy2key']) xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv_start(xboxdrv_config) if self.runner.is_watchable: # Create heartbeat every self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat)
def do_play(self, prelaunched, _error=None): if not prelaunched: self.state = self.STATE_STOPPED return system_config = self.runner.system_config self.original_outputs = sorted( display.get_outputs(), key=lambda e: e[0] == system_config.get('display') ) gameplay_info = self.runner.play() logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: self.show_error_message(gameplay_info) self.state = self.STATE_STOPPED return env = {} sdl_gamecontrollerconfig = system_config.get('sdl_gamecontrollerconfig') if sdl_gamecontrollerconfig: path = os.path.expanduser(sdl_gamecontrollerconfig) if os.path.exists(path): with open(path, "r") as f: sdl_gamecontrollerconfig = f.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': display.turn_off_except(restrict_to_display) time.sleep(3) self.resolution_changed = True resolution = system_config.get('resolution') if resolution != 'off': display.change_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 os.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') xephyr = system_config.get('xephyr') or 'off' if xephyr != 'off': if xephyr == '8bpp': xephyr_depth = '8' else: xephyr_depth = '16' xephyr_resolution = system_config.get('xephyr_resolution') or '640x480' xephyr_command = ['Xephyr', ':2', '-ac', '-screen', xephyr_resolution + 'x' + xephyr_depth, '-glamor', '-reset', '-terminate', '-fullscreen'] xephyr_thread = LutrisThread(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() pulse_latency = system_config.get('pulse_latency') if pulse_latency: env['PULSE_LATENCY_MSEC'] = '60' 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 return # Env vars game_env = gameplay_info.get('env') or self.runner.get_env() env.update(game_env) ld_preload = gameplay_info.get('ld_preload') if ld_preload: env["LD_PRELOAD"] = ld_preload 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' ld_library_path = ":".join([game_ld_libary_path, ld_library_path]) env["LD_LIBRARY_PATH"] = ld_library_path # /Env vars include_processes = shlex.split(system_config.get('include_processes', '')) exclude_processes = shlex.split(system_config.get('exclude_processes', '')) monitoring_disabled = system_config.get('disable_monitoring') if monitoring_disabled: show_obnoxious_process_monitor_message() process_watch = not monitoring_disabled if self.runner.system_config.get('disable_compositor'): self.desktop_effects(False) self.game_thread = LutrisThread(launch_arguments, runner=self.runner, env=env, rootpid=gameplay_info.get('rootpid'), watch=process_watch, term=terminal, log_buffer=self.log_buffer, include_processes=include_processes, exclude_processes=exclude_processes) if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() self.state = self.STATE_RUNNING # xboxdrv setup xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv_start(xboxdrv_config) if monitoring_disabled: logger.info("Process monitoring disabled") else: self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat)
def do_play(self, prelaunched, _error=None): if not prelaunched: self.state = self.STATE_STOPPED return system_config = self.runner.system_config self.original_outputs = display.get_outputs() gameplay_info = self.runner.play() env = {} logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: self.show_error_message(gameplay_info) self.state = self.STATE_STOPPED return 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': display.turn_off_except(restrict_to_display) time.sleep(3) self.resolution_changed = True resolution = system_config.get('resolution') if resolution != 'off': display.change_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 os.path.exists(self.killswitch): # Prevent setting a killswitch to a file that doesn't exists self.killswitch = None # Command launch_arguments = gameplay_info['command'] primusrun = system_config.get('primusrun') if primusrun and system.find_executable('primusrun'): launch_arguments.insert(0, 'primusrun') xephyr = system_config.get('xephyr') or 'off' if xephyr != 'off': if xephyr == '8bpp': xephyr_depth = '8' else: xephyr_depth = '16' xephyr_resolution = system_config.get('xephyr_resolution') or '640x480' xephyr_command = ['Xephyr', ':2', '-ac', '-screen', xephyr_resolution + 'x' + xephyr_depth, '-glamor', '-reset', '-terminate', '-fullscreen'] xephyr_thread = LutrisThread(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() pulse_latency = system_config.get('pulse_latency') if pulse_latency: env['PULSE_LATENCY_MSEC'] = '60' prefix_command = system_config.get("prefix_command") or '' if prefix_command.strip(): launch_arguments.insert(0, prefix_command) 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 return # Env vars game_env = gameplay_info.get('env') or {} env.update(game_env) system_env = system_config.get('env') or {} env.update(system_env) ld_preload = gameplay_info.get('ld_preload') or '' env["LD_PRELOAD"] = ld_preload # Runtime management ld_library_path = "" if self.runner.use_runtime(): runtime_env = runtime.get_env() if 'STEAM_RUNTIME' in runtime_env and 'STEAM_RUNTIME' not in env: env['STEAM_RUNTIME'] = runtime_env['STEAM_RUNTIME'] if 'LD_LIBRARY_PATH' in runtime_env: ld_library_path = runtime_env['LD_LIBRARY_PATH'] game_ld_libary_path = gameplay_info.get('ld_library_path') if game_ld_libary_path: if not ld_library_path: ld_library_path = '$LD_LIBRARY_PATH' ld_library_path = ":".join([game_ld_libary_path, ld_library_path]) env["LD_LIBRARY_PATH"] = ld_library_path # /Env vars self.game_thread = LutrisThread(launch_arguments, runner=self.runner, env=env, rootpid=gameplay_info.get('rootpid'), term=terminal) if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() self.state = self.STATE_RUNNING if 'joy2key' in gameplay_info: self.joy2key(gameplay_info['joy2key']) xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv_start(xboxdrv_config) self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat)
def wineexec( executable, args="", wine_path=None, prefix=None, arch=None, # pylint: disable=too-many-locals working_dir=None, winetricks_wine='', blocking=False, config=None, include_processes=[], exclude_processes=[], disable_runtime=False, env={}, overrides=None): """ Execute a Wine command. Args: executable (str): wine program to run, pass None to run wine itself args (str): program arguments wine_path (str): path to the wine version to use prefix (str): path to the wine prefix to use arch (str): wine architecture of the prefix working_dir (str): path to the working dir for the process winetricks_wine (str): path to the wine version used by winetricks blocking (bool): if true, do not run the process in a thread config (LutrisConfig): LutrisConfig object for the process context watch (list): list of process names to monitor (even when in a ignore list) Returns: Process results if the process is running in blocking mode or LutrisThread instance otherwise. """ executable = str(executable) if executable else '' if not wine_path: wine = import_runner('wine') wine_path = wine().get_executable() if not wine_path: raise RuntimeError("Wine is not installed") if not working_dir: if os.path.isfile(executable): working_dir = os.path.dirname(executable) executable, _args, working_dir = get_real_executable( executable, working_dir) if _args: args = '{} "{}"'.format(_args[0], _args[1]) # Create prefix if necessary if arch not in ('win32', 'win64'): arch = detect_arch(prefix, wine_path) if not detect_prefix_arch(prefix): wine_bin = winetricks_wine if winetricks_wine else wine_path create_prefix(prefix, wine_path=wine_bin, arch=arch) wineenv = {'WINEARCH': arch} if winetricks_wine: wineenv['WINE'] = winetricks_wine else: wineenv['WINE'] = wine_path if prefix: wineenv['WINEPREFIX'] = prefix wine_config = config or LutrisConfig(runner_slug='wine') disable_runtime = disable_runtime or wine_config.system_config[ 'disable_runtime'] if use_lutris_runtime(wine_path=wineenv['WINE'], force_disable=disable_runtime): if WINE_DIR in wine_path: wine_root_path = os.path.dirname(os.path.dirname(wine_path)) elif WINE_DIR in winetricks_wine: wine_root_path = os.path.dirname(os.path.dirname(winetricks_wine)) else: wine_root_path = None wineenv['LD_LIBRARY_PATH'] = ':'.join( runtime.get_paths(prefer_system_libs=wine_config. system_config['prefer_system_libs'], wine_path=wine_root_path)) if overrides: wineenv['WINEDLLOVERRIDES'] = get_overrides_env(overrides) wineenv.update(env) command = [wine_path] if executable: command.append(executable) command += shlex.split(args) if blocking: return system.execute(command, env=wineenv, cwd=working_dir) wine = import_runner('wine') thread = LutrisThread(command, runner=wine(), env=wineenv, cwd=working_dir, include_processes=include_processes, exclude_processes=exclude_processes) thread.start() return thread
class Game(object): """This class takes cares of loading the configuration for a game and running it. """ STATE_IDLE = 'idle' STATE_STOPPED = 'stopped' STATE_RUNNING = 'running' def __init__(self, id=None): self.id = id self.runner = None self.game_thread = None self.heartbeat = None self.config = None self.killswitch = None self.state = self.STATE_IDLE self.exit_main_loop = False game_data = pga.get_game_by_field(id, 'id') self.slug = game_data.get('slug') or '' self.runner_name = game_data.get('runner') or '' self.directory = game_data.get('directory') or '' self.name = game_data.get('name') or '' self.is_installed = bool(game_data.get('installed')) or False self.platform = game_data.get('platform') or '' self.year = game_data.get('year') or '' self.lastplayed = game_data.get('lastplayed') or 0 self.game_config_id = game_data.get('configpath') or '' self.steamid = game_data.get('steamid') or '' self.has_custom_banner = bool(game_data.get('has_custom_banner')) or False self.has_custom_icon = bool(game_data.get('has_custom_icon')) or False self.load_config() self.resolution_changed = False self.original_outputs = None self.log_buffer = Gtk.TextBuffer() self.log_buffer.create_tag("warning", foreground="red") def __repr__(self): return self.__unicode__() def __unicode__(self): value = self.name if self.runner_name: value += " (%s)" % self.runner_name return value def show_error_message(self, message): """Display an error message based on the runner's output.""" if "CUSTOM" == message['error']: message_text = message['text'].replace('&', '&') dialogs.ErrorDialog(message_text) elif "RUNNER_NOT_INSTALLED" == message['error']: dialogs.ErrorDialog('Error the runner is not installed') elif "NO_BIOS" == message['error']: dialogs.ErrorDialog("A bios file is required to run this game") elif "FILE_NOT_FOUND" == message['error']: filename = message['file'] if filename: message_text = "The file {} could not be found".format( filename.replace('&', '&') ) else: message_text = "No file provided" dialogs.ErrorDialog(message_text) elif "NOT_EXECUTABLE" == message['error']: message_text = message['file'].replace('&', '&') dialogs.ErrorDialog("The file %s is not executable" % message_text) def get_browse_dir(self): """Return the path to open with the Browse Files action.""" return self.runner.browse_dir def load_config(self): """Load the game's configuration.""" self.config = LutrisConfig(runner_slug=self.runner_name, game_config_id=self.game_config_id) if not self.is_installed: return if not self.runner_name: logger.error('Incomplete data for %s', self.slug) return try: runner_class = import_runner(self.runner_name) except InvalidRunner: logger.error("Unable to import runner %s for %s", self.runner_name, self.slug) else: self.runner = runner_class(self.config) def remove(self, from_library=False, from_disk=False): if from_disk and self.runner: logger.debug("Removing game %s from disk" % self.id) self.runner.remove_game_data(game_path=self.directory) # Do not keep multiple copies of the same game existing_games = pga.get_games_where(slug=self.slug) if len(existing_games) > 1: from_library = True if from_library: logger.debug("Removing game %s from library" % self.id) pga.delete_game(self.id) else: pga.set_uninstalled(self.id) self.config.remove() xdg.remove_launcher(self.slug, self.id, desktop=True, menu=True) return from_library def set_platform_from_runner(self): if not self.runner: return self.platform = self.runner.get_platform() def save(self, metadata_only=False): """ Save the game's config and metadata, if `metadata_only` is set to True, do not save the config. This is useful when exiting the game since the config might have changed and we don't want to override the changes. """ if not metadata_only: self.config.save() self.id = pga.add_or_update( name=self.name, runner=self.runner_name, slug=self.slug, platform=self.platform, year=self.year, lastplayed=self.lastplayed, directory=self.directory, installed=self.is_installed, configpath=self.config.game_config_id, steamid=self.steamid, id=self.id ) def prelaunch(self): """Verify that the current game can be launched.""" if not self.runner.is_installed(): installed = self.runner.install_dialog() if not installed: return False if self.runner.use_runtime(): runtime_updater = runtime.RuntimeUpdater() if runtime_updater.is_updating(): logger.warning("Runtime updates: {}".format( runtime_updater.current_updates) ) dialogs.ErrorDialog("Runtime currently updating", "Game might not work as expected") return True def play(self): """Launch the game.""" if not self.runner: dialogs.ErrorDialog("Invalid game configuration: Missing runner") self.state = self.STATE_STOPPED return if not self.prelaunch(): self.state = self.STATE_STOPPED return if hasattr(self.runner, 'prelaunch'): jobs.AsyncCall(self.runner.prelaunch, self.do_play) else: self.do_play(True) def do_play(self, prelaunched, _error=None): if not prelaunched: self.state = self.STATE_STOPPED return system_config = self.runner.system_config self.original_outputs = sorted( display.get_outputs(), key=lambda e: e[0] == system_config.get('display') ) gameplay_info = self.runner.play() env = {} logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: self.show_error_message(gameplay_info) self.state = self.STATE_STOPPED return sdl_gamecontrollerconfig = system_config.get('sdl_gamecontrollerconfig') if sdl_gamecontrollerconfig: path = os.path.expanduser(sdl_gamecontrollerconfig) if os.path.exists(path): with open(path, "r") as f: sdl_gamecontrollerconfig = f.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': display.turn_off_except(restrict_to_display) time.sleep(3) self.resolution_changed = True resolution = system_config.get('resolution') if resolution != 'off': display.change_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 os.path.exists(self.killswitch): # Prevent setting a killswitch to a file that doesn't exists self.killswitch = None # Command launch_arguments = gameplay_info['command'] primusrun = system_config.get('primusrun') if primusrun and system.find_executable('primusrun'): launch_arguments.insert(0, 'primusrun') xephyr = system_config.get('xephyr') or 'off' if xephyr != 'off': if xephyr == '8bpp': xephyr_depth = '8' else: xephyr_depth = '16' xephyr_resolution = system_config.get('xephyr_resolution') or '640x480' xephyr_command = ['Xephyr', ':2', '-ac', '-screen', xephyr_resolution + 'x' + xephyr_depth, '-glamor', '-reset', '-terminate', '-fullscreen'] xephyr_thread = LutrisThread(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() pulse_latency = system_config.get('pulse_latency') if pulse_latency: env['PULSE_LATENCY_MSEC'] = '60' 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 return # Env vars game_env = gameplay_info.get('env') or {} env.update(game_env) ld_preload = gameplay_info.get('ld_preload') if (ld_preload): env["LD_PRELOAD"] = ld_preload 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' ld_library_path = ":".join([game_ld_libary_path, ld_library_path]) env["LD_LIBRARY_PATH"] = ld_library_path # /Env vars include_processes = shlex.split(system_config.get('include_processes', '')) exclude_processes = shlex.split(system_config.get('exclude_processes', '')) monitoring_disabled = system_config.get('disable_monitoring') process_watch = not monitoring_disabled self.game_thread = LutrisThread(launch_arguments, runner=self.runner, env=env, rootpid=gameplay_info.get('rootpid'), watch=process_watch, term=terminal, log_buffer=self.log_buffer, include_processes=include_processes, exclude_processes=exclude_processes) if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() self.state = self.STATE_RUNNING # xboxdrv setup xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv_start(xboxdrv_config) if monitoring_disabled: logger.info("Process monitoring disabled") else: self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat) def xboxdrv_start(self, config): command = [ "pkexec", "xboxdrv", "--daemon", "--detach-kernel-driver", "--dbus", "session", "--silent" ] + config.split() logger.debug("[xboxdrv] %s", ' '.join(command)) self.xboxdrv_thread = LutrisThread(command, include_processes=['xboxdrv']) self.xboxdrv_thread.set_stop_command(self.xboxdrv_stop) self.xboxdrv_thread.start() def xboxdrv_stop(self): os.system("pkexec xboxdrvctl --shutdown") if os.path.exists("/usr/share/lutris/bin/resetxpad"): os.system("pkexec /usr/share/lutris/bin/resetxpad") def beat(self): """Watch the game's process(es).""" if self.game_thread.error: dialogs.ErrorDialog("<b>Error lauching the game:</b>\n" + self.game_thread.error) self.on_game_quit() return False # The killswitch file should be set to a device (ie. /dev/input/js0) # When that device is unplugged, the game is forced to quit. killswitch_engage = ( self.killswitch and not os.path.exists(self.killswitch) ) if not self.game_thread.is_running or killswitch_engage: logger.debug("Game thread stopped") self.on_game_quit() return False return True def stop(self): if self.runner.system_config.get('xboxdrv'): logger.debug("Stopping xboxdrv") self.xboxdrv_thread.stop() if self.game_thread: jobs.AsyncCall(self.game_thread.stop, None, killall=self.runner.killall_on_exit()) self.state = self.STATE_STOPPED def on_game_quit(self): """Restore some settings and cleanup after game quit.""" self.heartbeat = None if self.state != self.STATE_STOPPED: logger.debug("Game thread still running, stopping it (state: %s)", self.state) self.stop() 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.change_resolution(self.original_outputs) if self.runner.system_config.get('use_us_layout'): subprocess.Popen(['setxkbmap'], env=os.environ).communicate() if self.runner.system_config.get('restore_gamma'): display.restore_gamma() self.process_return_codes() if self.exit_main_loop: exit() def process_return_codes(self): """Do things depending on how the game quitted.""" if self.game_thread.return_code == 127: # Error missing shared lib error = "error while loading shared lib" error_line = strings.lookup_string_in_text(error, self.game_thread.stdout) if error_line: dialogs.ErrorDialog("<b>Error: Missing shared library.</b>" "\n\n%s" % error_line) if self.game_thread.return_code == 1: # Error Wine version conflict error = "maybe the wrong wineserver" if strings.lookup_string_in_text(error, self.game_thread.stdout): dialogs.ErrorDialog("<b>Error: A different Wine version is " "already using the same Wine prefix.</b>") def notify_steam_game_changed(self, appmanifest): logger.debug("Steam game %s state has changed, new states: %s", appmanifest.steamid, ', '.join(appmanifest.states)) if 'Fully Installed' in appmanifest.states: self.game_thread.ready_state = True elif 'Update Required' in appmanifest.states: self.game_thread.ready_state = False
class Game(object): """This class takes cares about loading the configuration for a game and running it. """ def __init__(self, slug): self.slug = slug self.runner = None self.game_thread = None self.heartbeat = None self.config = None game_data = pga.get_game_by_slug(slug) self.runner_name = game_data.get('runner') or '' self.directory = game_data.get('directory') or '' self.name = game_data.get('name') or '' self.is_installed = bool(game_data.get('installed')) or False self.year = game_data.get('year') or '' self.load_config() self.resolution_changed = False self.original_outputs = None def __repr__(self): return self.__unicode__() def __unicode__(self): value = self.name if self.runner_name: value += " (%s)" % self.runner_name return value def get_browse_dir(self): """Return the path to open with the Browse Files action.""" return self.runner.browse_dir def load_config(self): """Load the game's configuration.""" self.config = LutrisConfig(game=self.slug) if self.is_installed: runner_class = import_runner(self.runner_name) if runner_class: self.runner = runner_class(self.config) else: logger.error("Unable to import runner %s for %s", self.runner_name, self.slug) def remove(self, from_library=False, from_disk=False): if from_disk: self.runner.remove_game_data(game_path=self.directory) if from_library: pga.delete_game(self.slug) self.config.remove() else: pga.set_uninstalled(self.slug) def prelaunch(self): """Verify that the current game can be launched.""" if not self.runner.is_installed(): installed = self.runner.install_dialog() if not installed: return False if hasattr(self.runner, 'prelaunch'): return self.runner.prelaunch() return True def play(self): """Launch the game.""" if not self.runner: dialogs.ErrorDialog("Invalid game configuration: Missing runner") return False if not self.prelaunch(): return False system_config = self.runner.system_config self.original_outputs = display.get_outputs() gameplay_info = self.runner.play() logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: show_error_message(gameplay_info) return False launch_arguments = gameplay_info['command'] restrict_to_display = system_config.get('display') if restrict_to_display: display.turn_off_except(restrict_to_display) self.resolution_changed = True resolution = system_config.get('resolution') if resolution: display.change_resolution(resolution) self.resolution_changed = True if system_config.get('reset_pulse'): audio.reset_pulse() prefix_command = system_config.get("prefix_command", '').strip() if prefix_command and system.find_executable(prefix_command): launch_arguments.insert(0, prefix_command) ld_preload = gameplay_info.get('ld_preload') if ld_preload: launch_arguments.insert(0, 'LD_PRELOAD="{}"'.format(ld_preload)) ld_library_path = [] runtime64_path = os.path.join(settings.RUNTIME_DIR, "lib64") if os.path.exists(runtime64_path): ld_library_path.append(runtime64_path) runtime32_path = os.path.join(settings.RUNTIME_DIR, "lib32") if os.path.exists(runtime32_path): ld_library_path.append(runtime32_path) game_ld_libary_path = gameplay_info.get('ld_library_path') if game_ld_libary_path: ld_library_path.append(game_ld_libary_path) if ld_library_path: ld_full = ':'.join(ld_library_path) ld_arg = 'LD_LIBRARY_PATH="{}:$LD_LIBRARY_PATH"'.format(ld_full) launch_arguments.insert(0, ld_arg) env = gameplay_info.get('env') or [] for var in env: launch_arguments.insert(0, var) killswitch = system_config.get('killswitch') self.game_thread = LutrisThread(" ".join(launch_arguments), path=self.runner.working_dir, killswitch=killswitch) if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() if 'joy2key' in gameplay_info: self.joy2key(gameplay_info['joy2key']) xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv_start(xboxdrv_config) if self.runner.is_watchable: # Create heartbeat every self.heartbeat = GLib.timeout_add(5000, self.poke_process) def joy2key(self, config): """Run a joy2key thread.""" if not system.find_executable('joy2key'): logger.error("joy2key is not installed") return win = "grep %s" % config['window'] if 'notwindow' in config: win += ' | grep -v %s' % config['notwindow'] wid = "xwininfo -root -tree | %s | awk '{print $1}'" % win buttons = config['buttons'] axis = "Left Right Up Down" rcfile = os.path.expanduser("~/.joy2keyrc") rc_option = '-rcfile %s' % rcfile if os.path.exists(rcfile) else '' command = "sleep 5 " command += "&& joy2key $(%s) -X %s -buttons %s -axis %s" % ( wid, rc_option, buttons, axis ) joy2key_thread = LutrisThread(command) self.game_thread.attach_thread(joy2key_thread) joy2key_thread.start() def xboxdrv_start(self, config): command = ("pkexec xboxdrv --daemon --detach-kernel-driver " "--dbus session --silent %s" % config) logger.debug("xboxdrv command: %s", command) self.xboxdrv_thread = LutrisThread(command) self.xboxdrv_thread.set_stop_command(self.xboxdrv_stop) self.xboxdrv_thread.start() def xboxdrv_stop(self): os.system("pkexec xboxdrvctl --shutdown") def poke_process(self): """Watch game's process.""" if not self.game_thread.pid: self.quit_game() return False return True def quit_game(self): """Quit the game and cleanup.""" self.heartbeat = None quit_time = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime()) logger.debug("game has quit at %s" % quit_time) if self.resolution_changed\ or self.runner.system_config.get('reset_desktop'): display.change_resolution(self.original_outputs) if self.runner.system_config.get('restore_gamma'): display.restore_gamma() if self.runner.system_config.get('xboxdrv'): self.xboxdrv_thread.stop() if self.game_thread: self.game_thread.stop()
class Game(object): """This class takes cares about loading the configuration for a game and running it. """ def __init__(self, slug): self.slug = slug self.runner = None self.game_thread = None self.heartbeat = None self.config = None game_data = pga.get_game_by_slug(slug) self.runner_name = game_data.get('runner') or '' self.directory = game_data.get('directory') or '' self.name = game_data.get('name') or '' self.is_installed = bool(game_data.get('installed')) or False self.year = game_data.get('year') or '' self.load_config() self.resolution_changed = False self.original_outputs = None def __repr__(self): return self.__unicode__() def __unicode__(self): value = self.name if self.runner_name: value += " (%s)" % self.runner_name return value def get_browse_dir(self): """Return the path to open with the Browse Files action.""" return self.runner.browse_dir def load_config(self): """Load the game's configuration.""" self.config = LutrisConfig(game=self.slug) if self.is_installed: runner_class = import_runner(self.runner_name) if runner_class: self.runner = runner_class(self.config) else: logger.error("Unable to import runner %s for %s", self.runner_name, self.slug) def remove(self, from_library=False, from_disk=False): if from_disk: self.runner.remove_game_data(game_path=self.directory) if from_library: pga.delete_game(self.slug) self.config.remove() else: pga.set_uninstalled(self.slug) def prelaunch(self): """Verify that the current game can be launched.""" if not self.runner.is_installed(): installed = self.runner.install_dialog() if not installed: return False if hasattr(self.runner, 'prelaunch'): return self.runner.prelaunch() return True def use_runtime(self, system_config): disable_runtime = system_config.get('disable_runtime') env_runtime = os.getenv('LUTRIS_RUNTIME') if env_runtime and env_runtime.lower() in ('0', 'off'): disable_runtime = True return not disable_runtime def play(self): """Launch the game.""" if not self.runner: dialogs.ErrorDialog("Invalid game configuration: Missing runner") return False if not self.prelaunch(): return False system_config = self.runner.system_config self.original_outputs = display.get_outputs() gameplay_info = self.runner.play() logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: show_error_message(gameplay_info) return False launch_arguments = gameplay_info['command'] restrict_to_display = system_config.get('display') if restrict_to_display: display.turn_off_except(restrict_to_display) time.sleep(3) self.resolution_changed = True resolution = system_config.get('resolution') if resolution: display.change_resolution(resolution) time.sleep(3) self.resolution_changed = True if system_config.get('reset_pulse'): audio.reset_pulse() primusrun = system_config.get('primusrun') if primusrun and system.find_executable('primusrun'): launch_arguments.insert(0, 'primusrun') prefix_command = system_config.get("prefix_command", '').strip() if prefix_command: launch_arguments.insert(0, prefix_command) ld_preload = gameplay_info.get('ld_preload') if ld_preload: launch_arguments.insert(0, 'LD_PRELOAD="{}"'.format(ld_preload)) ld_library_path = [] if self.use_runtime(system_config): runtime64_path = os.path.join(settings.RUNTIME_DIR, "lib64") if os.path.exists(runtime64_path): ld_library_path.append(runtime64_path) runtime32_path = os.path.join(settings.RUNTIME_DIR, "lib32") if os.path.exists(runtime32_path): ld_library_path.append(runtime32_path) game_ld_libary_path = gameplay_info.get('ld_library_path') if game_ld_libary_path: ld_library_path.append(game_ld_libary_path) if ld_library_path: ld_full = ':'.join(ld_library_path) ld_arg = 'LD_LIBRARY_PATH="{}:$LD_LIBRARY_PATH"'.format(ld_full) launch_arguments.insert(0, ld_arg) env = gameplay_info.get('env') or [] for var in env: launch_arguments.insert(0, var) killswitch = system_config.get('killswitch') self.game_thread = LutrisThread(" ".join(launch_arguments), path=self.runner.working_dir, killswitch=killswitch) if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() if 'joy2key' in gameplay_info: self.joy2key(gameplay_info['joy2key']) xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv_start(xboxdrv_config) if self.runner.is_watchable: # Create heartbeat every self.heartbeat = GLib.timeout_add(5000, self.poke_process) def joy2key(self, config): """Run a joy2key thread.""" if not system.find_executable('joy2key'): logger.error("joy2key is not installed") return win = "grep %s" % config['window'] if 'notwindow' in config: win += ' | grep -v %s' % config['notwindow'] wid = "xwininfo -root -tree | %s | awk '{print $1}'" % win buttons = config['buttons'] axis = "Left Right Up Down" rcfile = os.path.expanduser("~/.joy2keyrc") rc_option = '-rcfile %s' % rcfile if os.path.exists(rcfile) else '' command = "sleep 5 " command += "&& joy2key $(%s) -X %s -buttons %s -axis %s" % ( wid, rc_option, buttons, axis ) joy2key_thread = LutrisThread(command) self.game_thread.attach_thread(joy2key_thread) joy2key_thread.start() def xboxdrv_start(self, config): command = ("pkexec xboxdrv --daemon --detach-kernel-driver " "--dbus session --silent %s" % config) logger.debug("xboxdrv command: %s", command) self.xboxdrv_thread = LutrisThread(command) self.xboxdrv_thread.set_stop_command(self.xboxdrv_stop) self.xboxdrv_thread.start() def xboxdrv_stop(self): os.system("pkexec xboxdrvctl --shutdown") def poke_process(self): """Watch game's process.""" if not self.game_thread.pid: self.quit_game() return False return True def quit_game(self): """Quit the game and cleanup.""" self.heartbeat = None quit_time = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime()) logger.debug("game has quit at %s" % quit_time) if self.resolution_changed\ or self.runner.system_config.get('reset_desktop'): display.change_resolution(self.original_outputs) if self.runner.system_config.get('restore_gamma'): display.restore_gamma() if self.runner.system_config.get('xboxdrv'): self.xboxdrv_thread.stop() if self.game_thread: self.game_thread.stop()
def play(self): """Launch the game.""" if not self.runner: dialogs.ErrorDialog("Invalid game configuration: Missing runner") return False if not self.prelaunch(): return False system_config = self.runner.system_config self.original_outputs = display.get_outputs() gameplay_info = self.runner.play() logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: show_error_message(gameplay_info) return False launch_arguments = gameplay_info['command'] restrict_to_display = system_config.get('display') if restrict_to_display: display.turn_off_except(restrict_to_display) self.resolution_changed = True resolution = system_config.get('resolution') if resolution: display.change_resolution(resolution) self.resolution_changed = True if system_config.get('reset_pulse'): audio.reset_pulse() prefix_command = system_config.get("prefix_command", '').strip() if prefix_command and system.find_executable(prefix_command): launch_arguments.insert(0, prefix_command) ld_preload = gameplay_info.get('ld_preload') if ld_preload: launch_arguments.insert(0, 'LD_PRELOAD="{}"'.format(ld_preload)) ld_library_path = [] runtime64_path = os.path.join(settings.RUNTIME_DIR, "lib64") if os.path.exists(runtime64_path): ld_library_path.append(runtime64_path) runtime32_path = os.path.join(settings.RUNTIME_DIR, "lib32") if os.path.exists(runtime32_path): ld_library_path.append(runtime32_path) game_ld_libary_path = gameplay_info.get('ld_library_path') if game_ld_libary_path: ld_library_path.append(game_ld_libary_path) if ld_library_path: ld_full = ':'.join(ld_library_path) ld_arg = 'LD_LIBRARY_PATH="{}:$LD_LIBRARY_PATH"'.format(ld_full) launch_arguments.insert(0, ld_arg) env = gameplay_info.get('env') or [] for var in env: launch_arguments.insert(0, var) killswitch = system_config.get('killswitch') self.game_thread = LutrisThread(" ".join(launch_arguments), path=self.runner.working_dir, killswitch=killswitch) if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() if 'joy2key' in gameplay_info: self.joy2key(gameplay_info['joy2key']) xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv_start(xboxdrv_config) if self.runner.is_watchable: # Create heartbeat every self.heartbeat = GLib.timeout_add(5000, self.poke_process)
def play(self): """Launch the game.""" if not self.runner: dialogs.ErrorDialog("Invalid game configuration: Missing runner") return False if not self.prelaunch(): return False system_config = self.runner.system_config self.original_outputs = display.get_outputs() gameplay_info = self.runner.play() logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: show_error_message(gameplay_info) return False restrict_to_display = system_config.get('display') if restrict_to_display != 'off': display.turn_off_except(restrict_to_display) time.sleep(3) self.resolution_changed = True resolution = system_config.get('resolution') if resolution != 'off': display.change_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 os.path.exists(self.killswitch): # Prevent setting a killswitch to a file that doesn't exists self.killswitch = None # Command launch_arguments = gameplay_info['command'] primusrun = system_config.get('primusrun') if primusrun and system.find_executable('primusrun'): launch_arguments.insert(0, 'primusrun') prefix_command = system_config.get("prefix_command") or '' if prefix_command.strip(): launch_arguments.insert(0, prefix_command) 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) return False # Env vars env = {} game_env = gameplay_info.get('env') or {} env.update(game_env) ld_preload = gameplay_info.get('ld_preload') if ld_preload: env["LD_PRELOAD"] = ld_preload ld_library_path = [] if self.use_runtime(system_config): env['STEAM_RUNTIME'] = os.path.join(settings.RUNTIME_DIR, 'steam') ld_library_path += runtime.get_runtime_paths() game_ld_libary_path = gameplay_info.get('ld_library_path') if game_ld_libary_path: ld_library_path.append(game_ld_libary_path) if ld_library_path: ld_full = ':'.join(ld_library_path) env["LD_LIBRARY_PATH"] = "{}:$LD_LIBRARY_PATH".format(ld_full) # /Env vars self.game_thread = LutrisThread(launch_arguments, runner=self.runner, env=env, rootpid=gameplay_info.get('rootpid'), term=terminal) self.state = self.STATE_RUNNING if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() if 'joy2key' in gameplay_info: self.joy2key(gameplay_info['joy2key']) xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv_start(xboxdrv_config) if self.runner.is_watchable: # Create heartbeat every self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat)
class Game(object): """This class takes cares about loading the configuration for a game and running it. """ STATE_IDLE = 'idle' STATE_STOPPED = 'stopped' STATE_RUNNING = 'running' def __init__(self, slug): self.slug = slug self.runner = None self.game_thread = None self.heartbeat = None self.config = None self.killswitch = None self.state = self.STATE_IDLE self.game_log = '' game_data = pga.get_game_by_slug(slug) self.runner_name = game_data.get('runner') or '' self.directory = game_data.get('directory') or '' self.name = game_data.get('name') or '' self.is_installed = bool(game_data.get('installed')) or False self.year = game_data.get('year') or '' self.load_config() self.resolution_changed = False self.original_outputs = None def __repr__(self): return self.__unicode__() def __unicode__(self): value = self.name if self.runner_name: value += " (%s)" % self.runner_name return value def get_browse_dir(self): """Return the path to open with the Browse Files action.""" return self.runner.browse_dir def load_config(self): """Load the game's configuration.""" self.config = LutrisConfig(runner_slug=self.runner_name, game_slug=self.slug) if not self.is_installed: return if not self.runner_name: logger.error('Incomplete data for %s', self.slug) return try: runner_class = import_runner(self.runner_name) except InvalidRunner: logger.error("Unable to import runner %s for %s", self.runner_name, self.slug) self.runner = runner_class(self.config) def remove(self, from_library=False, from_disk=False): if from_disk: self.runner.remove_game_data(game_path=self.directory) if from_library: pga.delete_game(self.slug) self.config.remove() else: pga.set_uninstalled(self.slug) def save(self): self.config.save() pga.add_or_update( name=self.name, runner=self.runner_name, slug=self.slug, directory=self.directory, installed=self.is_installed ) def prelaunch(self): """Verify that the current game can be launched.""" if not self.runner.is_installed(): installed = self.runner.install_dialog() if not installed: return False if hasattr(self.runner, 'prelaunch'): return self.runner.prelaunch() return True def use_runtime(self, system_config): disable_runtime = system_config.get('disable_runtime') env_runtime = os.getenv('LUTRIS_RUNTIME') if env_runtime and env_runtime.lower() in ('0', 'off'): disable_runtime = True return not disable_runtime def play(self): """Launch the game.""" if not self.runner: dialogs.ErrorDialog("Invalid game configuration: Missing runner") return False if not self.prelaunch(): return False system_config = self.runner.system_config self.original_outputs = display.get_outputs() gameplay_info = self.runner.play() logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: show_error_message(gameplay_info) return False restrict_to_display = system_config.get('display') if restrict_to_display != 'off': display.turn_off_except(restrict_to_display) time.sleep(3) self.resolution_changed = True resolution = system_config.get('resolution') if resolution != 'off': display.change_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 os.path.exists(self.killswitch): # Prevent setting a killswitch to a file that doesn't exists self.killswitch = None # Command launch_arguments = gameplay_info['command'] primusrun = system_config.get('primusrun') if primusrun and system.find_executable('primusrun'): launch_arguments.insert(0, 'primusrun') prefix_command = system_config.get("prefix_command") or '' if prefix_command.strip(): launch_arguments.insert(0, prefix_command) 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) return False # Env vars env = {} game_env = gameplay_info.get('env') or {} env.update(game_env) ld_preload = gameplay_info.get('ld_preload') if ld_preload: env["LD_PRELOAD"] = ld_preload ld_library_path = [] if self.use_runtime(system_config): env['STEAM_RUNTIME'] = os.path.join(settings.RUNTIME_DIR, 'steam') ld_library_path += runtime.get_runtime_paths() game_ld_libary_path = gameplay_info.get('ld_library_path') if game_ld_libary_path: ld_library_path.append(game_ld_libary_path) if ld_library_path: ld_full = ':'.join(ld_library_path) env["LD_LIBRARY_PATH"] = "{}:$LD_LIBRARY_PATH".format(ld_full) # /Env vars self.game_thread = LutrisThread(launch_arguments, runner=self.runner, env=env, rootpid=gameplay_info.get('rootpid'), term=terminal) self.state = self.STATE_RUNNING if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() if 'joy2key' in gameplay_info: self.joy2key(gameplay_info['joy2key']) xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv_start(xboxdrv_config) if self.runner.is_watchable: # Create heartbeat every self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat) def joy2key(self, config): """Run a joy2key thread.""" if not system.find_executable('joy2key'): logger.error("joy2key is not installed") return win = "grep %s" % config['window'] if 'notwindow' in config: win += ' | grep -v %s' % config['notwindow'] wid = "xwininfo -root -tree | %s | awk '{print $1}'" % win buttons = config['buttons'] axis = "Left Right Up Down" rcfile = os.path.expanduser("~/.joy2keyrc") rc_option = '-rcfile %s' % rcfile if os.path.exists(rcfile) else '' command = "sleep 5 " command += "&& joy2key $(%s) -X %s -buttons %s -axis %s" % ( wid, rc_option, buttons, axis ) joy2key_thread = LutrisThread(command) self.game_thread.attach_thread(joy2key_thread) joy2key_thread.start() def xboxdrv_start(self, config): command = [ "pkexec", "xboxdrv", "--daemon", "--detach-kernel-driver", "--dbus", "session", "--silent" ] + config.split() logger.debug("xboxdrv command: %s", command) self.xboxdrv_thread = LutrisThread(command) self.xboxdrv_thread.set_stop_command(self.xboxdrv_stop) self.xboxdrv_thread.start() def xboxdrv_stop(self): os.system("pkexec xboxdrvctl --shutdown") def beat(self): """Watch game's process.""" self.game_log = self.game_thread.stdout killswitch_engage = self.killswitch and \ not os.path.exists(self.killswitch) if not self.game_thread.is_running or killswitch_engage: self.on_game_quit() return False return True def stop(self): self.game_thread.stop(killall=True) def on_game_quit(self): """Restore some settings and cleanup after game quit.""" self.heartbeat = None quit_time = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime()) logger.debug("game has quit at %s" % quit_time) self.state = self.STATE_STOPPED if self.resolution_changed\ or self.runner.system_config.get('reset_desktop'): display.change_resolution(self.original_outputs) if self.runner.system_config.get('restore_gamma'): display.restore_gamma() if self.runner.system_config.get('xboxdrv'): self.xboxdrv_thread.stop() if self.game_thread: self.game_thread.stop()