Mathieu Abati

Français

English

Français

English

Appearance

Retropie: support des jeux PC (x86) et des jeux Steam ​

Ce tutoriel explique comment accéder à ses jeux PC (x86) et Steam depuis EmulationStation. Cette méthode ne s'applique qu'à une installation PC de Retropie, et est incompatible avec une installation RaspberryPi.

Ce tutoriel est lié au tutoriel Installation de RetroPie sur PC.

Ajout d'un nouveau système ​

Tout d'abord, on copie la configuration par défaut des systèmes supportés:

    cp /etc/emulationstation/es_systems.cfg /opt/retropie/configs/all/emulationstation
    cp /etc/emulationstation/es_systems.cfg /opt/retropie/configs/all/emulationstation

ainsi, nos modifications ne seront pas altérées en cas de mise à jour de RetroPie.

Maintenant, on peut éditer le fichier /opt/retropie/configs/all/emulationstation/es_systems.cfg et y ajouter à la fin, avant </systemList>:

    <system>
       <name>pc</name>
       <fullname>PC</fullname>
       <path>/home/pi/RetroPie/roms/pc</path>
       <extension>.sh</extension>
       <command>%ROM%</command>
       <platform>pc</platform>
       <theme>pc</theme>
    </system>
    <system>
       <name>pc</name>
       <fullname>PC</fullname>
       <path>/home/pi/RetroPie/roms/pc</path>
       <extension>.sh</extension>
       <command>%ROM%</command>
       <platform>pc</platform>
       <theme>pc</theme>
    </system>

Support des jeux 32-bits ​

Suivez cette section si votre installation de Debian est 64-bits, auquel cas vous aurez besoin d'avoir effectué les opérations qui suivent pour lancer des jeux 32-bits.

Vous avez besoin d'effectuer cette procédure si l'exécution de la commande:

    ldd executable_du_jeu
    ldd executable_du_jeu

vous renvoie l'erreur "not a dynamic executable", et que la commande:

    file executable_du_jeu
    file executable_du_jeu

vous dit, entre autres, "ELF 32-bit".

Si vous êtes dans ce cas, exécutez:

    sudo dpkg --add-architecture i386
    sudo apt-get update
    sudo apt-get install libc6-i386 lib32stdc++6
    sudo dpkg --add-architecture i386
    sudo apt-get update
    sudo apt-get install libc6-i386 lib32stdc++6

si vous avez une carte nVidia avec les drivers nVidia installés, vous pourriez avoir besoin de:

    sudo apt install libgl1-nvidia-glx:i386
    sudo apt install libgl1-nvidia-glx:i386

(un paquet similaire doit être disponible pour les autres cartes graphiques).

Ajouter un jeu PC ​

Pour ajouter un jeu, il suffit de créer un fichier portant le nom du jeu dans /home/pi/RetroPie/roms/pc, avec l'extension .sh. Exemple:

    touch ~/RetroPie/roms/pc/un_jeu_pc.sh
    touch ~/RetroPie/roms/pc/un_jeu_pc.sh

On rend ensuite ce fichier exécutable:

    chmod +x ~/RetroPie/roms/pc/un_jeu_pc.sh
    chmod +x ~/RetroPie/roms/pc/un_jeu_pc.sh

Puis il faut éditer ce fichier pour y ajouter la commande de lancement du jeu comme suit:

    #!/bin/bash
    kill -USR1 $(cat /tmp/music_player.pid)
    /chemin/absolu/vers/binaire/du/jeu
    kill -USR2 $(cat /tmp/music_player.pid)
    #!/bin/bash
    kill -USR1 $(cat /tmp/music_player.pid)
    /chemin/absolu/vers/binaire/du/jeu
    kill -USR2 $(cat /tmp/music_player.pid)

Si vous n'avez pas suivi le chapitre relatif à la musique de fond du tutoriel Installation de RetroPie sur PC, retirez de votre script les deux lignes qui commencent par kill. Elles servent à interrompre la musique au lancement du jeu, et à la redémarrer lorsque le jeu est terminé.

Quitter les jeux PC ​

Il peut être pratique de quitter un jeu avec une touche dédiée, ou une combinaison de touches, à la manière des autres jeux émulés par RetroPie.

Dans l'exemple ci-dessous, nous avons choisi de presser deux touches simultanément sur notre contrôleur de jeu pour quitter un jeu PC.

Installons tout d'abord les paquets requis:

     sudo apt install joystick xserver-xorg-input-joystick xbindkeys
     sudo apt install joystick xserver-xorg-input-joystick xbindkeys

Pour identifier les touches de notre contrôleur de jeu, nous avons besoin de jstest:

    jstest
    jstest

vous pourrez ainsi voir, lors de la pression sur une touche du contrôleur de jeu, son numéro. Dans notre cas d'exemple, nous utiliserons START et SELECT, dont les codes sont 9 et 8 respectivement.

De la même façon, il va falloir identifier le code des touches clavier CTRL et X. Nous utiliserons xbindkeys pour ça:

    xbindkeys -k
    xbindkeys -k

qui nous révèle le code lors d'un appui touche. Pour CTRL nous obtenons 37, et pour X 53.

À présent, nous allons configurer Xorg de sorte que START et SELECT déclenchent la combinaison de touches CTRL+X. Pour cela, il faut éditer /etc/X11/xorg.conf.d/50-joystick-all.conf et y insérer:

    Section "InputClass"
        Identifier "joystick-all"
        Driver "joystick"
        MatchIsJoystick "on"
        MatchDevicePath "/dev/input/event*"
        Option "StartMouseEnabled" "false"
        Option "MapButton9" "key=37"
        Option "MapButton10" "key=53"
    EndSection
    Section "InputClass"
        Identifier "joystick-all"
        Driver "joystick"
        MatchIsJoystick "on"
        MatchDevicePath "/dev/input/event*"
        Option "StartMouseEnabled" "false"
        Option "MapButton9" "key=37"
        Option "MapButton10" "key=53"
    EndSection

image Note: Il faut ajouter 1 au code de touche donné par jstest, ici nous avons donc MapButton9 et MpaButton10.

À présent nous pouvons configurer tout ça. Nous utiliserons xbindkeys pour déclencher une action sur CTRL+X. Il faut créer le fichier ~/.xbindkeysrc et y insérer:

    "/home/pi/RetroPie/roms/pc/_exit_game.sh"
      Control+Mod2 + x
    "/home/pi/RetroPie/roms/pc/_exit_game.sh"
      Control+Mod2 + x

Nous créons donc également ~/RetroPie/roms/pc/_exit_game.sh avec ce contenu:

bash
    #!/bin/bash

    PIDFILE="/tmp/pc_game.pid"

    # Get all child processes PID
    cpid ()
    {
            local child=$(ps -o pid= --ppid "$1")
            for pid in $child; do
                    cpid "$pid"
            done
            echo "$child"
    }

    if [ -f ${PIDFILE} ]; then
            PID=$(cat ${PIDFILE})
            sudo kill $(cpid $PID)
            sudo kill $PID
            rm ${PIDFILE}
    fi
    #!/bin/bash

    PIDFILE="/tmp/pc_game.pid"

    # Get all child processes PID
    cpid ()
    {
            local child=$(ps -o pid= --ppid "$1")
            for pid in $child; do
                    cpid "$pid"
            done
            echo "$child"
    }

    if [ -f ${PIDFILE} ]; then
            PID=$(cat ${PIDFILE})
            sudo kill $(cpid $PID)
            sudo kill $PID
            rm ${PIDFILE}
    fi

et par la même occasion, nous créons, ~/RetroPie/roms/pc/_run_game.sh:

bash
    #!/bin/bash

    echo $BASHPID > /tmp/pc_game.pid
    "$@"
    #!/bin/bash

    echo $BASHPID > /tmp/pc_game.pid
    "$@"

puis nous rendons ces deux script exécutables:

    chmod +x ~/RetroPie/roms/pc/_run_game.sh
    chmod +x ~/RetroPie/roms/pc/_exit_game.sh
    chmod +x ~/RetroPie/roms/pc/_run_game.sh
    chmod +x ~/RetroPie/roms/pc/_exit_game.sh

Pour lancer un jeu PC, ça se passe légèrement différement de ce que nous avons vu précédemment:

    #!/bin/bash
    kill -USR1 $(cat /tmp/music_player.pid)
    ~/RetroPie/roms/pc/_run_game.sh /chemin/absolu/vers/binaire/du/jeu
    kill -USR2 $(cat /tmp/music_player.pid)
    #!/bin/bash
    kill -USR1 $(cat /tmp/music_player.pid)
    ~/RetroPie/roms/pc/_run_game.sh /chemin/absolu/vers/binaire/du/jeu
    kill -USR2 $(cat /tmp/music_player.pid)

Pour finir, il faut activer xbindkeys au démarrage pour qu'il gère l'action associée à l'appui sur CTRL+X (START+SELECT). Il faut donc créer le fichier ~/.config/autostart/xbindkeys.desktop et y insérer:

    [Desktop Entry]
    Type=Application
    Exec=/usr/bin/xbindkeys
    X-GNOME-Autostart-enabled=true
    Name=xbindkeys
    [Desktop Entry]
    Type=Application
    Exec=/usr/bin/xbindkeys
    X-GNOME-Autostart-enabled=true
    Name=xbindkeys

Redémarrez la session X pour prendre tous ces paramètres en compte.

Support des manettes et joysticks ​

Certains jeux supportent mal, ou pas du tout, les manettes (et les joysticks). Pour ces cas-là, nous pouvons utiliser Padmapper ou bien Antimicro.

Padmapper s'utilise uniquement en ligne de commande, et se configure en éditant un fichier de configuration. C'est un projet associé au projet VersusBox.

Antimicro s'utilise via une interface graphique.

Padmapper ​

Padmapper est un outil pour Linux qui permet de simuler le clavier et la souris à partir de manettes de jeu. Il devient donc possible de presser des touches du clavier à partir de boutons d'une manette, et de déplacer la souris à partir d'un joystick.

Installation:

sudo pip install padmapper
sudo pip install padmapper

Nous allons créer une configuration et des profils de manettes pour chaque jeu indépendamment.

Vous pouvez, à ce stade, lancer le jeu, et noter la configuration par défaut des touches, ça nous sera utile pour paramétrer notre cartographique de manette.

Ensuite vous pouvez lancer l'outil de capture pour avoir les identifiants des boutons de votre manette:

padmapper-capture
padmapper-capture

Suivez ensuite la documentation officielle sur la page GitHub de Padmapper pour évrire un fichier de configuration pour votre jeu.

Placez votre fichier de configuration ici: /home/pi/RetroPie/roms/pc/<nom_du_jeu>/padmapper.json.

Le script de lancement du jeu, tel que décrit au chapitre Ajouter un jeu PC, devra ressembler à ceci:

bash
    #!/bin/bash

    WORKING_DIR="/home/pi/RetroPie/roms/pc/<nom_du_jeu>"
    export XDG_CONFIG_HOME="${WORKING_DIR}"

    # Arret de la musique
    kill -USR1 $(cat /tmp/music_player.pid)

    echo $BASHPID > /tmp/pc_game.pid
    padmapper /home/pi/RetroPie/roms/pc/<nom_du_jeu>/padmapper.json &
    PADMAPPER_PID=$!

    # Lancement du jeu
    ${WORKING_DIR}/<executable>

    # Stoppe padmapper et redemarre la musique
    kill -9 $PADMAPPER_PID
    kill -USR2 $(cat /tmp/music_player.pid)
    #!/bin/bash

    WORKING_DIR="/home/pi/RetroPie/roms/pc/<nom_du_jeu>"
    export XDG_CONFIG_HOME="${WORKING_DIR}"

    # Arret de la musique
    kill -USR1 $(cat /tmp/music_player.pid)

    echo $BASHPID > /tmp/pc_game.pid
    padmapper /home/pi/RetroPie/roms/pc/<nom_du_jeu>/padmapper.json &
    PADMAPPER_PID=$!

    # Lancement du jeu
    ${WORKING_DIR}/<executable>

    # Stoppe padmapper et redemarre la musique
    kill -9 $PADMAPPER_PID
    kill -USR2 $(cat /tmp/music_player.pid)

Remplacez <nom_du_jeu> par le nom du répertoire du jeu, et <executable> par le nom de l'exécutable.

Antimicro ​

Antimicro est une application permettant de simuler des appuis de touches de clavier lorsque l'on actionne une manette. La méthode ci-dessous fonctionne pour deux manettes permettant à deux joueurs de jouer au même jeu.

Commençons par récupérer et installer Antimicro, vous pouvez trouver une version à jour pour Debian ici: https://packages.libregeek.org/debian/pool/main/a/antimicro/

Téléchargez-là, puis installez-là avec:

    sudo dpkg -i antimicro_X.Y.deb
    sudo dpkg -i antimicro_X.Y.deb

Nous allons créer une configuration et des profils de manettes pour chaque jeu indépendamment.

Vous pouvez, à ce stade, lancer le jeu, et noter la configuration par défaut des touches, ça nous sera utile pour paramétrer notre cartographique de manette.

Ensuite, lancez Antimicro comme suit:

    XDG_CONFIG_HOME=/home/pi/RetroPie/roms/pc/<nom_du_jeu> antimicro
    XDG_CONFIG_HOME=/home/pi/RetroPie/roms/pc/<nom_du_jeu> antimicro

ce qui va démarrer une interface de configuration.

Si les caractères sont trop petits et peu lisibles, vous pouvez relancer cette interface avec:

    XDG_CONFIG_HOME=/home/pi/RetroPie/roms/pc/<nom_du_jeu> QT_SCALE_FACTOR=2 antimicro
    XDG_CONFIG_HOME=/home/pi/RetroPie/roms/pc/<nom_du_jeu> QT_SCALE_FACTOR=2 antimicro

Il faut tout d'abord paramétrer vos manettes. Si elles sont identiques, un seul paramétrage suffit, sinon il faut le faire pour chacune. Allez dans le menu Options puis [Cartographie de contrôleur de jeu]{.title-ref}. Renseignez alors chaque touche. Vous pouvez assigner Retour]{.title-ref} à votre touche [Select.

Cartographie de contrôleur de jeu

De retour dans l'interface principale, vous trouverez autant d'onglets que de manettes connectées. Vous pouvez alors, pour chaque touche de la manette, définir quelle touche du clavier sera simulée. Vous pouvez définir l'action de Retour à la touche ECHAP]{.title-ref} et l'action de [Start à la touche ENTREE.

Correspondance contrôleurs et touches simulées

Sauvegarder, pour chaque onglet de manette, le profil avec le bouton Enregistrer. Sauvez les profils dans un répertoire /home/pi/RetroPie/roms/pc/<nom_du_jeu>/antimicro

Enfin, rendez-vous dans le menu Options puis Paramètres, dans l'onglet général assurez-vous que la case permettant de charger automatiquement le dernier profil utilisé est cochée. Vous pouvez alors quitter Antimicro.

Le script de lancement du jeu, tel que décrit au chapitre Ajouter un jeu PC, devra ressembler à ceci:

bash
    #!/bin/bash

    WORKING_DIR="/home/pi/RetroPie/roms/pc/<nom_du_jeu>"
    export XDG_CONFIG_HOME="${WORKING_DIR}"

    # Arret de la musique
    kill -USR1 $(cat /tmp/music_player.pid)

    # Assignation du controleur 1 au profil p1
    antimicro --hidden --no-tray --profile-controller 1 \
       ${WORKING_DIR}/antimicro<nom_manette_1>.gamecontroller.amgp &
    kill $!
    # Assignation du controleur 2 au profil p2
    # Le profil p1 est pre-charge car il etait le dernier profil utilise
    antimicro --hidden --no-tray --profile-controller 2 \
       ${WORKING_DIR}/antimicro/<nom_manette_2>.gamecontroller.amgp &
    ANTIMICRO_PID=$!

    # Lancement du jeu
    ${WORKING_DIR}/<executable>

    # Stoppe Antimicro et redemarre la musique
    kill $ANTIMICRO_PID
    kill -USR2 $(cat /tmp/music_player.pid)
    #!/bin/bash

    WORKING_DIR="/home/pi/RetroPie/roms/pc/<nom_du_jeu>"
    export XDG_CONFIG_HOME="${WORKING_DIR}"

    # Arret de la musique
    kill -USR1 $(cat /tmp/music_player.pid)

    # Assignation du controleur 1 au profil p1
    antimicro --hidden --no-tray --profile-controller 1 \
       ${WORKING_DIR}/antimicro<nom_manette_1>.gamecontroller.amgp &
    kill $!
    # Assignation du controleur 2 au profil p2
    # Le profil p1 est pre-charge car il etait le dernier profil utilise
    antimicro --hidden --no-tray --profile-controller 2 \
       ${WORKING_DIR}/antimicro/<nom_manette_2>.gamecontroller.amgp &
    ANTIMICRO_PID=$!

    # Lancement du jeu
    ${WORKING_DIR}/<executable>

    # Stoppe Antimicro et redemarre la musique
    kill $ANTIMICRO_PID
    kill -USR2 $(cat /tmp/music_player.pid)

Remplacez <nom_du_jeu> par le nom du répertoire du jeu, <nom_manette_1>, <nom_manette_2> par les noms des fichiers de profils précédemment sauvés pour chaque manette, et <executable> par le nom de l'exécutable.

image Note: La méthode présentée dans ce script est un contournement, car la version d'Antimicro utilisée pour réaliser ce tutoriel ne permettait pas de charger plusieurs profils en ligne de commande, l'option -d de ce dernier, pour le lancer en tant que démon, étant bugguée.

Forcer la désactivation des contrôleurs dans un jeu ​

Si votre jeu avait un support des contrôleurs, même mauvais, vous devrez désactiver le support des contrôleurs dans votre jeu. En effet, si le jeu réagit à certains événements des contrôleurs, ça pourrait entrer en conflit avec les commandes relayées par Padmapper ou Antimicro, et perturber le bon fonctionnement du jeu.

Si votre jeu ne permet pas de désactiver le support des contrôleurs, suivez la solution suivante.

La solution proposée ici consiste à exécuter le jeu par le biais d'un autre utilisateur que l'utilisateur pi, cet utilisateur ne sera pas présent dans le groupe input et ne sera donc pas capable de lire les entrées des contrôleurs.

On commence par ajouter un nouvel utilisateur qui sera dédié à l'exécution de ces jeux, on nomme cette utilisateur user_noctrl:

    sudo useradd -m -d /home/pi/RetroPie/roms/pc/user_noctrl -G video,audio user_noctrl -s /bin/bash
    sudo useradd -m -d /home/pi/RetroPie/roms/pc/user_noctrl -G video,audio user_noctrl -s /bin/bash

Pour chaque jeu concerné, changez les permissions sur ses fichiers:

    sudo chown -R user_noctrl /home/pi/RetroPie/roms/pc/<nom_du_jeu>/<fichiers_du_jeu>
    sudo chown -R user_noctrl /home/pi/RetroPie/roms/pc/<nom_du_jeu>/<fichiers_du_jeu>

et modifiez le script de lancement du jeu pour qu'il soit exécuté de cette façon:

bash
    [...]
    # Lancement du jeu
    chmod o+rw ~/.Xauthority
    sudo -u user_noctrl "${WORKING_DIR}/<executable>"
    [...]
    [...]
    # Lancement du jeu
    chmod o+rw ~/.Xauthority
    sudo -u user_noctrl "${WORKING_DIR}/<executable>"
    [...]

Pour que l'utilisateur user_noctrl ait accès à l'audio sans problèmes, éditez /etc/pulse/default.pa et ajoutez-y à la fin:

    load-module module-native-protocol-unix auth-anonymous=1 socket=/tmp/pulse-socket
    load-module module-native-protocol-unix auth-anonymous=1 socket=/tmp/pulse-socket

ce qui permettra à user_noctrl d'accéder au démon audio via un socket UNIX.

Il faut ensuite modifier la configuration Pulse de user_noctrl pour qu'il utilise ce socket. Connectez-vous au shell en tant que user_noctrl:

    sudo -u user_noctrl -s
    sudo -u user_noctrl -s

et exécutez:

    mkdir -p .config/pulse
    mkdir -p .config/pulse

puis éditez ~/.config/pulse/client.conf pour y insérer:

    default-server = unix:/tmp/pulse-socket
    default-server = unix:/tmp/pulse-socket

et faites CTRL+D pour sortir du shell de user_noctrl, rebootez, et les utilisateurs pi et user_noctrl auront accès à l'audio simultanément.

Voilà, le jeu n'a plus accès aux contrôleurs de jeux, seulement au clavier et à la souris.

D'autres méthodes sont listées sur le wiki d'Antimicro.

Ajouter un jeu Steam ​

Dans la procédure ci-dessous, on considère qu'il n'y a pas Steam sur le PC RetroPie, et que l'on copie les jeux souhaités depuis une autre machine sur laquelle Steam est installé. En effet, nous ne souhaitons pas ici passer par l'interface de Steam pour lancer notre jeu, nous souhaitons y accéder par notre interface EmulationStation.

L'installation de Steam sur la machine n'est pas nécessairement requise, si le jeu souhaité n'utilise pas de fonctionnalités de l'API Steam. Certains jeux ne fonctionneront donc pas sans Steam. Des jeux utilisant Steam DRM peuvent cependant fonctionner, même si Steam n'est pas présent sur la machine.

Seuls les jeux Steam compatible Linux sont supportés.

image Attention: Cette procédure ne vise pas à aider au piratage de jeux, vous devez avoir acquis le jeu sur la plateforme Steam pour l'utiliser ensuite sur votre PC de jeu RetroPie.

Copier le jeu Steam vers le PC RetroPie ​

Sur le PC Steam, les jeux se situent dans votre répertoire:

/home/\<nom\_utilisateur\>/.local/share/Steam/SteamApps/common

Copiez simplement le dossier de votre jeu sur votre machine RetroPie, à l'endroit de votre choix.

Ajouter le jeu dans la collection PC d'EmulationStation ​

Suivez la procédure Ajouter un jeu PC détaillée précédemment. L'exécutable du jeu se situe dans le dossier précédemment copié, et est spécifique à chaque jeu, à vous de l'identifier.

Dépendances ​

Certains jeux Steam peuvent dépendre de certaines librairies que l'on trouve habituellement sur un système Ubuntu, pour lequel est prévu Steam à l'origine.

Vous pouvez installer les librairies suivantes, qui pourraient s'avérer utiles:

    sudo apt install libgtk2.0 libxtst6:i386 libxrandr2:i386 libglib2.0-0:i386 \
    libgtk2.0-0:i386 libpulse0:i386 libgdk-pixbuf2.0-0:i386 \
    libcurl4-openssl-dev:i386 libopenal1:i386 libusb-1.0-0:i386 \
    libdbus-glib-1-2:i386 libnm-glib4:i386 libnm-util2:i386
    sudo apt install libgtk2.0 libxtst6:i386 libxrandr2:i386 libglib2.0-0:i386 \
    libgtk2.0-0:i386 libpulse0:i386 libgdk-pixbuf2.0-0:i386 \
    libcurl4-openssl-dev:i386 libopenal1:i386 libusb-1.0-0:i386 \
    libdbus-glib-1-2:i386 libnm-glib4:i386 libnm-util2:i386

Dépendance sur l'API Steam ​

Certains jeux dépendent de l'API Steam. Vous pouvez en général le constater facilement, si vous trouvez une instance de libsteam_api.so dans le répertoire du jeu. Bien souvent cette dépendance empêchera le jeu de fonctionner si Steam n'est pas installé. Et si Steam est installé, cette librairie a la facheuse tendance de lancer son interface, ce qui n'est pas souhaitable dans notre environnement RetroPie.

Cependant, de nombreux jeux ont une utilisation limitée de l'API Steam, et selon vos besoins vous pourriez vouloir vous en passer. Pour cela, il est possible d'utiliser Goldberg Steam Emulator.

Goldberg Steam Emulator est une API Steam "bête": elle va se comporter comme l'API Steam, mais sans aucune intelligence, elle retournera donc au jeu des données vides ou des valeurs par défaut. Par exemple, il n'est pas possible avec elle d'avoir sa liste d'amis Steam accessible dans le jeu: elle retournera simplement une liste vide.

Vous pouvez télécharger Goldberg Steam Emulator sur sa page officielle: https://gitlab.com/Mr_Goldberg/goldberg_emulator. Vous y trouverez des versions pré-compilées.

Vous devez ensuite déterminer si votre jeu est 32 ou 64 bits. La commande file sur l'exécutable du jeu vous donnera cette information.

Remplacez, dans le répertoire de votre jeu, libsteam_api.so par la bonne version fournie par `Goldberg Steam Emulator`: 32-bits ou 64-bits, suivant si votre jeu est 32 ou 64 bits.

Créez un fichier steam_appid.txt dans le même répertoire que libsteam_api.so, et remplissez ce fichier avec l'APP ID du jeu. Vous pouvez trouver ce numéro dans l'URL de la page du jeu sur le site de Steam.

Pour que les sauvegardes soient placées dans le répertoire du jeu, créez un fichier local_save.txt dans le même répertoire que libsteam_api.so, et remplissez ce fichier avec le nom du répertoire dans lequel les sauvegardes doivent aller (par exemple: "save").

Lisez le Readme.txt de Goldberg Steam Emulator pour connaître toutes les options.

Avancé ​

Cette section s'adresse à des utilisateurs d'un niveau plus avancé, qui veulent tenter de faire fonctionner sans Steam des jeux plus récalcitrants.

Si l'un de vos jeux ne démarre pas correctement, vous pouvez commencer par vérifier s'il ne lui manque aucune librairie:

    ldd executable_du_jeu
    ldd executable_du_jeu

LDD vous informera si une librairie est manquante. Vous pouvez ensuite chercher si la librairie est fournie par un paquet Debian en la recherchant sur https://packages.debian.org, section Search the contents of packages, et installer l'éventuel paquet.

D'autres librairies peuvent-être dynamiquement chargées pendant l'exécution du jeu. Vous pourrez les identifier avec la commande suivante:

    strace -f executable\_du\_jeu
    strace -f executable\_du\_jeu

Cette commande donne énormément d'informations peu digestes au sujet des appels système que le jeu effectue, elle peut vous permettre d'identifier un fichier manquant au jeu.