class EditGameConfigDialog(Gtk.Dialog, GameDialogCommon):
""" Game config edit dialog """
def __init__(self, parent, game):
super(EditGameConfigDialog, self).__init__()
self.parent_window = parent
self.game = game
self.lutris_config = LutrisConfig(game=game)
self.runner_name = self.lutris_config.runner
game_name = self.lutris_config.config.get("realname", game)
self.set_title("Edit game configuration for %s" % game_name)
self.set_size_request(500, 500)
self.build_notebook()
self.build_game_tab()
self.build_runner_tab()
self.build_system_tab()
self.build_action_area(Gtk.STOCK_EDIT, self.edit_game)
self.show_all()
self.run()
def edit_game(self, _widget=None):
"""Save the changes"""
self.lutris_config.save(config_type="game")
self.destroy()
def install(self):
success = super(hatari, self).install()
if not success:
return False
config_path = os.path.expanduser('~/.hatari')
if not os.path.exists(config_path):
os.makedirs(config_path)
bios_path = os.path.expanduser('~/.hatari/bios')
if not os.path.exists(bios_path):
os.makedirs(bios_path)
dlg = QuestionDialog({
'question': "Do you want to select an Atari ST BIOS file?",
'title': "Use BIOS file?",
})
if dlg.result == dlg.YES:
bios_dlg = FileDialog("Select a BIOS file")
bios_filename = bios_dlg.filename
if not bios_filename:
return
shutil.copy(bios_filename, bios_path)
bios_path = os.path.join(bios_path, os.path.basename(bios_filename))
config = LutrisConfig(runner_slug='hatari')
config.raw_runner_config.update({'bios_file': bios_path})
config.save()
return True
def mark_as_installed(appid, runner_name, game_info):
for key in ['name', 'slug']:
assert game_info[key]
logger.info("Setting %s as installed", game_info['name'])
config_id = (game_info.get('config_path') or make_game_config_id(game_info['slug']))
game_id = pga.add_or_update(
name=game_info['name'],
runner=runner_name,
slug=game_info['slug'],
installed=1,
configpath=config_id,
installer_slug=game_info['installer_slug']
)
config = LutrisConfig(
runner_slug=runner_name,
game_config_id=config_id,
)
config.raw_game_config.update({
'appid': appid,
'exe': game_info['exe'],
'args': game_info['args']
})
config.raw_system_config.update({
'disable_runtime': True
})
config.save()
return game_id
def mark_as_installed(appid, runner_name, game_info):
for key in ['name', 'slug']:
assert game_info[key]
logger.info("Setting %s as installed" % game_info['name'])
config_id = (game_info.get('config_path') or make_game_config_id(game_info['slug']))
game_id = pga.add_or_update(
name=game_info['name'],
runner=runner_name,
slug=game_info['slug'],
installed=1,
configpath=config_id,
installer_slug=game_info['installer_slug']
)
config = LutrisConfig(
runner_slug=runner_name,
game_config_id=config_id,
)
config.raw_game_config.update({
'appid': appid,
'exe': game_info['exe'],
'args': game_info['args']
})
config.raw_system_config.update({
'disable_runtime': True
})
config.save()
return game_id
def create_config(self):
"""Create the game configuration for a Steam game"""
game_config = LutrisConfig(
runner_slug=self.runner, game_config_id=self.config_id
)
game_config.raw_game_config.update({"appid": self.appid})
game_config.save()
def install(self):
success = super(hatari, self).install()
if not success:
return False
config_path = os.path.expanduser('~/.hatari')
if not os.path.exists(config_path):
os.makedirs(config_path)
bios_path = os.path.expanduser('~/.hatari/bios')
if not os.path.exists(bios_path):
os.makedirs(bios_path)
dlg = QuestionDialog({
'question': "Do you want to select an Atari ST BIOS file?",
'title': "Use BIOS file?",
})
if dlg.result == dlg.YES:
bios_dlg = FileDialog("Select a BIOS file")
bios_filename = bios_dlg.filename
shutil.copy(bios_filename, bios_path)
bios_path = os.path.join(bios_path,
os.path.basename(bios_filename))
runner_config = LutrisConfig(runner='hatari')
runner_config.config_type = 'runner'
runner_config.runner_config = {'hatari': {'bios_file': bios_path}}
runner_config.save()
return True
def on_runner_installed(*args):
bios_path = system.create_folder('~/.pcsxr/bios')
dlg = QuestionDialog({
'question':
("Do you want to select a Playstation BIOS file?\n\n"
"The BIOS is the core code running the machine.\n"
"PCSX-Reloaded includes an emulated BIOS, but it is "
"still incomplete. \n"
"Using an original BIOS avoids some bugs and reduced "
"compatibility \n"
"with some games."),
'title':
"Use BIOS file?",
})
if dlg.result == dlg.YES:
bios_dlg = FileDialog("Select a BIOS file")
bios_src = bios_dlg.filename
shutil.copy(bios_src, bios_path)
# Save bios in config
bios_path = os.path.join(bios_path, os.path.basename(bios_src))
config = LutrisConfig(runner_slug='pcsxr')
config.raw_runner_config.update({'bios': bios_path})
config.save()
if callback:
callback()
def install(self):
success = super(pcsxr, self).install()
if not success:
return False
config_path = os.path.expanduser('~/.pcsxr')
if not os.path.exists(config_path):
os.makedirs(config_path)
# Bios
bios_path = os.path.expanduser('~/.pcsxr/bios')
if not os.path.exists(bios_path):
os.makedirs(bios_path)
dlg = QuestionDialog({
'question': ("Do you want to select a Playstation BIOS file?\n\n"
"The BIOS is the core code running the machine.\n"
"PCSX-Reloaded includes an emulated BIOS, but it is "
"still incomplete. \n"
"Using an original BIOS avoids some bugs and reduced "
"compatibility \n"
"with some games."),
'title': "Use BIOS file?",
})
if dlg.result == dlg.YES:
bios_dlg = FileDialog("Select a BIOS file")
bios_src = bios_dlg.filename
shutil.copy(bios_src, bios_path)
# Save bios in config
bios_path = os.path.join(bios_path, os.path.basename(bios_src))
runner_config = LutrisConfig(runner='pcsxr')
runner_config.config_type = 'runner'
runner_config.runner_config = {'pcsxr': {'bios': bios_path}}
runner_config.save()
return True
def create_config(self, db_game, config_id):
details = json.loads(db_game["details"])
config = LutrisConfig(runner_slug="linux", game_config_id=config_id)
config.raw_game_config.update({
"exe": details["exe"],
"args": details["args"],
})
config.raw_system_config.update({"disable_runtime": True})
config.save()
def create_config(self):
"""Create a Lutris config for the current game"""
config = LutrisConfig(runner_slug=self.runner, game_config_id=self.config_id)
config.raw_game_config.update({
"appid": self.appid,
"exe": self.details["exe"],
"args": self.details["args"]
})
config.raw_system_config.update({"disable_runtime": True})
config.save()
def install(self, installer_path=None):
if installer_path:
self.msi_exec(installer_path, quiet=True)
Gdk.threads_enter()
dlg = DirectoryDialog('Where is Steam.exe installed?')
self.game_path = dlg.folder
Gdk.threads_leave()
config = LutrisConfig(runner='winesteam')
config.runner_config = {'system': {'game_path': self.game_path}}
config.save()
def create_config(self):
"""Create a Lutris config for the current game"""
config = LutrisConfig(runner_slug=self.runner,
game_config_id=self.config_id)
config.raw_game_config.update({
"appid": self.appid,
"exe": self.details["exe"],
"args": self.details["args"]
})
config.raw_system_config.update({"disable_runtime": True})
config.save()
class RunnerConfigDialog(Gtk.Dialog):
"""Runners management dialog."""
def __init__(self, runner):
Gtk.Dialog.__init__(self)
runner_name = runner.__class__.__name__
self.set_title("Configure %s" % runner_name)
self.set_size_request(570, 500)
self.runner_name = runner_name
self.lutris_config = LutrisConfig(runner=runner_name)
# Notebook for choosing between runner and system configuration
self.notebook = Gtk.Notebook()
self.vbox.pack_start(self.notebook, True, True, 0)
# Runner configuration
self.runner_config_vbox = RunnerBox(self.lutris_config, "runner",
self.runner_name)
runner_scrollwindow = Gtk.ScrolledWindow()
runner_scrollwindow.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
runner_scrollwindow.add_with_viewport(self.runner_config_vbox)
self.notebook.append_page(runner_scrollwindow,
Gtk.Label(label="Runner configuration"))
# System configuration
self.system_config_vbox = SystemBox(self.lutris_config, "runner")
system_scrollwindow = Gtk.ScrolledWindow()
system_scrollwindow.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
system_scrollwindow.add_with_viewport(self.system_config_vbox)
self.notebook.append_page(system_scrollwindow,
Gtk.Label(label="System configuration"))
# Action buttons
cancel_button = Gtk.Button("Cancel")
ok_button = Gtk.Button("Ok")
self.action_area.pack_start(cancel_button, True, True, 0)
self.action_area.pack_start(ok_button, True, True, 0)
cancel_button.connect("clicked", self.close)
ok_button.connect("clicked", self.ok_clicked)
self.show_all()
self.run()
def close(self, _widget):
self.destroy()
def ok_clicked(self, _wigdet):
self.lutris_config.config_type = "runner"
self.lutris_config.save()
self.destroy()
class RunnerConfigDialog(Gtk.Dialog):
"""Runners management dialog"""
def __init__(self, runner):
Gtk.Dialog.__init__(self)
runner_name = runner.__class__.__name__
self.set_title("Configure %s" % runner_name)
self.set_size_request(570, 500)
self.runner = runner_name
self.lutris_config = LutrisConfig(runner=runner_name)
#Notebook for choosing between runner and system configuration
self.notebook = Gtk.Notebook()
self.vbox.pack_start(self.notebook, True, True, 0)
#Runner configuration
self.runner_config_vbox = RunnerBox(self.lutris_config, "runner")
runner_scrollwindow = Gtk.ScrolledWindow()
runner_scrollwindow.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
runner_scrollwindow.add_with_viewport(self.runner_config_vbox)
self.notebook.append_page(runner_scrollwindow,
Gtk.Label(label="Runner configuration"))
#System configuration
self.system_config_vbox = SystemBox(self.lutris_config, "runner")
system_scrollwindow = Gtk.ScrolledWindow()
system_scrollwindow.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
system_scrollwindow.add_with_viewport(self.system_config_vbox)
self.notebook.append_page(system_scrollwindow,
Gtk.Label(label="System configuration"))
#Action buttons
cancel_button = Gtk.Button(None, Gtk.STOCK_CANCEL)
ok_button = Gtk.Button(None, Gtk.STOCK_OK)
self.action_area.pack_start(cancel_button, True, True, 0)
self.action_area.pack_start(ok_button, True, True, 0)
cancel_button.connect("clicked", self.close)
ok_button.connect("clicked", self.ok_clicked)
self.show_all()
self.run()
def close(self, _widget):
self.destroy()
def ok_clicked(self, _wigdet):
assert self.lutris_config.config_type == 'runner'
self.lutris_config.config_type = "runner"
self.lutris_config.save()
self.destroy()
class SystemConfigDialog(Dialog, GameDialogCommon):
def __init__(self):
super(SystemConfigDialog, self).__init__("System preferences")
self.set_size_request(500, 500)
self.lutris_config = LutrisConfig()
self.system_config_vbox = SystemBox(self.lutris_config, 'system')
self.vbox.pack_start(self.system_config_vbox, True, True, 0)
self.build_action_area("Save", self.save_config)
self.show_all()
def save_config(self, widget):
self.lutris_config.save()
self.destroy()
class SystemConfigDialog(Dialog, GameDialogCommon):
def __init__(self):
super(SystemConfigDialog, self).__init__("System preferences")
self.set_size_request(500, 500)
self.lutris_config = LutrisConfig()
self.system_config_vbox = SystemBox(self.lutris_config, 'system')
self.vbox.pack_start(self.system_config_vbox, True, True, 0)
self.build_action_area("Save", self.save_config)
self.show_all()
def save_config(self, widget):
self.lutris_config.save()
self.destroy()
class RunnerConfigDialog(GameDialogCommon):
"""Runner config edit dialog."""
def __init__(self, runner, parent=None):
self.runner_name = runner.__class__.__name__
super().__init__(_("Configure %s") % runner.human_name, parent=parent)
self.saved = False
self.lutris_config = LutrisConfig(runner_slug=self.runner_name)
self.build_notebook()
self.build_tabs("runner")
self.build_action_area(self.on_save)
self.show_all()
def on_save(self, wigdet, data=None):
self.lutris_config.save()
self.destroy()
def on_runner_installed(*args):
config_path = system.create_folder("~/.atari800")
bios_archive = os.path.join(config_path, "atari800-bioses.zip")
dlg = DownloadDialog(self.bios_url, bios_archive)
dlg.run()
if not system.path_exists(bios_archive):
ErrorDialog("Could not download Atari800 BIOS archive")
return
extract.extract_archive(bios_archive, config_path)
os.remove(bios_archive)
config = LutrisConfig(runner_slug="atari800")
config.raw_runner_config.update({"bios_path": config_path})
config.save()
if callback:
callback()
def on_runner_installed(*args): # pylint: disable=unused-argument
config_path = system.create_folder("~/.atari800")
bios_archive = os.path.join(config_path, "atari800-bioses.zip")
dlg = DownloadDialog(self.bios_url, bios_archive)
dlg.run()
if not system.path_exists(bios_archive):
ErrorDialog(_("Could not download Atari 800 BIOS archive"))
return
extract.extract_archive(bios_archive, config_path)
os.remove(bios_archive)
config = LutrisConfig(runner_slug="atari800")
config.raw_runner_config.update({"bios_path": config_path})
config.save()
if callback:
callback()
def on_runner_installed(*args):
config_path = system.create_folder("~/.atari800")
bios_archive = os.path.join(config_path, 'atari800-bioses.zip')
dlg = DownloadDialog(self.bios_url, bios_archive)
dlg.run()
if not system.path_exists(bios_archive):
ErrorDialog("Could not download Atari800 BIOS archive")
return
extract.extract_archive(bios_archive, config_path)
os.remove(bios_archive)
config = LutrisConfig(runner_slug='atari800')
config.raw_runner_config.update({'bios_path': config_path})
config.save()
if callback:
callback()
def mark_as_installed(scummvm_id, name, path):
"""Add scummvm from the auto-import"""
logger.info("Setting %s as installed" % name)
slug = slugify(name)
config_id = make_game_config_id(slug)
game_id = pga.add_or_update(name=name,
runner='scummvm',
installer_slug=INSTALLER_SLUG,
slug=slug,
installed=1,
configpath=config_id,
directory=path)
config = LutrisConfig(runner_slug='scummvm', game_config_id=config_id)
config.raw_game_config.update({'game_id': scummvm_id, 'path': path})
config.save()
return game_id
def on_runner_installed(*args):
bios_path = system.create_folder('~/.hatari/bios')
dlg = QuestionDialog({
'question': "Do you want to select an Atari ST BIOS file?",
'title': "Use BIOS file?",
})
if dlg.result == dlg.YES:
bios_dlg = FileDialog("Select a BIOS file")
bios_filename = bios_dlg.filename
if not bios_filename:
return
shutil.copy(bios_filename, bios_path)
bios_path = os.path.join(bios_path, os.path.basename(bios_filename))
config = LutrisConfig(runner_slug='hatari')
config.raw_runner_config.update({'bios_file': bios_path})
config.save()
if callback:
callback()
class SystemConfigDialog(Dialog, GameDialogCommon):
def __init__(self, parent=None):
super().__init__("System preferences", parent=parent)
self.game = None
self.runner_name = None
self.lutris_config = LutrisConfig()
self.set_default_size(DIALOG_WIDTH, DIALOG_HEIGHT)
self.build_notebook()
self.build_tabs("system")
self.build_action_area(self.on_save)
self.show_all()
def on_save(self, _widget):
self.lutris_config.save()
self.destroy()
def install(self):
success = super(atari800, self).install()
if not success:
return False
config_path = os.path.expanduser("~/.atari800")
if not os.path.exists(config_path):
os.makedirs(config_path)
bios_archive = os.path.join(config_path, 'atari800-bioses.zip')
dlg = DownloadDialog(self.bios_url, bios_archive)
dlg.run()
if not os.path.exists(bios_archive):
ErrorDialog("Could not download Atari800 BIOS archive")
return
extract.extract_archive(bios_archive, config_path)
os.remove(bios_archive)
config = LutrisConfig(runner_slug='atari800')
config.raw_runner_config.update({'bios_path': config_path})
config.save()
def mark_as_installed(scummvm_id, name, path):
"""Add scummvm from the auto-import"""
logger.info("Setting %s as installed", name)
slug = slugify(name)
config_id = make_game_config_id(slug)
game_id = pga.add_or_update(
name=name,
runner="scummvm",
installer_slug=INSTALLER_SLUG,
slug=slug,
installed=1,
configpath=config_id,
directory=path,
)
config = LutrisConfig(runner_slug="scummvm", game_config_id=config_id)
config.raw_game_config.update({"game_id": scummvm_id, "path": path})
config.save()
return game_id
def write_config(self, _id, name, fullpath):
"""Write game configuration to settings directory."""
system = self.__class__.__name__
index = fullpath.rindex("/")
exe = fullpath[index + 1:]
path = fullpath[:index]
if path.startswith("file://"):
path = path[7:]
config = LutrisConfig()
config.config = {
"main": {
"path": path,
"exe": exe,
"realname": name,
"runner": system
}
}
config.save(config_type="game")
class SystemConfigDialog(Gtk.Dialog, GameDialogCommon):
title = "System preferences"
dialog_height = 500
def __init__(self):
super(SystemConfigDialog, self).__init__()
self.set_title(self.title)
self.set_size_request(500, self.dialog_height)
self.lutris_config = LutrisConfig()
self.system_config_vbox = SystemBox(self.lutris_config, 'system')
self.vbox.pack_start(self.system_config_vbox, True, True, 0)
self.build_action_area("Save", self.save_config)
self.show_all()
def save_config(self, widget):
assert self.lutris_config.config_type == 'system'
self.lutris_config.save()
self.destroy()
class SystemConfigDialog(Gtk.Dialog, GameDialogCommon):
title = "System preferences"
dialog_height = 500
def __init__(self):
super(SystemConfigDialog, self).__init__()
self.set_title(self.title)
self.set_size_request(500, self.dialog_height)
self.lutris_config = LutrisConfig()
self.system_config_vbox = SystemBox(self.lutris_config, 'system')
self.vbox.pack_start(self.system_config_vbox, True, True, 0)
self.build_action_area("Save", self.save_config)
self.show_all()
def save_config(self, widget):
assert self.lutris_config.config_type == 'system'
self.lutris_config.save()
self.destroy()
class SystemConfigDialog(Dialog, GameDialogCommon):
def __init__(self, parent=None):
super().__init__("System preferences", parent=parent)
self.game = None
self.runner_name = None
self.lutris_config = LutrisConfig()
self.set_default_size(DIALOG_WIDTH, DIALOG_HEIGHT)
self.system_box = SystemBox(self.lutris_config)
self.system_sw = self.build_scrolled_window(self.system_box)
self.vbox.pack_start(self.system_sw, True, True, 0)
self.build_action_area(self.on_save)
self.show_all()
def on_save(self, widget):
self.lutris_config.save()
self.destroy()
def install(self):
success = super(atari800, self).install()
if not success:
return False
config_path = os.path.expanduser("~/.atari800")
if not os.path.exists(config_path):
os.makedirs(config_path)
bios_archive = os.path.join(config_path, 'atari800-bioses.zip')
dlg = DownloadDialog(self.bios_url, bios_archive)
dlg.run()
if not os.path.exists(bios_archive):
ErrorDialog("Could not download Atari800 BIOS archive")
return
extract_archive(bios_archive, config_path)
os.remove(bios_archive)
runner_config = LutrisConfig(runner='atari800')
runner_config.config_type = 'runner'
runner_config.runner_config = {'atari800': {'bios_path': config_path}}
runner_config.save()
class SystemConfigDialog(Dialog, GameDialogCommon):
def __init__(self):
super(SystemConfigDialog, self).__init__("System preferences")
self.game = None
self.runner_name = None
self.lutris_config = LutrisConfig()
self.set_default_size(DIALOG_WIDTH, DIALOG_HEIGHT)
self.system_box = SystemBox(self.lutris_config)
self.system_sw = self.build_scrolled_window(self.system_box)
self.vbox.pack_start(self.system_sw, True, True, 0)
self.build_action_area("Save", self.save_config)
self.show_all()
def save_config(self, widget):
self.lutris_config.save()
self.destroy()
def on_runner_installed(*args):
bios_path = system.create_folder('~/.hatari/bios')
dlg = QuestionDialog({
'question': "Do you want to select an Atari ST BIOS file?",
'title': "Use BIOS file?",
})
if dlg.result == dlg.YES:
bios_dlg = FileDialog("Select a BIOS file")
bios_filename = bios_dlg.filename
if not bios_filename:
return
shutil.copy(bios_filename, bios_path)
bios_path = os.path.join(bios_path,
os.path.basename(bios_filename))
config = LutrisConfig(runner_slug='hatari')
config.raw_runner_config.update({'bios_file': bios_path})
config.save()
if callback:
callback()
def migrate():
games = pga.get_games(filter_installed=True)
for game_info in games:
if game_info["runner"] != "steam" or game_info["configpath"]:
continue
slug = game_info["slug"]
config_id = make_game_config_id(slug)
# Add configpath to db
pga.add_or_update(name=game_info["name"],
runner="steam",
slug=slug,
configpath=config_id)
# Add appid to config
game_config = LutrisConfig(runner_slug="steam",
game_config_id=config_id)
game_config.raw_game_config.update(
{"appid": str(game_info["steamid"])})
game_config.save()
def mark_as_installed(steamid, runner_name, game_info):
for key in ['name', 'slug']:
assert game_info[key]
logger.info("Setting %s as installed" % game_info['name'])
config_id = (game_info.get('config_path') or make_game_config_id(game_info['slug']))
game_id = pga.add_or_update(
steamid=int(steamid),
name=game_info['name'],
runner=runner_name,
slug=game_info['slug'],
installed=1,
configpath=config_id,
)
game_config = LutrisConfig(
runner_slug=runner_name,
game_config_id=config_id,
)
game_config.raw_game_config.update({'appid': steamid})
game_config.save()
return game_id
def mark_as_installed(steamid, runner_name, game_info):
for key in ['name', 'slug']:
assert game_info[key]
logger.info("Setting %s as installed" % game_info['name'])
config_id = (game_info.get('config_path') or make_game_config_id(game_info['slug']))
game_id = pga.add_or_update(
steamid=int(steamid),
name=game_info['name'],
runner=runner_name,
slug=game_info['slug'],
installed=1,
configpath=config_id,
)
game_config = LutrisConfig(
runner_slug=runner_name,
game_config_id=config_id,
)
game_config.raw_game_config.update({'appid': steamid})
game_config.save()
return game_id
class RunnerConfigDialog(Dialog, GameDialogCommon):
"""Runner config edit dialog."""
def __init__(self, runner, parent=None):
self.runner_name = runner.__class__.__name__
super().__init__("Configure %s" % runner.human_name, parent=parent)
self.game = None
self.saved = False
self.lutris_config = LutrisConfig(runner_slug=self.runner_name)
self.set_default_size(DIALOG_WIDTH, DIALOG_HEIGHT)
self.build_notebook()
self.build_tabs("runner")
self.build_action_area(self.on_save)
self.show_all()
def on_save(self, wigdet, data=None):
self.lutris_config.save()
self.destroy()
class RunnerConfigDialog(Dialog, GameDialogCommon):
"""Runner config edit dialog."""
def __init__(self, runner, parent=None):
self.runner_name = runner.__class__.__name__
super(RunnerConfigDialog,
self).__init__("Configure %s" % self.runner_name, parent=parent)
self.game = None
self.saved = False
self.lutris_config = LutrisConfig(runner_slug=self.runner_name)
self.set_default_size(DIALOG_WIDTH, DIALOG_HEIGHT)
self.build_notebook()
self.build_tabs('runner')
self.build_action_area(self.on_save)
self.show_all()
def on_save(self, wigdet, data=None):
self.lutris_config.save()
self.destroy()
class RunnerConfigDialog(Dialog, GameDialogCommon):
"""Runners management dialog."""
def __init__(self, runner):
self.runner_name = runner.__class__.__name__
super(RunnerConfigDialog, self).__init__(
"Configure %s" % self.runner_name
)
self.game = None
self.saved = False
self.lutris_config = LutrisConfig(runner_slug=self.runner_name)
self.set_default_size(DIALOG_WIDTH, DIALOG_HEIGHT)
self.build_notebook()
self.build_tabs('runner')
self.build_action_area("Edit", self.ok_clicked)
self.show_all()
def ok_clicked(self, _wigdet):
self.lutris_config.save()
self.destroy()
def on_runner_installed(*args):
bios_path = system.create_folder('~/.pcsxr/bios')
dlg = QuestionDialog({
'question': ("Do you want to select a Playstation BIOS file?\n\n"
"The BIOS is the core code running the machine.\n"
"PCSX-Reloaded includes an emulated BIOS, but it is "
"still incomplete. \n"
"Using an original BIOS avoids some bugs and reduced "
"compatibility \n"
"with some games."),
'title': "Use BIOS file?",
})
if dlg.result == dlg.YES:
bios_dlg = FileDialog("Select a BIOS file")
bios_src = bios_dlg.filename
shutil.copy(bios_src, bios_path)
# Save bios in config
bios_path = os.path.join(bios_path, os.path.basename(bios_src))
config = LutrisConfig(runner_slug='pcsxr')
config.raw_runner_config.update({'bios': bios_path})
config.save()
if callback:
callback()
class AddGameDialog(Gtk.Dialog, GameDialogCommon):
""" Add game dialog class"""
def __init__(self, parent, game=None):
super(AddGameDialog, self).__init__()
self.parent_window = parent
self.lutris_config = LutrisConfig()
self.runner_name = None
self.set_title("Add a new game")
self.set_size_request(600, 500)
if game:
name = game.name
self.slug = game.slug
else:
name = None
self.slug = None
self.build_name_entry(name)
self.build_runner_dropdown()
self.build_notebook()
self.build_game_tab()
self.build_runner_tab()
self.build_system_tab()
self.build_action_area(Gtk.STOCK_ADD, self.save_game)
self.show_all()
self.run()
def save_game(self, _button):
""" OK button pressed in the Add Game Dialog """
name = self.name_entry.get_text()
self.lutris_config.config["realname"] = name
self.lutris_config.config["runner"] = self.runner_name
if self.runner_name and name:
self.slug = self.lutris_config.save(config_type="game")
runner_class = lutris.runners.import_runner(self.runner_name)
runner = runner_class(self.lutris_config)
pga.add_or_update(name, self.runner_name, slug=self.slug,
directory=runner.get_game_path(), installed=1)
self.destroy()
def on_runner_changed(self, widget):
"""Action called when runner drop down is changed"""
runner_index = widget.get_active()
current_page = self.notebook.get_current_page()
self.clear_tabs()
if runner_index == 0:
self.runner_name = None
self.lutris_config = LutrisConfig()
else:
self.runner_name = widget.get_model()[runner_index][1]
self.lutris_config = LutrisConfig(self.runner_name)
self.build_game_tab()
self.build_runner_tab()
self.build_system_tab()
self.notebook.set_current_page(current_page)
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>")
class Game(GObject.Object):
"""This class takes cares of loading the configuration for a game
and running it.
"""
STATE_IDLE = "idle"
STATE_STOPPED = "stopped"
STATE_RUNNING = "running"
__gsignals__ = {
"game-error": (GObject.SIGNAL_RUN_FIRST, None, (str, )),
"game-start": (GObject.SIGNAL_RUN_FIRST, None, ()),
"game-started": (GObject.SIGNAL_RUN_FIRST, None, ()),
"game-stop": (GObject.SIGNAL_RUN_FIRST, None, ()),
"game-stopped": (GObject.SIGNAL_RUN_FIRST, None, (int, )),
"game-removed": (GObject.SIGNAL_RUN_FIRST, None, ()),
"game-updated": (GObject.SIGNAL_RUN_FIRST, None, ()),
"game-installed": (GObject.SIGNAL_RUN_FIRST, None, ()),
}
def __init__(self, game_id=None):
super().__init__()
self.id = game_id # pylint: disable=invalid-name
self.runner = None
self.config = None
# Load attributes from database
game_data = pga.get_game_by_field(game_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.game_config_id = game_data.get("configpath") or ""
self.is_installed = bool(
game_data.get("installed") and self.game_config_id)
self.platform = game_data.get("platform") or ""
self.year = game_data.get("year") or ""
self.lastplayed = game_data.get("lastplayed") or 0
self.steamid = game_data.get("steamid") or ""
self.has_custom_banner = bool(game_data.get("has_custom_banner"))
self.has_custom_icon = bool(game_data.get("has_custom_icon"))
self.discord_presence = DiscordPresence()
try:
self.playtime = float(game_data.get("playtime") or 0.0)
except ValueError:
logger.error("Invalid playtime value %s",
game_data.get("playtime"))
self.playtime = 0.0
if self.game_config_id:
self.load_config()
self.game_thread = None
self.prelaunch_executor = None
self.heartbeat = None
self.killswitch = None
self.state = self.STATE_IDLE
self.game_runtime_config = {}
self.resolution_changed = False
self.compositor_disabled = False
self.original_outputs = None
self._log_buffer = None
self.timer = Timer()
self.screen_saver_inhibitor_cookie = None
def __repr__(self):
return self.__str__()
def __str__(self):
value = self.name
if self.runner_name:
value += " (%s)" % self.runner_name
return value
@property
def log_buffer(self):
"""Access the log buffer object, creating it if necessary"""
if self._log_buffer is None:
self._log_buffer = Gtk.TextBuffer()
self._log_buffer.create_tag("warning", foreground="red")
if self.game_thread:
self.game_thread.set_log_buffer(self._log_buffer)
self._log_buffer.set_text(self.game_thread.stdout)
return self._log_buffer
@property
def formatted_playtime(self):
"""Return a human readable formatted play time"""
return strings.get_formatted_playtime(self.playtime)
@property
def is_search_result(self):
"""Return whether or not the game is a remote game from search results.
This is bad, find another way to do this.
"""
return self.id < 0
@staticmethod
def show_error_message(message):
"""Display an error message based on the runner's output."""
if message["error"] == "CUSTOM":
message_text = message["text"].replace("&", "&")
dialogs.ErrorDialog(message_text)
elif message["error"] == "RUNNER_NOT_INSTALLED":
dialogs.ErrorDialog(_("Error the runner is not installed"))
elif message["error"] == "NO_BIOS":
dialogs.ErrorDialog(_("A bios file is required to run this game"))
elif message["error"] == "FILE_NOT_FOUND":
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 message["error"] == "NOT_EXECUTABLE":
message_text = message["file"].replace("&", "&")
dialogs.ErrorDialog(
_("The file %s is not executable") % message_text)
elif message["error"] == "PATH_NOT_SET":
message_text = _(
"The path '%s' is not set. please set it in the options."
) % message["path"]
dialogs.ErrorDialog(message_text)
else:
dialogs.ErrorDialog(_("Unhandled error: %s") % message["error"])
def get_browse_dir(self):
"""Return the path to open with the Browse Files action."""
return self.runner.game_path
def _get_runner(self):
"""Return the runner instance for this game's configuration"""
try:
runner_class = import_runner(self.runner_name)
return runner_class(self.config)
except InvalidRunner:
logger.error("Unable to import runner %s for %s", self.runner_name,
self.slug)
def load_config(self):
"""Load the game's configuration."""
if not self.is_installed:
return
self.config = LutrisConfig(runner_slug=self.runner_name,
game_config_id=self.game_config_id)
self.runner = self._get_runner()
if self.discord_presence.available:
self.discord_presence.client_id = (
self.config.system_config.get("discord_client_id")
or DEFAULT_DISCORD_CLIENT_ID)
self.discord_presence.game_name = (
self.config.system_config.get("discord_custom_game_name")
or self.name)
self.discord_presence.show_runner = self.config.system_config.get(
"discord_show_runner", True)
self.discord_presence.runner_name = (
self.config.system_config.get("discord_custom_runner_name")
or self.runner_name)
self.discord_presence.rpc_enabled = self.config.system_config.get(
"discord_rpc_enabled", True)
def set_desktop_compositing(self, enable):
"""Enables or disables compositing"""
if enable:
if self.compositor_disabled:
enable_compositing()
self.compositor_disabled = False
else:
if not self.compositor_disabled:
disable_compositing()
self.compositor_disabled = True
def remove(self, from_library=False, from_disk=False):
"""Uninstall a game
Params:
from_library (bool): Completely remove the game from library, do
not set it as uninstalled
from_disk (bool): Delete the game files
Return:
bool: Updated value for from_library
"""
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)
if self.config:
self.config.remove()
xdgshortcuts.remove_launcher(self.slug,
self.id,
desktop=True,
menu=True)
self.is_installed = False
self.emit("game-removed")
return from_library
def set_platform_from_runner(self):
"""Set the game's platform from the runner"""
if not self.runner:
logger.warning("Game has no runner, can't set platform")
return
self.platform = self.runner.get_platform()
if not self.platform:
logger.warning("Can't get platform for runner %s",
self.runner.human_name)
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.
"""
logger.debug("Saving %s", self)
if not metadata_only:
self.config.save()
self.set_platform_from_runner()
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,
playtime=self.playtime,
)
self.emit("game-updated")
def is_launchable(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: %s",
runtime_updater.current_updates)
dialogs.ErrorDialog(_("Runtime currently updating"),
_("Game might not work as expected"))
if ("wine" in self.runner_name and not wine.get_system_wine_version()
and not LINUX_SYSTEM.is_flatpak):
# TODO find a reference to the root window or better yet a way not
# to have Gtk dependent code in this class.
root_window = None
dialogs.WineNotInstalledWarning(parent=root_window)
return True
def play(self):
"""Launch the game."""
if not self.runner:
dialogs.ErrorDialog(
_("Invalid game configuration: Missing runner"))
self.state = self.STATE_STOPPED
self.emit("game-stop")
return
if not self.is_launchable():
self.state = self.STATE_STOPPED
self.emit("game-stop")
return
self.emit("game-start")
jobs.AsyncCall(self.runner.prelaunch, self.configure_game)
def restrict_to_display(self, display):
outputs = DISPLAY_MANAGER.get_config()
if display == "primary":
display = None
for output in outputs:
if output.primary:
display = output.name
break
if not display:
logger.warning("No primary display set")
else:
found = False
for output in outputs:
if output.name == display:
found = True
break
if not found:
logger.warning("Selected display %s not found", display)
display = None
if display:
turn_off_except(display)
time.sleep(3)
return True
return False
def get_launch_parameters(self, gameplay_info):
system_config = self.runner.system_config
launch_arguments = gameplay_info["command"]
optimus = system_config.get("optimus")
if optimus == "primusrun" and system.find_executable("primusrun"):
launch_arguments.insert(0, "primusrun")
elif optimus == "optirun" and system.find_executable("optirun"):
launch_arguments.insert(0, "virtualgl")
launch_arguments.insert(0, "-b")
launch_arguments.insert(0, "optirun")
elif optimus == "pvkrun" and system.find_executable("pvkrun"):
launch_arguments.insert(0, "pvkrun")
# Mangohud activation
mangohud = system_config.get("mangohud") or ""
if mangohud and system.find_executable("mangohud"):
# This is probably not the way to go. This only work with a few
# Wine games. It will probably crash it, or do nothing at all.
# I have never got mangohud to work on anything other than a Wine
# game.
dialogs.NoticeDialog(
"MangoHud support is experimental. Expect the "
"game to crash or the framerate counter not to "
"appear at all.")
launch_arguments = ["mangohud"] + launch_arguments
fps_limit = system_config.get("fps_limit") or ""
if fps_limit:
strangle_cmd = system.find_executable("strangle")
if strangle_cmd:
launch_arguments = [strangle_cmd, fps_limit] + launch_arguments
else:
logger.warning(
"libstrangle is not available on this system, FPS limiter disabled"
)
prefix_command = system_config.get("prefix_command") or ""
if prefix_command:
launch_arguments = (
shlex.split(os.path.expandvars(prefix_command)) +
launch_arguments)
single_cpu = system_config.get("single_cpu") or False
if single_cpu:
logger.info("The game will run on a single CPU core")
launch_arguments.insert(0, "0")
launch_arguments.insert(0, "-c")
launch_arguments.insert(0, "taskset")
env = {}
env.update(self.runner.get_env())
env.update(gameplay_info.get("env") or {})
env["game_name"] = self.name
# Set environment variables dependent on gameplay info
# LD_PRELOAD
ld_preload = gameplay_info.get("ld_preload")
if ld_preload:
env["LD_PRELOAD"] = ld_preload
# LD_LIBRARY_PATH
game_ld_libary_path = gameplay_info.get("ld_library_path")
if game_ld_libary_path:
ld_library_path = env.get("LD_LIBRARY_PATH")
if not ld_library_path:
ld_library_path = "$LD_LIBRARY_PATH"
env["LD_LIBRARY_PATH"] = ":".join(
[game_ld_libary_path, ld_library_path])
# Feral gamemode
gamemode = system_config.get(
"gamemode") and LINUX_SYSTEM.gamemode_available()
if gamemode:
if system.find_executable("gamemoderun"):
launch_arguments.insert(0, "gamemoderun")
else:
env["LD_PRELOAD"] = ":".join([
path for path in [
env.get("LD_PRELOAD"),
"libgamemodeauto.so",
] if path
])
return launch_arguments, env
def start_xephyr(self, display=":2"):
"""Start a monitored Xephyr instance"""
if not system.find_executable("Xephyr"):
raise GameConfigError(
"Unable to find Xephyr, install it or disable the Xephyr option"
)
xephyr_depth = "8" if self.runner.system_config.get(
"xephyr") == "8bpp" else "16"
xephyr_resolution = self.runner.system_config.get(
"xephyr_resolution") or "640x480"
xephyr_command = [
"Xephyr",
display,
"-ac",
"-screen",
xephyr_resolution + "x" + xephyr_depth,
"-glamor",
"-reset",
"-terminate",
]
if self.runner.system_config.get("xephyr_fullscreen"):
xephyr_command.append("-fullscreen")
xephyr_thread = MonitoredCommand(xephyr_command)
xephyr_thread.start()
time.sleep(3)
return display
@staticmethod
def set_keyboard_layout(layout):
setxkbmap_command = ["setxkbmap", "-model", "pc101", layout, "-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()
def start_prelaunch_command(self):
"""Start the prelaunch command specified in the system options"""
prelaunch_command = self.runner.system_config.get("prelaunch_command")
command_array = shlex.split(prelaunch_command)
if not system.path_exists(command_array[0]):
logger.warning("Command %s not found", command_array[0])
return
self.prelaunch_executor = MonitoredCommand(
command_array,
include_processes=[os.path.basename(command_array[0])],
env=self.game_runtime_config["env"],
cwd=self.directory,
)
self.prelaunch_executor.start()
logger.info("Running %s in the background", prelaunch_command)
def get_terminal(self):
"""Return the terminal used to run the game into or None if the game is not run from a terminal.
Remember that only games using text mode should use the terminal.
"""
if self.runner.system_config.get("terminal"):
terminal = self.runner.system_config.get(
"terminal_app", system.get_default_terminal())
if terminal and not system.find_executable(terminal):
raise GameConfigError(
_("The selected terminal application could not be launched:\n%s"
) % terminal)
return terminal
def get_killswitch(self):
"""Return the path to a file that is monitored during game execution.
If the file stops existing, the game is stopped.
"""
killswitch = self.runner.system_config.get("killswitch")
# Prevent setting a killswitch to a file that doesn't exists
if killswitch and system.path_exists(self.killswitch):
return killswitch
def get_gameplay_info(self):
"""Return the information provided by a runner's play method.
Checks for possible errors.
"""
gameplay_info = self.runner.play()
if "error" in gameplay_info:
self.show_error_message(gameplay_info)
self.state = self.STATE_STOPPED
self.emit("game-stop")
return
return gameplay_info
@watch_lutris_errors
def configure_game(self, prelaunched, error=None): # noqa: C901
"""Get the game ready to start, applying all the options
This methods sets the game_runtime_config attribute.
"""
if error:
logger.error(error)
dialogs.ErrorDialog(str(error))
if not prelaunched:
logger.error("Game prelaunch unsuccessful")
dialogs.ErrorDialog(_("An error prevented the game from running"))
self.state = self.STATE_STOPPED
self.emit("game-stop")
return
gameplay_info = self.get_gameplay_info()
if not gameplay_info:
return
command, env = self.get_launch_parameters(gameplay_info)
self.game_runtime_config = {
"args":
command,
"env":
env,
"terminal":
self.get_terminal(),
"include_processes":
shlex.split(self.runner.system_config.get("include_processes",
"")),
"exclude_processes":
shlex.split(self.runner.system_config.get("exclude_processes",
"")),
}
# Audio control
if self.runner.system_config.get("reset_pulse"):
audio.reset_pulse()
# Input control
if self.runner.system_config.get("use_us_layout"):
self.set_keyboard_layout("us")
# Display control
self.original_outputs = DISPLAY_MANAGER.get_config()
if self.runner.system_config.get("disable_compositor"):
self.set_desktop_compositing(False)
if self.runner.system_config.get("disable_screen_saver"):
self.screen_saver_inhibitor_cookie = SCREEN_SAVER_INHIBITOR.inhibit(
self.name)
if self.runner.system_config.get("display") != "off":
self.resolution_changed = self.restrict_to_display(
self.runner.system_config.get("display"))
resolution = self.runner.system_config.get("resolution")
if resolution != "off":
DISPLAY_MANAGER.set_resolution(resolution)
time.sleep(3)
self.resolution_changed = True
xephyr = self.runner.system_config.get("xephyr") or "off"
if xephyr != "off":
env["DISPLAY"] = self.start_xephyr()
# Execution control
self.killswitch = self.get_killswitch()
if self.runner.system_config.get("prelaunch_command"):
self.start_prelaunch_command()
if self.runner.system_config.get("prelaunch_wait"):
# Monitor the prelaunch command and wait until it has finished
self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY,
self.prelaunch_beat)
else:
self.start_game()
def start_game(self):
"""Run a background command to lauch the game"""
self.game_thread = MonitoredCommand(
self.game_runtime_config["args"],
title=self.name,
runner=self.runner,
env=self.game_runtime_config["env"],
term=self.game_runtime_config["terminal"],
log_buffer=self._log_buffer,
include_processes=self.game_runtime_config["include_processes"],
exclude_processes=self.game_runtime_config["exclude_processes"],
)
if hasattr(self.runner, "stop"):
self.game_thread.stop_func = self.runner.stop
self.game_thread.start()
self.timer.start()
self.emit("game-started")
self.state = self.STATE_RUNNING
self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat)
def stop_game(self):
"""Cleanup after a game as stopped"""
self.state = self.STATE_STOPPED
self.emit("game-stop")
if not self.timer.finished:
self.timer.end()
self.playtime += self.timer.duration / 3600
def prelaunch_beat(self):
"""Watch the prelaunch command"""
if self.prelaunch_executor and self.prelaunch_executor.is_running:
return True
self.start_game()
return False
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 system.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
if self.discord_presence.available:
self.discord_presence.update_discord_rich_presence()
return True
def stop(self):
"""Stops the game"""
if self.state == self.STATE_STOPPED:
logger.debug("Game already stopped")
return
logger.info("Stopping %s", self)
if self.game_thread:
jobs.AsyncCall(self.game_thread.stop, None)
self.stop_game()
def on_game_quit(self):
"""Restore some settings and cleanup after game quit."""
if self.prelaunch_executor and self.prelaunch_executor.is_running:
logger.info("Stopping prelaunch script")
self.prelaunch_executor.stop()
self.heartbeat = None
if self.state != self.STATE_STOPPED:
logger.warning("Game still running (state: %s)", self.state)
self.stop()
# Check for post game script
postexit_command = self.runner.system_config.get("postexit_command")
if postexit_command:
command_array = shlex.split(postexit_command)
if system.path_exists(command_array[0]):
logger.info("Running post-exit command: %s", postexit_command)
postexit_thread = MonitoredCommand(
command_array,
include_processes=[os.path.basename(postexit_command)],
env=self.game_runtime_config["env"],
cwd=self.directory,
)
postexit_thread.start()
if self.discord_presence.available:
self.discord_presence.clear_discord_rich_presence()
quit_time = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime())
logger.debug("%s stopped at %s", self.name, quit_time)
self.lastplayed = int(time.time())
self.save(metadata_only=True)
os.chdir(os.path.expanduser("~"))
if self.resolution_changed or self.runner.system_config.get(
"reset_desktop"):
DISPLAY_MANAGER.set_resolution(self.original_outputs)
if self.compositor_disabled:
self.set_desktop_compositing(True)
if self.screen_saver_inhibitor_cookie is not None:
SCREEN_SAVER_INHIBITOR.uninhibit(
self.screen_saver_inhibitor_cookie)
self.screen_saver_inhibitor_cookie = None
if self.runner.system_config.get("use_us_layout"):
subprocess.Popen(["setxkbmap"], env=os.environ).communicate()
if self.runner.system_config.get("restore_gamma"):
restore_gamma()
self.process_return_codes()
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 not self.game_thread:
return
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
def write_script(self, script_path):
"""Output the launch argument in a bash script"""
gameplay_info = self.get_gameplay_info()
if not gameplay_info:
return
command, env = self.get_launch_parameters(gameplay_info)
# Override TERM otherwise the script might not run
env["TERM"] = "xterm"
script_content = "#!/bin/bash\n\n\n"
script_content += "# Environment variables\n\n"
for env_var in env:
script_content += "export %s=\"%s\"\n" % (env_var, env[env_var])
script_content += "\n\n# Command\n\n"
script_content += shlex.join(command)
with open(script_path, "w") as script_file:
script_file.write(script_content)
os.chmod(script_path, os.stat(script_path).st_mode | stat.S_IEXEC)
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 EditGameConfigDialog(Gtk.Dialog):
"""Game config edit dialog"""
def __init__(self, parent, game):
super(EditGameConfigDialog, self).__init__()
self.parent_window = parent
self.game = game
self.lutris_config = LutrisConfig(game=game)
game_name = self.lutris_config.config["realname"]
self.set_title("Edit game configuration for %s" % game_name)
self.set_size_request(500, 500)
#Notebook
config_notebook = Gtk.Notebook()
self.vbox.pack_start(config_notebook, True, True, 0)
#Game configuration tab
self.game_config_vbox = GameConfigVBox(self.lutris_config, "game")
game_config_scrolled_window = Gtk.ScrolledWindow()
game_config_scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
game_config_scrolled_window.add_with_viewport(self.game_config_vbox)
config_notebook.append_page(game_config_scrolled_window,
Gtk.Label(label="Game Configuration"))
#Runner configuration tab
self.runner_config_box = RunnerConfigVBox(self.lutris_config, "game")
runner_config_scrolled_window = Gtk.ScrolledWindow()
runner_config_scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
runner_config_scrolled_window.add_with_viewport(self.runner_config_box)
config_notebook.append_page(runner_config_scrolled_window,
Gtk.Label(label="Runner Configuration"))
#System configuration tab
self.system_config_box = SystemConfigVBox(self.lutris_config, "game")
system_config_scrolled_window = Gtk.ScrolledWindow()
system_config_scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
system_config_scrolled_window.add_with_viewport(self.system_config_box)
config_notebook.append_page(system_config_scrolled_window,
Gtk.Label(label="System Configuration"))
#Action Area
cancel_button = Gtk.Button(None, Gtk.STOCK_CANCEL)
add_button = Gtk.Button(None, Gtk.STOCK_EDIT)
self.action_area.pack_start(cancel_button, True, True, 0)
self.action_area.pack_start(add_button, True, True, 0)
cancel_button.connect("clicked", self.close)
add_button.connect("clicked", self.edit_game)
self.show_all()
self.run()
def edit_game(self, _widget=None):
"""Save the changes"""
logger.debug(self.lutris_config.config)
self.lutris_config.save(config_type="game")
self.destroy()
def close(self, _widget=None):
"""Dialog destroy callback"""
self.destroy()
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 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()
def create_config(self):
"""Create the game configuration for a Steam game"""
game_config = LutrisConfig(runner_slug=self.runner, game_config_id=self.config_id)
game_config.raw_game_config.update({"appid": self.appid})
game_config.save()
class GameDialogCommon(object):
no_runner_label = "Select a runner from the list"
@staticmethod
def get_runner_liststore():
"""Build a ListStore with available runners."""
runner_liststore = Gtk.ListStore(str, str)
runner_liststore.append(("Select a runner from the list", ""))
for runner_name in runners.__all__:
runner_class = runners.import_runner(runner_name)
runner = runner_class()
if runner.is_installed():
description = runner.description
runner_liststore.append(
("%s (%s)" % (runner_name, description), runner_name)
)
return runner_liststore
def build_entry_box(self, entry, label_text=None):
box = Gtk.HBox()
if label_text:
label = Gtk.Label(label=label_text)
box.pack_start(label, False, False, 20)
box.pack_start(entry, True, True, 20)
return box
def get_runner_dropdown(self):
runner_liststore = self.get_runner_liststore()
self.runner_dropdown = Gtk.ComboBox.new_with_model(runner_liststore)
runner_index = 0
if self.game:
for runner in runner_liststore:
if self.runner_name == str(runner[1]):
break
runner_index += 1
self.runner_dropdown.set_active(runner_index)
self.runner_dropdown.connect("changed", self.on_runner_changed)
cell = Gtk.CellRendererText()
cell.props.ellipsize = Pango.EllipsizeMode.END
self.runner_dropdown.pack_start(cell, True)
self.runner_dropdown.add_attribute(cell, 'text', 0)
return self.runner_dropdown
@staticmethod
def build_scrolled_window(widget):
scrolled_window = Gtk.ScrolledWindow()
scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
scrolled_window.add_with_viewport(widget)
return scrolled_window
def build_notebook(self):
self.notebook = Gtk.Notebook()
self.vbox.pack_start(self.notebook, True, True, 10)
def add_notebook_tab(self, widget, label):
self.notebook.append_page(widget, Gtk.Label(label=label))
def build_info_tab(self):
info_box = VBox()
self.name_entry = Gtk.Entry()
if self.game:
self.name_entry.set_text(self.game.name)
name_box = self.build_entry_box(self.name_entry, "Name")
info_box.pack_start(name_box, False, False, 5)
if self.game:
self.slug_entry = Gtk.Entry()
self.slug_entry.set_text(self.game.slug)
self.slug_entry.set_sensitive(False)
slug_box = self.build_entry_box(self.slug_entry, "Identifier")
info_box.pack_start(slug_box, False, False, 5)
runner_box = Gtk.HBox()
label = Gtk.Label("Runner")
label.set_alignment(0.5, 0.5)
runner_dropdown = self.get_runner_dropdown()
runner_box.pack_start(label, False, False, 20)
runner_box.pack_start(runner_dropdown, False, False, 20)
info_box.pack_start(runner_box, False, False, 5)
info_sw = self.build_scrolled_window(info_box)
self.add_notebook_tab(info_sw, "Game info")
def build_game_tab(self):
if self.game and self.runner_name:
self.game.runner_name = self.runner_name
self.game_box = GameBox(self.lutris_config, self.game)
game_sw = self.build_scrolled_window(self.game_box)
elif self.runner_name:
game = Game(None)
game.runner_name = self.runner_name
self.game_box = GameBox(self.lutris_config, game)
game_sw = self.build_scrolled_window(self.game_box)
else:
game_sw = Gtk.Label(label=self.no_runner_label)
self.add_notebook_tab(game_sw, "Game options")
def build_runner_tab(self, config_level):
if self.runner_name:
self.runner_box = RunnerBox(self.lutris_config)
runner_sw = self.build_scrolled_window(self.runner_box)
else:
runner_sw = Gtk.Label(label=self.no_runner_label)
self.add_notebook_tab(runner_sw, "Runner options")
def build_system_tab(self, config_level):
self.system_box = SystemBox(self.lutris_config)
self.system_sw = self.build_scrolled_window(self.system_box)
self.add_notebook_tab(self.system_sw, "System options")
def build_tabs(self, config_level):
if config_level == 'game':
self.build_info_tab()
self.build_game_tab()
self.build_runner_tab(config_level)
self.build_system_tab(config_level)
def rebuild_tabs(self):
for i in range(self.notebook.get_n_pages(), 1, -1):
self.notebook.remove_page(i - 1)
self.build_game_tab()
self.build_runner_tab('game')
self.build_system_tab('game')
self.show_all()
def build_action_area(self, label, button_callback):
self.action_area.set_layout(Gtk.ButtonBoxStyle.EDGE)
# Advanced settings checkbox
checkbox = Gtk.CheckButton(label="Show advanced options")
value = settings.read_setting('show_advanced_options')
if value == 'True':
checkbox.set_active(value)
checkbox.connect("toggled", self.on_show_advanced_options_toggled)
self.action_area.pack_start(checkbox, False, False, 5)
# Buttons
hbox = Gtk.HBox()
cancel_button = Gtk.Button(label="Cancel")
cancel_button.connect("clicked", self.on_cancel_clicked)
hbox.pack_start(cancel_button, True, True, 10)
button = Gtk.Button(label=label)
button.connect("clicked", button_callback)
hbox.pack_start(button, True, True, 0)
self.action_area.pack_start(hbox, True, True, 0)
def set_advanced_options_visible(self, value):
"""Change visibility of advanced options across all config tabs."""
widgets = self.system_box.get_children()
if self.runner_name:
widgets += self.runner_box.get_children()
if self.game:
widgets += self.game_box.get_children()
for widget in widgets:
if widget.get_style_context().has_class('advanced'):
widget.set_visible(value)
if value:
widget.set_no_show_all(not value)
widget.show_all()
def on_show_advanced_options_toggled(self, checkbox):
value = True if checkbox.get_active() else False
settings.write_setting('show_advanced_options', value)
self.set_advanced_options_visible(value)
def on_runner_changed(self, widget):
"""Action called when runner drop down is changed."""
runner_index = widget.get_active()
current_page = self.notebook.get_current_page()
if runner_index == 0:
self.runner_name = None
self.lutris_config = LutrisConfig()
else:
self.runner_name = widget.get_model()[runner_index][1]
# XXX DANGER ZONE
self.lutris_config = LutrisConfig(runner_slug=self.runner_name,
level='game')
self.rebuild_tabs()
self.notebook.set_current_page(current_page)
def on_cancel_clicked(self, widget=None):
"""Dialog destroy callback."""
self.destroy()
def is_valid(self):
name = self.name_entry.get_text()
if not self.runner_name:
ErrorDialog("Runner not provided")
return False
if not name:
ErrorDialog("Please fill in the name")
return False
return True
def on_save(self, _button):
"""Save game info and destroy widget. Return True if success."""
if not self.is_valid():
return False
name = self.name_entry.get_text()
# Do not modify slug
if not self.slug:
self.slug = slugify(name)
if not self.game:
self.game = Game(self.slug)
self.game.config = self.lutris_config
if not self.lutris_config.game_slug:
self.lutris_config.game_slug = self.slug
self.lutris_config.save()
runner_class = runners.import_runner(self.runner_name)
runner = runner_class(self.lutris_config)
self.game.name = name
self.game.slug = self.slug
self.game.runner_name = self.runner_name
self.game.directory = runner.game_path
self.game.is_installed = True
self.game.save()
self.destroy()
logger.debug("Saved %s", name)
self.saved = True
def install(self):
"""Install NullDC"""
dlg = DirectoryDialog('Where is NullDC located ?')
config = LutrisConfig(runner=self.__class__.__name__)
config.runner_config = {'system': {'game_path': dlg.folder}}
config.save()
def create_config(self, db_game, config_id):
"""Create the game configuration for a Steam game"""
game_config = LutrisConfig(runner_slug="steam",
game_config_id=config_id)
game_config.raw_game_config.update({"appid": db_game["appid"]})
game_config.save()
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>")
class Game(GObject.Object):
"""This class takes cares of loading the configuration for a game
and running it.
"""
STATE_STOPPED = "stopped"
STATE_LAUNCHING = "launching"
STATE_RUNNING = "running"
__gsignals__ = {
"game-error": (GObject.SIGNAL_RUN_FIRST, None, (str, )),
"game-launch": (GObject.SIGNAL_RUN_FIRST, None, ()),
"game-start": (GObject.SIGNAL_RUN_FIRST, None, ()),
"game-started": (GObject.SIGNAL_RUN_FIRST, None, ()),
"game-stop": (GObject.SIGNAL_RUN_FIRST, None, ()),
"game-stopped": (GObject.SIGNAL_RUN_FIRST, None, ()),
"game-removed": (GObject.SIGNAL_RUN_FIRST, None, ()),
"game-updated": (GObject.SIGNAL_RUN_FIRST, None, ()),
"game-install": (GObject.SIGNAL_RUN_FIRST, None, ()),
"game-installed": (GObject.SIGNAL_RUN_FIRST, None, ()),
}
def __init__(self, game_id=None):
super().__init__()
self.id = game_id # pylint: disable=invalid-name
self.runner = None
self.config = None
# Load attributes from database
game_data = games_db.get_game_by_field(game_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.game_config_id = game_data.get("configpath") or ""
self.is_installed = bool(game_data.get("installed") and self.game_config_id)
self.is_hidden = bool(game_data.get("hidden"))
self.platform = game_data.get("platform") or ""
self.year = game_data.get("year") or ""
self.lastplayed = game_data.get("lastplayed") or 0
self.has_custom_banner = bool(game_data.get("has_custom_banner"))
self.has_custom_icon = bool(game_data.get("has_custom_icon"))
self.service = game_data.get("service")
self.appid = game_data.get("service_id")
self.discord_presence = DiscordPresence()
self.playtime = game_data.get("playtime") or 0.0
if self.game_config_id:
self.load_config()
self.game_thread = None
self.prelaunch_executor = None
self.heartbeat = None
self.killswitch = None
self.state = self.STATE_STOPPED
self.game_runtime_config = {}
self.resolution_changed = False
self.compositor_disabled = False
self.original_outputs = None
self._log_buffer = None
self.timer = Timer()
self.screen_saver_inhibitor_cookie = None
def __repr__(self):
return self.__str__()
def __str__(self):
value = self.name
if self.runner_name:
value += " (%s)" % self.runner_name
return value
@property
def is_favorite(self):
"""Return whether the game is in the user's favorites"""
categories = categories_db.get_categories_in_game(self.id)
for category in categories:
if category == "favorite":
return True
return False
def add_to_favorites(self):
"""Add the game to the 'favorite' category"""
favorite = categories_db.get_category("favorite")
if not favorite:
favorite = categories_db.add_category("favorite")
categories_db.add_game_to_category(self.id, favorite["id"])
self.emit("game-updated")
def remove_from_favorites(self):
"""Remove game from favorites"""
favorite = categories_db.get_category("favorite")
categories_db.remove_category_from_game(self.id, favorite["id"])
self.emit("game-updated")
def hide(self):
"""Do not show this game in the UI"""
self.is_hidden = True
self.save()
def unhide(self):
"""Remove the game from hidden games"""
self.is_hidden = False
self.save()
@property
def log_buffer(self):
"""Access the log buffer object, creating it if necessary"""
_log_buffer = LOG_BUFFERS.get(self.id)
if _log_buffer:
return _log_buffer
_log_buffer = Gtk.TextBuffer()
_log_buffer.create_tag("warning", foreground="red")
if self.game_thread:
self.game_thread.set_log_buffer(self._log_buffer)
_log_buffer.set_text(self.game_thread.stdout)
LOG_BUFFERS[self.id] = _log_buffer
return _log_buffer
@property
def formatted_playtime(self):
"""Return a human readable formatted play time"""
return strings.get_formatted_playtime(self.playtime)
@staticmethod
def show_error_message(message):
"""Display an error message based on the runner's output."""
if message["error"] == "CUSTOM":
message_text = message["text"].replace("&", "&")
dialogs.ErrorDialog(message_text)
elif message["error"] == "RUNNER_NOT_INSTALLED":
dialogs.ErrorDialog(_("Error the runner is not installed"))
elif message["error"] == "NO_BIOS":
dialogs.ErrorDialog(_("A bios file is required to run this game"))
elif message["error"] == "FILE_NOT_FOUND":
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 message["error"] == "NOT_EXECUTABLE":
message_text = message["file"].replace("&", "&")
dialogs.ErrorDialog(_("The file %s is not executable") % message_text)
elif message["error"] == "PATH_NOT_SET":
message_text = _("The path '%s' is not set. please set it in the options.") % message["path"]
dialogs.ErrorDialog(message_text)
else:
dialogs.ErrorDialog(_("Unhandled error: %s") % message["error"])
def get_browse_dir(self):
"""Return the path to open with the Browse Files action."""
return self.runner.game_path
def _get_runner(self):
"""Return the runner instance for this game's configuration"""
try:
runner_class = import_runner(self.runner_name)
return runner_class(self.config)
except InvalidRunner:
logger.error("Unable to import runner %s for %s", self.runner_name, self.slug)
def load_config(self):
"""Load the game's configuration."""
if not self.is_installed:
return
self.config = LutrisConfig(runner_slug=self.runner_name, game_config_id=self.game_config_id)
self.runner = self._get_runner()
if self.discord_presence.available:
self.discord_presence.client_id = (
self.config.system_config.get("discord_client_id") or DEFAULT_DISCORD_CLIENT_ID
)
self.discord_presence.game_name = (self.config.system_config.get("discord_custom_game_name") or self.name)
self.discord_presence.show_runner = self.config.system_config.get("discord_show_runner", True)
self.discord_presence.runner_name = (
self.config.system_config.get("discord_custom_runner_name") or self.runner_name
)
self.discord_presence.rpc_enabled = self.config.system_config.get("discord_rpc_enabled", True)
def set_desktop_compositing(self, enable):
"""Enables or disables compositing"""
if enable:
if self.compositor_disabled:
enable_compositing()
self.compositor_disabled = False
else:
if not self.compositor_disabled:
disable_compositing()
self.compositor_disabled = True
def remove(self, delete_files=False):
"""Uninstall a game
Params:
delete_files (bool): Delete the game files
"""
if delete_files and self.runner:
self.runner.remove_game_data(game_path=self.directory)
games_db.set_uninstalled(self.id)
if self.config:
self.config.remove()
xdgshortcuts.remove_launcher(self.slug, self.id, desktop=True, menu=True)
self.is_installed = False
self.emit("game-removed")
def set_platform_from_runner(self):
"""Set the game's platform from the runner"""
if not self.runner:
logger.warning("Game has no runner, can't set platform")
return
self.platform = self.runner.get_platform()
if not self.platform:
logger.warning("Can't get platform for runner %s", self.runner.human_name)
def save(self, save_config=False):
"""
Save the game's config and metadata, if `save_config` is set to False,
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 self.config:
logger.debug("Saving %s with config ID %s", self, self.config.game_config_id)
configpath = self.config.game_config_id
if save_config:
self.config.save()
else:
logger.warning("Saving %s without a configuration", self)
configpath = ""
self.set_platform_from_runner()
self.id = games_db.add_or_update(
name=self.name,
runner=self.runner_name,
slug=self.slug,
platform=self.platform,
directory=self.directory,
installed=self.is_installed,
year=self.year,
lastplayed=self.lastplayed,
configpath=configpath,
id=self.id,
playtime=self.playtime,
hidden=self.is_hidden,
service=self.service,
service_id=self.appid,
)
self.emit("game-updated")
def is_launchable(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: %s", runtime_updater.current_updates)
dialogs.ErrorDialog(_("Runtime currently updating"), _("Game might not work as expected"))
if ("wine" in self.runner_name and not wine.get_system_wine_version() and not LINUX_SYSTEM.is_flatpak):
# TODO find a reference to the root window or better yet a way not
# to have Gtk dependent code in this class.
root_window = None
dialogs.WineNotInstalledWarning(parent=root_window)
return True
def restrict_to_display(self, display):
outputs = DISPLAY_MANAGER.get_config()
if display == "primary":
display = None
for output in outputs:
if output.primary:
display = output.name
break
if not display:
logger.warning("No primary display set")
else:
found = False
for output in outputs:
if output.name == display:
found = True
break
if not found:
logger.warning("Selected display %s not found", display)
display = None
if display:
turn_off_except(display)
time.sleep(3)
return True
return False
def start_xephyr(self, display=":2"):
"""Start a monitored Xephyr instance"""
if not system.find_executable("Xephyr"):
raise GameConfigError("Unable to find Xephyr, install it or disable the Xephyr option")
xephyr_command = get_xephyr_command(display, self.runner.system_config)
xephyr_thread = MonitoredCommand(xephyr_command)
xephyr_thread.start()
time.sleep(3)
return display
@staticmethod
def set_keyboard_layout(layout):
setxkbmap_command = ["setxkbmap", "-model", "pc101", layout, "-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()
def start_prelaunch_command(self):
"""Start the prelaunch command specified in the system options"""
prelaunch_command = self.runner.system_config.get("prelaunch_command")
command_array = shlex.split(prelaunch_command)
if not system.path_exists(command_array[0]):
logger.warning("Command %s not found", command_array[0])
return
self.prelaunch_executor = MonitoredCommand(
command_array,
include_processes=[os.path.basename(command_array[0])],
env=self.game_runtime_config["env"],
cwd=self.directory,
)
self.prelaunch_executor.start()
logger.info("Running %s in the background", prelaunch_command)
def get_terminal(self):
"""Return the terminal used to run the game into or None if the game is not run from a terminal.
Remember that only games using text mode should use the terminal.
"""
if self.runner.system_config.get("terminal"):
terminal = self.runner.system_config.get("terminal_app", system.get_default_terminal())
if terminal and not system.find_executable(terminal):
raise GameConfigError(_("The selected terminal application could not be launched:\n%s") % terminal)
return terminal
def get_killswitch(self):
"""Return the path to a file that is monitored during game execution.
If the file stops existing, the game is stopped.
"""
killswitch = self.runner.system_config.get("killswitch")
# Prevent setting a killswitch to a file that doesn't exists
if killswitch and system.path_exists(self.killswitch):
return killswitch
def get_gameplay_info(self):
"""Return the information provided by a runner's play method.
Checks for possible errors.
"""
gameplay_info = self.runner.play()
if "error" in gameplay_info:
self.show_error_message(gameplay_info)
self.state = self.STATE_STOPPED
self.emit("game-stop")
return
return gameplay_info
@watch_lutris_errors
def configure_game(self, prelaunched, error=None): # noqa: C901
"""Get the game ready to start, applying all the options
This methods sets the game_runtime_config attribute.
"""
if error:
logger.error(error)
dialogs.ErrorDialog(str(error))
if not prelaunched:
logger.error("Game prelaunch unsuccessful")
dialogs.ErrorDialog(_("An error prevented the game from running"))
self.state = self.STATE_STOPPED
self.emit("game-stop")
return
gameplay_info = self.get_gameplay_info()
if not gameplay_info:
return
command, env = get_launch_parameters(self.runner, gameplay_info)
env["game_name"] = self.name # What is this used for??
self.game_runtime_config = {
"args": command,
"env": env,
"terminal": self.get_terminal(),
"include_processes": shlex.split(self.runner.system_config.get("include_processes", "")),
"exclude_processes": shlex.split(self.runner.system_config.get("exclude_processes", "")),
}
# Audio control
if self.runner.system_config.get("reset_pulse"):
audio.reset_pulse()
# Input control
if self.runner.system_config.get("use_us_layout"):
self.set_keyboard_layout("us")
# Display control
self.original_outputs = DISPLAY_MANAGER.get_config()
if self.runner.system_config.get("disable_compositor"):
self.set_desktop_compositing(False)
if self.runner.system_config.get("disable_screen_saver"):
self.screen_saver_inhibitor_cookie = SCREEN_SAVER_INHIBITOR.inhibit(self.name)
if self.runner.system_config.get("display") != "off":
self.resolution_changed = self.restrict_to_display(self.runner.system_config.get("display"))
resolution = self.runner.system_config.get("resolution")
if resolution != "off":
DISPLAY_MANAGER.set_resolution(resolution)
time.sleep(3)
self.resolution_changed = True
xephyr = self.runner.system_config.get("xephyr") or "off"
if xephyr != "off":
env["DISPLAY"] = self.start_xephyr()
# Execution control
self.killswitch = self.get_killswitch()
if self.runner.system_config.get("prelaunch_command"):
self.start_prelaunch_command()
if self.runner.system_config.get("prelaunch_wait"):
# Monitor the prelaunch command and wait until it has finished
self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.prelaunch_beat)
else:
self.start_game()
def launch(self):
"""Request launching a game. The game may not be installed yet."""
if not self.is_installed:
self.emit("game-install")
return
wait_for_dxvk_init()
self.load_config() # Reload the config before launching it.
if not self.runner:
dialogs.ErrorDialog(_("Invalid game configuration: Missing runner"))
return
if not self.is_launchable():
logger.error("Game is not launchable")
return
self.state = self.STATE_LAUNCHING
self.emit("game-start")
jobs.AsyncCall(self.runner.prelaunch, self.configure_game)
def start_game(self):
"""Run a background command to lauch the game"""
self.game_thread = MonitoredCommand(
self.game_runtime_config["args"],
title=self.name,
runner=self.runner,
env=self.game_runtime_config["env"],
term=self.game_runtime_config["terminal"],
log_buffer=self.log_buffer,
include_processes=self.game_runtime_config["include_processes"],
exclude_processes=self.game_runtime_config["exclude_processes"],
)
if hasattr(self.runner, "stop"):
self.game_thread.stop_func = self.runner.stop
self.game_thread.start()
self.timer.start()
self.state = self.STATE_RUNNING
self.emit("game-started")
self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat)
def stop_game(self):
"""Cleanup after a game as stopped"""
self.state = self.STATE_STOPPED
self.emit("game-stop")
if not self.timer.finished:
self.timer.end()
self.playtime += self.timer.duration / 3600
def prelaunch_beat(self):
"""Watch the prelaunch command"""
if self.prelaunch_executor and self.prelaunch_executor.is_running:
return True
self.start_game()
return False
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 system.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
if self.discord_presence.available:
self.discord_presence.update_discord_rich_presence()
return True
def stop(self):
"""Stops the game"""
if self.state == self.STATE_STOPPED:
logger.debug("Game already stopped")
return
logger.info("Stopping %s", self)
if self.game_thread:
jobs.AsyncCall(self.game_thread.stop, None)
self.stop_game()
def on_game_quit(self):
"""Restore some settings and cleanup after game quit."""
if self.prelaunch_executor and self.prelaunch_executor.is_running:
logger.info("Stopping prelaunch script")
self.prelaunch_executor.stop()
self.heartbeat = None
if self.state != self.STATE_STOPPED:
logger.warning("Game still running (state: %s)", self.state)
self.stop()
# Check for post game script
postexit_command = self.runner.system_config.get("postexit_command")
if postexit_command:
command_array = shlex.split(postexit_command)
if system.path_exists(command_array[0]):
logger.info("Running post-exit command: %s", postexit_command)
postexit_thread = MonitoredCommand(
command_array,
include_processes=[os.path.basename(postexit_command)],
env=self.game_runtime_config["env"],
cwd=self.directory,
)
postexit_thread.start()
if self.discord_presence.available:
self.discord_presence.clear_discord_rich_presence()
quit_time = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime())
logger.debug("%s stopped at %s", self.name, quit_time)
self.lastplayed = int(time.time())
self.save(save_config=False)
os.chdir(os.path.expanduser("~"))
if self.resolution_changed or self.runner.system_config.get("reset_desktop"):
DISPLAY_MANAGER.set_resolution(self.original_outputs)
if self.compositor_disabled:
self.set_desktop_compositing(True)
if self.screen_saver_inhibitor_cookie is not None:
SCREEN_SAVER_INHIBITOR.uninhibit(self.screen_saver_inhibitor_cookie)
self.screen_saver_inhibitor_cookie = None
if self.runner.system_config.get("use_us_layout"):
subprocess.Popen(["setxkbmap"], env=os.environ).communicate()
if self.runner.system_config.get("restore_gamma"):
restore_gamma()
self.process_return_codes()
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 write_script(self, script_path):
"""Output the launch argument in a bash script"""
gameplay_info = self.get_gameplay_info()
if not gameplay_info:
return
export_bash_script(self.runner, gameplay_info, script_path)
def move(self, new_location):
logger.info("Moving %s to %s", self, new_location)
new_config = ""
old_location = self.directory
if old_location:
game_directory = os.path.basename(old_location)
target_directory = os.path.join(new_location, game_directory)
else:
target_directory = new_location
self.directory = target_directory
self.save()
if not old_location:
logger.info("Previous location wasn't set. Cannot continue moving")
return target_directory
with open(self.config.game_config_path) as config_file:
for line in config_file.readlines():
if target_directory in line:
new_config += line
else:
new_config += line.replace(old_location, target_directory)
with open(self.config.game_config_path, "w") as config_file:
config_file.write(new_config)
if not system.path_exists(old_location):
logger.warning("Location %s doesn't exist, files already moved?", old_location)
return
if new_location.startswith(old_location):
logger.warning("Can't move %s to one of its children %s", old_location, new_location)
return target_directory
try:
shutil.move(old_location, new_location)
except OSError as ex:
logger.error(
"Failed to move %s to %s, you may have to move files manually (Exception: %s)",
old_location, new_location, ex
)
return target_directory
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(game=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
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 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 beat(self):
"""Watch game's process."""
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
self.game_log = self.game_thread.stdout
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 GameDialogCommon(object):
no_runner_label = "Select a runner from the list"
@staticmethod
def get_runner_liststore():
"""Build a ListStore with available runners."""
runner_liststore = Gtk.ListStore(str, str)
runner_liststore.append(("Select a runner from the list", ""))
for runner_name in lutris.runners.__all__:
runner_class = lutris.runners.import_runner(runner_name)
runner = runner_class()
if runner.is_installed():
description = runner.description
runner_liststore.append(
("%s (%s)" % (runner_name, description), runner_name)
)
return runner_liststore
def build_entry_box(self, entry, label_text=None):
box = Gtk.HBox()
if label_text:
label = Gtk.Label(label=label_text)
box.pack_start(label, False, False, 20)
box.pack_start(entry, True, True, 20)
return box
def get_runner_dropdown(self):
runner_liststore = self.get_runner_liststore()
self.runner_dropdown = Gtk.ComboBox.new_with_model(runner_liststore)
runner_index = 0
if self.game:
for runner in runner_liststore:
if self.runner_name == str(runner[1]):
break
runner_index += 1
self.runner_dropdown.set_active(runner_index)
self.runner_dropdown.connect("changed", self.on_runner_changed)
cell = Gtk.CellRendererText()
cell.props.ellipsize = Pango.EllipsizeMode.END
self.runner_dropdown.pack_start(cell, True)
self.runner_dropdown.add_attribute(cell, 'text', 0)
return self.runner_dropdown
@staticmethod
def build_scrolled_window(widget):
scrolled_window = Gtk.ScrolledWindow()
scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
scrolled_window.add_with_viewport(widget)
scrolled_window.show_all()
return scrolled_window
def build_notebook(self):
self.notebook = Gtk.Notebook()
self.vbox.pack_start(self.notebook, True, True, 10)
def add_notebook_tab(self, widget, label):
self.notebook.append_page(widget, Gtk.Label(label=label))
def build_info_tab(self):
info_box = VBox()
self.name_entry = Gtk.Entry()
if self.game:
self.name_entry.set_text(self.game.name)
name_box = self.build_entry_box(self.name_entry, "Name")
info_box.pack_start(name_box, False, False, 5)
if self.game:
self.slug_entry = Gtk.Entry()
self.slug_entry.set_text(self.game.slug)
self.slug_entry.set_sensitive(False)
slug_box = self.build_entry_box(self.slug_entry, "Identifier")
info_box.pack_start(slug_box, False, False, 5)
runner_box = Gtk.HBox()
label = Gtk.Label("Runner")
label.set_alignment(0.5, 0.5)
runner_dropdown = self.get_runner_dropdown()
runner_box.pack_start(label, False, False, 20)
runner_box.pack_start(runner_dropdown, False, False, 20)
info_box.pack_start(runner_box, False, False, 5)
info_sw = self.build_scrolled_window(info_box)
self.add_notebook_tab(info_sw, "Game info")
def build_game_tab(self):
if self.game and self.runner_name:
self.game.runner_name = self.runner_name
self.game_box = GameBox(self.lutris_config, "game", self.game)
game_sw = self.build_scrolled_window(self.game_box)
elif self.runner_name:
game = Game(None)
game.runner_name = self.runner_name
self.game_box = GameBox(self.lutris_config, "game", game)
game_sw = self.build_scrolled_window(self.game_box)
else:
game_sw = Gtk.Label(label=self.no_runner_label)
game_sw.show()
self.add_notebook_tab(game_sw, "Game configuration")
def build_runner_tab(self):
if self.runner_name:
self.runner_box = RunnerBox(self.lutris_config, "game",
self.runner_name)
runner_sw = self.build_scrolled_window(self.runner_box)
else:
runner_sw = Gtk.Label(label=self.no_runner_label)
runner_sw.show()
self.add_notebook_tab(runner_sw, "Runner configuration")
def build_system_tab(self):
self.system_box = SystemBox(self.lutris_config, "game")
self.system_sw = self.build_scrolled_window(self.system_box)
self.add_notebook_tab(self.system_sw, "System configuration")
def build_tabs(self):
self.build_info_tab()
self.build_game_tab()
self.build_runner_tab()
self.build_system_tab()
def rebuild_tabs(self):
for i in range(self.notebook.get_n_pages(), 1, -1):
self.notebook.remove_page(i - 1)
self.build_game_tab()
self.build_runner_tab()
self.build_system_tab()
def build_action_area(self, label, button_callback):
cancel_button = Gtk.Button(label="Cancel")
cancel_button.connect("clicked", self.on_cancel_clicked)
self.action_area.pack_start(cancel_button, True, True, 0)
button = Gtk.Button(label=label)
button.connect("clicked", button_callback)
self.action_area.pack_start(button, True, True, 0)
def on_runner_changed(self, widget):
"""Action called when runner drop down is changed."""
runner_index = widget.get_active()
current_page = self.notebook.get_current_page()
if runner_index == 0:
self.runner_name = None
self.lutris_config = LutrisConfig()
else:
self.runner_name = widget.get_model()[runner_index][1]
# XXX DANGER ZONE
self.lutris_config = LutrisConfig(runner=self.runner_name)
self.rebuild_tabs()
self.notebook.set_current_page(current_page)
def on_cancel_clicked(self, widget=None):
"""Dialog destroy callback."""
self.destroy()
def is_valid(self):
name = self.name_entry.get_text()
if not self.runner_name:
ErrorDialog("Runner not provided")
return False
if not name:
ErrorDialog("Please fill in the name")
return False
return True
def on_save(self, _button):
"""Save game info and destroy widget. Return True if success."""
if not self.is_valid():
return False
name = self.name_entry.get_text()
if not self.lutris_config.game:
self.lutris_config.game = slugify(name)
self.lutris_config.save()
self.slug = self.lutris_config.game
runner_class = lutris.runners.import_runner(self.runner_name)
runner = runner_class(self.lutris_config)
pga.add_or_update(name, self.runner_name, slug=self.slug,
directory=runner.game_path,
installed=1)
self.destroy()
logger.debug("Saved %s", name)
return True
class Game(GObject.Object):
"""This class takes cares of loading the configuration for a game
and running it.
"""
STATE_IDLE = "idle"
STATE_STOPPED = "stopped"
STATE_RUNNING = "running"
__gsignals__ = {
"game-error": (GObject.SIGNAL_RUN_FIRST, None, (str, )),
"game-start": (GObject.SIGNAL_RUN_FIRST, None, ()),
"game-started": (GObject.SIGNAL_RUN_FIRST, None, ()),
"game-stop": (GObject.SIGNAL_RUN_FIRST, None, ()),
"game-stopped": (GObject.SIGNAL_RUN_FIRST, None, (int, )),
"game-removed": (GObject.SIGNAL_RUN_FIRST, None, ()),
"game-updated": (GObject.SIGNAL_RUN_FIRST, None, ()),
"game-installed": (GObject.SIGNAL_RUN_FIRST, None, ()),
}
def __init__(self, game_id=None):
super().__init__()
self.id = game_id # pylint: disable=invalid-name
self.runner = None
self.config = None
# Load attributes from database
game_data = pga.get_game_by_field(game_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.game_config_id = game_data.get("configpath") or ""
self.is_installed = bool(
game_data.get("installed") and self.game_config_id)
self.platform = game_data.get("platform") or ""
self.year = game_data.get("year") or ""
self.lastplayed = game_data.get("lastplayed") or 0
self.steamid = game_data.get("steamid") or ""
self.has_custom_banner = bool(game_data.get("has_custom_banner"))
self.has_custom_icon = bool(game_data.get("has_custom_icon"))
self.discord_presence = DiscordPresence()
try:
self.playtime = float(game_data.get("playtime") or 0.0)
except ValueError:
logger.error("Invalid playtime value %s",
game_data.get("playtime"))
self.playtime = 0.0
if self.game_config_id:
self.load_config()
self.game_thread = None
self.prelaunch_executor = None
self.heartbeat = None
self.killswitch = None
self.state = self.STATE_IDLE
self.game_runtime_config = {}
self.resolution_changed = False
self.compositor_disabled = False
self.stop_compositor = self.start_compositor = ""
self.original_outputs = None
self._log_buffer = None
self.timer = Timer()
def __repr__(self):
return self.__str__()
def __str__(self):
value = self.name
if self.runner_name:
value += " (%s)" % self.runner_name
return value
@property
def log_buffer(self):
"""Access the log buffer object, creating it if necessary"""
if self._log_buffer is None:
self._log_buffer = Gtk.TextBuffer()
self._log_buffer.create_tag("warning", foreground="red")
if self.game_thread:
self.game_thread.set_log_buffer(self._log_buffer)
self._log_buffer.set_text(self.game_thread.stdout)
return self._log_buffer
@property
def formatted_playtime(self):
"""Return a human readable formatted play time"""
return strings.get_formatted_playtime(self.playtime)
@property
def is_search_result(self):
"""Return whether or not the game is a remote game from search results.
This is bad, find another way to do this.
"""
return self.id < 0
@staticmethod
def show_error_message(message):
"""Display an error message based on the runner's output."""
if message["error"] == "CUSTOM":
message_text = message["text"].replace("&", "&")
dialogs.ErrorDialog(message_text)
elif message["error"] == "RUNNER_NOT_INSTALLED":
dialogs.ErrorDialog("Error the runner is not installed")
elif message["error"] == "NO_BIOS":
dialogs.ErrorDialog("A bios file is required to run this game")
elif message["error"] == "FILE_NOT_FOUND":
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 message["error"] == "NOT_EXECUTABLE":
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 _get_runner(self):
"""Return the runner instance for this game's configuration"""
try:
runner_class = import_runner(self.runner_name)
return runner_class(self.config)
except InvalidRunner:
logger.error("Unable to import runner %s for %s", self.runner_name,
self.slug)
def load_config(self):
"""Load the game's configuration."""
if not self.is_installed:
return
self.config = LutrisConfig(runner_slug=self.runner_name,
game_config_id=self.game_config_id)
self.runner = self._get_runner()
if self.discord_presence.available:
self.discord_presence.client_id = (
self.config.system_config.get("discord_client_id")
or DEFAULT_DISCORD_CLIENT_ID)
self.discord_presence.game_name = (
self.config.system_config.get("discord_custom_game_name")
or self.name)
self.discord_presence.show_runner = self.config.system_config.get(
"discord_show_runner", True)
self.discord_presence.runner_name = (
self.config.system_config.get("discord_custom_runner_name")
or self.runner_name)
self.discord_presence.rpc_enabled = self.config.system_config.get(
"discord_rpc_enabled", True)
def set_desktop_compositing(self, enable):
"""Enables or disables compositing"""
if enable:
system.execute(self.start_compositor, shell=True)
else:
(
self.start_compositor,
self.stop_compositor,
) = get_compositor_commands()
if not (self.compositor_disabled or not self.stop_compositor):
system.execute(self.stop_compositor, shell=True)
self.compositor_disabled = True
def remove(self, from_library=False, from_disk=False):
"""Uninstall a game
Params:
from_library (bool): Completely remove the game from library, do
not set it as uninstalled
from_disk (bool): Delete the game files
Return:
bool: Updated value for from_library
"""
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)
if self.config:
self.config.remove()
xdgshortcuts.remove_launcher(self.slug,
self.id,
desktop=True,
menu=True)
self.is_installed = False
self.emit("game-removed")
return from_library
def set_platform_from_runner(self):
"""Set the game's platform from the runner"""
if not self.runner:
logger.warning("Game has no runner, can't set platform")
return
self.platform = self.runner.get_platform()
if not self.platform:
logger.warning("Can't get platform for runner %s",
self.runner.human_name)
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.
"""
logger.debug("Saving %s", self)
if not metadata_only:
self.config.save()
self.set_platform_from_runner()
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,
playtime=self.playtime,
)
self.emit("game-updated")
def is_launchable(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: %s",
runtime_updater.current_updates)
dialogs.ErrorDialog("Runtime currently updating",
"Game might not work as expected")
if ("wine" in self.runner_name and not wine.get_system_wine_version()
and not LINUX_SYSTEM.is_flatpak):
# TODO find a reference to the root window or better yet a way not
# to have Gtk dependent code in this class.
root_window = None
dialogs.WineNotInstalledWarning(parent=root_window)
return True
def play(self):
"""Launch the game."""
if not self.runner:
dialogs.ErrorDialog("Invalid game configuration: Missing runner")
self.state = self.STATE_STOPPED
self.emit("game-stop")
return
if not self.is_launchable():
self.state = self.STATE_STOPPED
self.emit("game-stop")
return
self.emit("game-start")
jobs.AsyncCall(self.runner.prelaunch, self.configure_game)
@watch_lutris_errors
def configure_game(self, prelaunched, error=None):
"""Get the game ready to start, applying all the options
This methods sets the game_runtime_config attribute.
"""
if error:
logger.error(error)
dialogs.ErrorDialog(str(error))
if not prelaunched:
logger.error("Game prelaunch unsuccessful")
dialogs.ErrorDialog("An error prevented the game from running")
self.state = self.STATE_STOPPED
self.emit("game-stop")
return
system_config = self.runner.system_config
self.original_outputs = DISPLAY_MANAGER.get_config()
gameplay_info = self.runner.play()
if "error" in gameplay_info:
self.show_error_message(gameplay_info)
self.state = self.STATE_STOPPED
self.emit("game-stop")
return
logger.debug("Launching %s: %s", self.name, gameplay_info)
logger.debug("Game info: %s", json.dumps(gameplay_info, indent=2))
env = {}
sdl_gamecontrollerconfig = system_config.get(
"sdl_gamecontrollerconfig")
if sdl_gamecontrollerconfig:
path = os.path.expanduser(sdl_gamecontrollerconfig)
if system.path_exists(path):
with open(path, "r") as controllerdb_file:
sdl_gamecontrollerconfig = controllerdb_file.read()
env["SDL_GAMECONTROLLERCONFIG"] = sdl_gamecontrollerconfig
sdl_video_fullscreen = system_config.get("sdl_video_fullscreen") or ""
env["SDL_VIDEO_FULLSCREEN_DISPLAY"] = sdl_video_fullscreen
restrict_to_display = system_config.get("display")
if restrict_to_display != "off":
if restrict_to_display == "primary":
restrict_to_display = None
for output in self.original_outputs:
if output.primary:
restrict_to_display = output.name
break
if not restrict_to_display:
logger.warning("No primary display set")
else:
found = False
for output in self.original_outputs:
if output.name == restrict_to_display:
found = True
break
if not found:
logger.warning("Selected display %s not found",
restrict_to_display)
restrict_to_display = None
if restrict_to_display:
turn_off_except(restrict_to_display)
time.sleep(3)
self.resolution_changed = True
resolution = system_config.get("resolution")
if resolution != "off":
DISPLAY_MANAGER.set_resolution(resolution)
time.sleep(3)
self.resolution_changed = True
if system_config.get("reset_pulse"):
audio.reset_pulse()
self.killswitch = system_config.get("killswitch")
if self.killswitch and not system.path_exists(self.killswitch):
# Prevent setting a killswitch to a file that doesn't exists
self.killswitch = None
# Command
launch_arguments = gameplay_info["command"]
optimus = system_config.get("optimus")
if optimus == "primusrun" and system.find_executable("primusrun"):
launch_arguments.insert(0, "primusrun")
elif optimus == "optirun" and system.find_executable("optirun"):
launch_arguments.insert(0, "virtualgl")
launch_arguments.insert(0, "-b")
launch_arguments.insert(0, "optirun")
elif optimus == "pvkrun" and system.find_executable("pvkrun"):
launch_arguments.insert(0, "pvkrun")
xephyr = system_config.get("xephyr") or "off"
if xephyr != "off":
if not system.find_executable("Xephyr"):
raise GameConfigError(
"Unable to find Xephyr, install it or disable the Xephyr option"
)
xephyr_depth = "8" if xephyr == "8bpp" else "16"
xephyr_resolution = system_config.get(
"xephyr_resolution") or "640x480"
xephyr_command = [
"Xephyr",
":2",
"-ac",
"-screen",
xephyr_resolution + "x" + xephyr_depth,
"-glamor",
"-reset",
"-terminate",
]
if system_config.get("xephyr_fullscreen"):
xephyr_command.append("-fullscreen")
xephyr_thread = MonitoredCommand(xephyr_command)
xephyr_thread.start()
time.sleep(3)
env["DISPLAY"] = ":2"
if system_config.get("use_us_layout"):
setxkbmap_command = [
"setxkbmap", "-model", "pc101", "us", "-print"
]
xkbcomp_command = ["xkbcomp", "-", os.environ.get("DISPLAY", ":0")]
xkbcomp = subprocess.Popen(xkbcomp_command, stdin=subprocess.PIPE)
subprocess.Popen(setxkbmap_command,
env=os.environ,
stdout=xkbcomp.stdin).communicate()
xkbcomp.communicate()
if system_config.get("aco"):
env["RADV_PERFTEST"] = "aco"
pulse_latency = system_config.get("pulse_latency")
if pulse_latency:
env["PULSE_LATENCY_MSEC"] = "60"
vk_icd = system_config.get("vk_icd")
if vk_icd and vk_icd != "off" and system.path_exists(vk_icd):
env["VK_ICD_FILENAMES"] = vk_icd
fps_limit = system_config.get("fps_limit") or ""
if fps_limit:
strangle_cmd = system.find_executable("strangle")
if strangle_cmd:
launch_arguments = [strangle_cmd, fps_limit] + launch_arguments
else:
logger.warning(
"libstrangle is not available on this system, FPS limiter disabled"
)
prefix_command = system_config.get("prefix_command") or ""
if prefix_command:
launch_arguments = (
shlex.split(os.path.expandvars(prefix_command)) +
launch_arguments)
single_cpu = system_config.get("single_cpu") or False
if single_cpu:
logger.info("The game will run on a single CPU core")
launch_arguments.insert(0, "0")
launch_arguments.insert(0, "-c")
launch_arguments.insert(0, "taskset")
terminal = system_config.get("terminal")
if terminal:
terminal = system_config.get("terminal_app",
system.get_default_terminal())
if terminal and not system.find_executable(terminal):
dialogs.ErrorDialog("The selected terminal application "
"could not be launched:\n"
"%s" % terminal)
self.state = self.STATE_STOPPED
self.emit("game-stop")
return
# Env vars
game_env = gameplay_info.get("env") or self.runner.get_env()
env.update(game_env)
env["game_name"] = self.name
# Prime vars
prime = system_config.get("prime")
if prime:
env["__NV_PRIME_RENDER_OFFLOAD"] = "1"
env["__GLX_VENDOR_LIBRARY_NAME"] = "nvidia"
env["__VK_LAYER_NV_optimus"] = "NVIDIA_only"
# LD_PRELOAD
ld_preload = gameplay_info.get("ld_preload")
if ld_preload:
env["LD_PRELOAD"] = ld_preload
# Feral gamemode
gamemode = system_config.get("gamemode")
if gamemode:
env["LD_PRELOAD"] = ":".join([
path for path in [
env.get("LD_PRELOAD"),
"libgamemodeauto.so",
] if path
])
# LD_LIBRARY_PATH
game_ld_libary_path = gameplay_info.get("ld_library_path")
if game_ld_libary_path:
ld_library_path = env.get("LD_LIBRARY_PATH")
if not ld_library_path:
ld_library_path = "$LD_LIBRARY_PATH"
env["LD_LIBRARY_PATH"] = ":".join(
[game_ld_libary_path, ld_library_path])
include_processes = shlex.split(
system_config.get("include_processes", ""))
exclude_processes = shlex.split(
system_config.get("exclude_processes", ""))
self.game_runtime_config = {
"args": launch_arguments,
"env": env,
"terminal": terminal,
"include_processes": include_processes,
"exclude_processes": exclude_processes,
}
if system_config.get("disable_compositor"):
self.set_desktop_compositing(False)
prelaunch_command = system_config.get("prelaunch_command")
if system.path_exists(prelaunch_command):
self.prelaunch_executor = MonitoredCommand(
[prelaunch_command],
include_processes=[os.path.basename(prelaunch_command)],
env=self.game_runtime_config["env"],
cwd=self.directory,
)
self.prelaunch_executor.start()
logger.info("Running %s in the background", prelaunch_command)
if system_config.get("prelaunch_wait"):
self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY,
self.prelaunch_beat)
else:
self.start_game()
def start_game(self):
"""Run a background command to lauch the game"""
self.game_thread = MonitoredCommand(
self.game_runtime_config["args"],
title=self.name,
runner=self.runner,
env=self.game_runtime_config["env"],
term=self.game_runtime_config["terminal"],
log_buffer=self._log_buffer,
include_processes=self.game_runtime_config["include_processes"],
exclude_processes=self.game_runtime_config["exclude_processes"],
)
if hasattr(self.runner, "stop"):
self.game_thread.stop_func = self.runner.stop
self.game_thread.start()
self.timer.start()
self.emit("game-started")
self.state = self.STATE_RUNNING
self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat)
def stop_game(self):
"""Cleanup after a game as stopped"""
self.state = self.STATE_STOPPED
self.emit("game-stop")
if not self.timer.finished:
self.timer.end()
self.playtime += self.timer.duration / 3600
def prelaunch_beat(self):
"""Watch the prelaunch command"""
if self.prelaunch_executor and self.prelaunch_executor.is_running:
return True
self.start_game()
return False
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 system.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
if self.discord_presence.available:
self.discord_presence.update_discord_rich_presence()
return True
def stop(self):
"""Stops the game"""
if self.state == self.STATE_STOPPED:
logger.debug("Game already stopped")
return
logger.info("Stopping %s", self)
if self.game_thread:
jobs.AsyncCall(self.game_thread.stop, None)
self.stop_game()
def on_game_quit(self):
"""Restore some settings and cleanup after game quit."""
if self.prelaunch_executor and self.prelaunch_executor.is_running:
logger.info("Stopping prelaunch script")
self.prelaunch_executor.stop()
self.heartbeat = None
if self.state != self.STATE_STOPPED:
logger.warning("Game still running (state: %s)", self.state)
self.stop()
# Check for post game script
postexit_command = self.runner.system_config.get("postexit_command")
if system.path_exists(postexit_command):
logger.info("Running post-exit command: %s", postexit_command)
postexit_thread = MonitoredCommand(
[postexit_command],
include_processes=[os.path.basename(postexit_command)],
env=self.game_runtime_config["env"],
cwd=self.directory,
)
postexit_thread.start()
if self.discord_presence.available:
self.discord_presence.clear_discord_rich_presence()
quit_time = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime())
logger.debug("%s stopped at %s", self.name, quit_time)
self.lastplayed = int(time.time())
self.save(metadata_only=True)
os.chdir(os.path.expanduser("~"))
if self.resolution_changed or self.runner.system_config.get(
"reset_desktop"):
DISPLAY_MANAGER.set_resolution(self.original_outputs)
if self.compositor_disabled:
self.set_desktop_compositing(True)
if self.runner.system_config.get("use_us_layout"):
subprocess.Popen(["setxkbmap"], env=os.environ).communicate()
if self.runner.system_config.get("restore_gamma"):
restore_gamma()
self.process_return_codes()
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 not self.game_thread:
return
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 AddGameDialog(Gtk.Dialog):
""" Add game dialog class"""
def __init__(self, parent):
super(AddGameDialog, self).__init__()
self.parent_window = parent
#Real name
realname_hbox = Gtk.HBox()
realname_label = Gtk.Label(label="Name")
realname_hbox.pack_start(realname_label, False, False, 5)
self.realname_entry = Gtk.Entry()
realname_hbox.add(self.realname_entry)
self.vbox.pack_start(realname_hbox, False, False, 5)
self.lutris_config = LutrisConfig()
self.set_title("Add a new game")
self.set_size_request(600, 500)
#Runners: get a list of available runners
runner_liststore = Gtk.ListStore(str, str)
runner_liststore.append(("Select a runner from the list", ""))
for runner_name in lutris.runners.__all__:
runner_class = import_runner(runner_name)
runner = runner_class()
description = runner.description
if runner.is_installed():
runner_liststore.append(
("%s (%s)" % (runner_name, description), runner_name)
)
runner_combobox = Gtk.ComboBox.new_with_model(runner_liststore)
runner_combobox.connect("changed", self.on_runner_changed)
cell = Gtk.CellRendererText()
runner_combobox.pack_start(cell, True)
runner_combobox.add_attribute(cell, 'text', 0)
self.vbox.pack_start(runner_combobox, False, True, 5)
notebook = Gtk.Notebook()
self.vbox.pack_start(notebook, True, True, 0)
default_label = "Select a runner from the list"
#Game configuration
self.game_config_vbox = Gtk.Label(label=default_label)
self.conf_scroll_window = Gtk.ScrolledWindow()
self.conf_scroll_window.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
self.conf_scroll_window.add_with_viewport(self.game_config_vbox)
notebook.append_page(self.conf_scroll_window,
Gtk.Label(label="Game configuration"))
#Runner configuration
self.runner_config_vbox = Gtk.Label(label=default_label)
self.runner_scroll_window = Gtk.ScrolledWindow()
self.runner_scroll_window.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
self.runner_scroll_window.add_with_viewport(self.runner_config_vbox)
notebook.append_page(self.runner_scroll_window,
Gtk.Label(label="Runner configuration"))
#System configuration
self.system_config_vbox = SystemConfigVBox(self.lutris_config, "game")
self.system_scroll_window = Gtk.ScrolledWindow()
self.system_scroll_window.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
self.system_scroll_window.add_with_viewport(self.system_config_vbox)
notebook.append_page(self.system_scroll_window,
Gtk.Label(label="System configuration"))
cancel_button = Gtk.Button(None, Gtk.STOCK_CANCEL)
add_button = Gtk.Button(None, Gtk.STOCK_ADD)
self.action_area.add(cancel_button)
self.action_area.add(add_button)
cancel_button.connect("clicked", self.close)
add_button.connect("clicked", self.add_game)
self.show_all()
self.run()
def add_game(self, _button):
"""OK button pressed in the Add Game Dialog"""
name = self.realname_entry.get_text()
self.lutris_config.config["realname"] = name
self.lutris_config.config["runner"] = self.runner_class
if self.runner_class and name:
game_identifier = self.lutris_config.save(config_type="game")
self.game_info = {"name": name,
"runner": self.runner_class,
"slug": game_identifier}
runner = import_runner(self.runner_class)(self.lutris_config)
self.game_info['directory'] = runner.get_game_path()
pga.add_game(**self.game_info)
self.destroy()
def on_runner_changed(self, widget):
"""Action called when runner drop down is changed"""
selected_runner = widget.get_active()
scroll_windows_children = [self.conf_scroll_window.get_children(),
self.runner_scroll_window.get_children(),
self.system_scroll_window.get_children()]
for scroll_window_children in scroll_windows_children:
for child in scroll_window_children:
child.destroy()
if selected_runner == 0:
no_runner_label = Gtk.Label(label="Choose a runner from the list")
no_runner_label.show()
self.runner_scroll_window.add_with_viewport(no_runner_label)
return
self.runner_class = widget.get_model()[selected_runner][1]
self.lutris_config = LutrisConfig(self.runner_class)
self.game_config_vbox = GameConfigVBox(self.lutris_config, "game")
self.conf_scroll_window.add_with_viewport(self.game_config_vbox)
self.conf_scroll_window.show_all()
#Load runner box
self.runner_options_vbox = RunnerConfigVBox(self.lutris_config, "game")
self.runner_scroll_window.add_with_viewport(self.runner_options_vbox)
self.runner_scroll_window.show_all()
#Load system box
self.system_config_vbox = SystemConfigVBox(self.lutris_config, "game")
self.system_scroll_window.add_with_viewport(self.system_config_vbox)
self.system_scroll_window.show_all()
def close(self, _widget=None, _other=None):
"""Action received on dialog close"""
self.destroy()
class PreferencesDialog(GameDialogCommon):
def __init__(self, parent=None):
super().__init__(_("Lutris settings"), parent=parent)
self.set_border_width(0)
self.set_default_size(1010, 600)
self.lutris_config = LutrisConfig()
hbox = Gtk.HBox(visible=True)
sidebar = Gtk.ListBox(visible=True)
sidebar.connect("row-selected", self.on_sidebar_activated)
sidebar.add(
self.get_sidebar_button("prefs-stack", _("Interface"),
"view-grid-symbolic"))
sidebar.add(
self.get_sidebar_button("runners-stack", _("Runners"),
"applications-utilities-symbolic"))
sidebar.add(
self.get_sidebar_button("services-stack", _("Sources"),
"application-x-addon-symbolic"))
sidebar.add(
self.get_sidebar_button("sysinfo-stack", _("Hardware information"),
"computer-symbolic"))
sidebar.add(
self.get_sidebar_button("system-stack", _("Global options"),
"emblem-system-symbolic"))
hbox.pack_start(sidebar, False, False, 0)
self.stack = Gtk.Stack(visible=True)
self.stack.set_vhomogeneous(False)
self.stack.set_interpolate_size(True)
hbox.add(self.stack)
self.vbox.pack_start(hbox, True, True, 0)
self.stack.add_named(self.build_scrolled_window(PreferencesBox()),
"prefs-stack")
self.stack.add_named(self.build_scrolled_window(RunnersBox()),
"runners-stack")
self.stack.add_named(self.build_scrolled_window(ServicesBox()),
"services-stack")
self.stack.add_named(self.build_scrolled_window(SysInfoBox()),
"sysinfo-stack")
self.system_box = SystemBox(self.lutris_config)
self.system_box.show_all()
self.stack.add_named(self.build_scrolled_window(self.system_box),
"system-stack")
self.build_action_area(self.on_save)
self.action_area.set_margin_bottom(12)
self.action_area.set_margin_right(12)
self.action_area.set_margin_left(12)
self.action_area.set_margin_top(12)
def on_sidebar_activated(self, _listbox, row):
if row.get_children()[0].stack_id == "system-stack":
self.action_area.show_all()
else:
self.action_area.hide()
self.stack.set_visible_child_name(row.get_children()[0].stack_id)
def get_sidebar_button(self, stack_id, text, icon_name):
hbox = Gtk.HBox(visible=True)
hbox.stack_id = stack_id
hbox.set_margin_top(12)
hbox.set_margin_bottom(12)
hbox.set_margin_right(40)
icon = Gtk.Image.new_from_icon_name(icon_name, Gtk.IconSize.MENU)
icon.show()
hbox.pack_start(icon, False, False, 6)
label = Gtk.Label(text, visible=True)
label.set_alignment(0, 0.5)
hbox.pack_start(label, False, False, 6)
return hbox
def on_save(self, _widget):
self.lutris_config.save()
self.destroy()
class GameDialogCommon(object):
no_runner_label = "Select a runner from the list"
@staticmethod
def get_runner_liststore():
"""Build a ListStore with available runners."""
runner_liststore = Gtk.ListStore(str, str)
runner_liststore.append(("Select a runner from the list", ""))
for runner_name in lutris.runners.__all__:
runner_class = lutris.runners.import_runner(runner_name)
runner = runner_class()
if runner.is_installed():
description = runner.description
runner_liststore.append(
("%s (%s)" % (runner_name, description), runner_name))
return runner_liststore
def build_entry_box(self, entry, label_text=None):
box = Gtk.HBox()
if label_text:
label = Gtk.Label(label=label_text)
box.pack_start(label, False, False, 20)
box.pack_start(entry, True, True, 20)
return box
def get_runner_dropdown(self):
runner_liststore = self.get_runner_liststore()
self.runner_dropdown = Gtk.ComboBox.new_with_model(runner_liststore)
runner_index = 0
if self.game:
for runner in runner_liststore:
if self.runner_name == str(runner[1]):
break
runner_index += 1
self.runner_dropdown.set_active(runner_index)
self.runner_dropdown.connect("changed", self.on_runner_changed)
cell = Gtk.CellRendererText()
cell.props.ellipsize = Pango.EllipsizeMode.END
self.runner_dropdown.pack_start(cell, True)
self.runner_dropdown.add_attribute(cell, 'text', 0)
return self.runner_dropdown
@staticmethod
def build_scrolled_window(widget):
scrolled_window = Gtk.ScrolledWindow()
scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
scrolled_window.add_with_viewport(widget)
scrolled_window.show_all()
return scrolled_window
def build_notebook(self):
self.notebook = Gtk.Notebook()
self.vbox.pack_start(self.notebook, True, True, 10)
def add_notebook_tab(self, widget, label):
self.notebook.append_page(widget, Gtk.Label(label=label))
def build_info_tab(self):
info_box = VBox()
self.name_entry = Gtk.Entry()
if self.game:
self.name_entry.set_text(self.game.name)
name_box = self.build_entry_box(self.name_entry, "Name")
info_box.pack_start(name_box, False, False, 5)
if self.game:
self.slug_entry = Gtk.Entry()
self.slug_entry.set_text(self.game.slug)
self.slug_entry.set_sensitive(False)
slug_box = self.build_entry_box(self.slug_entry, "Identifier")
info_box.pack_start(slug_box, False, False, 5)
runner_box = Gtk.HBox()
label = Gtk.Label("Runner")
label.set_alignment(0.5, 0.5)
runner_dropdown = self.get_runner_dropdown()
runner_box.pack_start(label, False, False, 20)
runner_box.pack_start(runner_dropdown, False, False, 20)
info_box.pack_start(runner_box, False, False, 5)
info_sw = self.build_scrolled_window(info_box)
self.add_notebook_tab(info_sw, "Game info")
def build_game_tab(self):
if self.game and self.runner_name:
self.game.runner_name = self.runner_name
self.game_box = GameBox(self.lutris_config, "game", self.game)
game_sw = self.build_scrolled_window(self.game_box)
elif self.runner_name:
game = Game(None)
game.runner_name = self.runner_name
self.game_box = GameBox(self.lutris_config, "game", game)
game_sw = self.build_scrolled_window(self.game_box)
else:
game_sw = Gtk.Label(label=self.no_runner_label)
game_sw.show()
self.add_notebook_tab(game_sw, "Game configuration")
def build_runner_tab(self):
if self.runner_name:
self.runner_box = RunnerBox(self.lutris_config, "game",
self.runner_name)
runner_sw = self.build_scrolled_window(self.runner_box)
else:
runner_sw = Gtk.Label(label=self.no_runner_label)
runner_sw.show()
self.add_notebook_tab(runner_sw, "Runner configuration")
def build_system_tab(self):
self.system_box = SystemBox(self.lutris_config, "game")
self.system_sw = self.build_scrolled_window(self.system_box)
self.add_notebook_tab(self.system_sw, "System configuration")
def build_tabs(self):
self.build_info_tab()
self.build_game_tab()
self.build_runner_tab()
self.build_system_tab()
def rebuild_tabs(self):
for i in range(self.notebook.get_n_pages(), 1, -1):
self.notebook.remove_page(i - 1)
self.build_game_tab()
self.build_runner_tab()
self.build_system_tab()
def build_action_area(self, label, button_callback):
cancel_button = Gtk.Button(label="Cancel")
cancel_button.connect("clicked", self.on_cancel_clicked)
self.action_area.pack_start(cancel_button, True, True, 0)
button = Gtk.Button(label=label)
button.connect("clicked", button_callback)
self.action_area.pack_start(button, True, True, 0)
def on_runner_changed(self, widget):
"""Action called when runner drop down is changed."""
runner_index = widget.get_active()
current_page = self.notebook.get_current_page()
if runner_index == 0:
self.runner_name = None
self.lutris_config = LutrisConfig()
else:
self.runner_name = widget.get_model()[runner_index][1]
# XXX DANGER ZONE
self.lutris_config = LutrisConfig(runner=self.runner_name)
self.rebuild_tabs()
self.notebook.set_current_page(current_page)
def on_cancel_clicked(self, widget=None):
"""Dialog destroy callback."""
self.destroy()
def is_valid(self):
name = self.name_entry.get_text()
if not self.runner_name:
ErrorDialog("Runner not provided")
return False
if not name:
ErrorDialog("Please fill in the name")
return False
return True
def on_save(self, _button):
"""Save game info and destroy widget. Return True if success."""
if not self.is_valid():
return False
name = self.name_entry.get_text()
if not self.lutris_config.game:
self.lutris_config.game = slugify(name)
self.lutris_config.save()
self.slug = self.lutris_config.game
runner_class = lutris.runners.import_runner(self.runner_name)
runner = runner_class(self.lutris_config)
pga.add_or_update(name,
self.runner_name,
slug=self.slug,
directory=runner.game_path,
installed=1)
self.destroy()
logger.debug("Saved %s", name)
return True
