Installation d'un serveur NetHack 5.0.0 (branche cybernethack) avec dgamelaunch sous LXD

1er novembre 2026

Ce tutoriel monte un serveur NetHack public accessible en SSH. Le jeu est compilé depuis la branche cybernethack de HackTechDev/Nethack500_Lubuntu2604, sous l'utilisateur util01, et installé dans ~/nethack500. Il est ensuite servi par dgamelaunch dans un chroot, à l'intérieur d'un conteneur LXD.

Vue d'ensemble

Joueur (ssh -p 2222 nethack@ton-serveur)
  │
Hôte Lubuntu 26.04 ── proxy LXD tcp:2222 → conteneur:22
  │
Conteneur LXD « nethack »
  │  sshd → compte « nethack » sans mot de passe → ForceCommand dgamelaunch
  │
  ├── /home/util01/Nethack500_Lubuntu2604   sources (branche cybernethack)
  ├── /home/util01/nethack500               jeu installé (usage local de util01)
  ├── /home/util01/bin/nethack              script de lancement local
  │
  └── /opt/nethack/
       ├── dgamelaunch                      binaire setuid root
       ├── dgamelaunch.conf
       └── chroot/
            ├── home/util01/nethack500/     copie du jeu servie aux joueurs
            ├── dgldir/                     comptes, ttyrec, dumplogs, rcfiles
            └── lib/, usr/, etc/            bibliothèques, terminfo, locales

Le chemin /home/util01/nethack500 est gravé dans le binaire à la compilation. Le chroot reproduit donc exactement ce chemin. Dans le chroot, les parties tournent sous l'uid de util01, propriétaire des fichiers du jeu.

Qui lance quoi :

Étape	Utilisateur
1. Installation de LXD	ton compte sur l'hôte
2. Conteneur LXD	ton compte sur l'hôte
3. Paquets	root (conteneur)
4. Compilation et installation de NetHack	`util01`
5. Compilation de dgamelaunch	`util01`, installation en root
6 à 8. Chroot, configuration, SSH	root (conteneur)
9. Mise à jour	hôte, `util01` puis root

1. Installation de LXD

Installer le socle snap core, puis LXD en version LTS 6.0, et vérifier la version installée :

util01@ordilocal:~$ sudo snap install core
util01@ordilocal:~$ sudo snap install lxd --channel=6.0/stable
util01@ordilocal:~$ lxd --version
6.10.1 LTS

Si un ancien LXD (4.0 par exemple) est déjà installé, snap install ne fait rien : le mettre à jour à la place :

util01@ordilocal:~$ sudo snap refresh lxd --channel=6.0/stable

Initialiser LXD avec les réglages par défaut (pont réseau lxdbr0 et stockage) :

util01@ordilocal:~$ sudo lxd init --minimal

2. Conteneur LXD (sur l'hôte)

Ajouter l'utilisateur util01 dans le groupe lxd :

util01@ordilocal:~$ sudo usermod -aG lxd util01
util01@ordilocal:~$ newgrp lxd
util01@ordilocal:~$ lxc list

Se déconnecter et se reconnecter.
Créer le conteneur nethack à partir de l'image Ubuntu 26.04 :

util01@ordilocal:~$ lxc launch ubuntu:26.04 nethack
Launching nethack
util01@ordilocal:~$

Limiter le conteneur à 2 processeurs et 1 Gio de mémoire :

util01@ordilocal:~$ lxc config set nethack limits.cpu 2
util01@ordilocal:~$ lxc config set nethack limits.memory 1GiB

Vérifier que le conteneur tourne et qu'il a reçu une adresse IP :

util01@ordilocal:~$ lxc list
+---------+---------+---------------------+-----------------------------------------------+-----------+-----------+
|  NAME   |  STATE  |        IPV4         |                     IPV6                      |   TYPE    | SNAPSHOTS |
+---------+---------+---------------------+-----------------------------------------------+-----------+-----------+
| nethack | RUNNING | 10.42.86.225 (eth0) | fd42:30fa:ec0d:4af5:216:3eff:fe96:af86 (eth0) | CONTAINER | 0         |
+---------+---------+---------------------+-----------------------------------------------+-----------+-----------+
util01@ordilocal:~$

Rediriger le port 2222 de l'hôte vers le port SSH (22) du conteneur :

util01@ordilocal:~$ lxc config device add nethack ssh-nethack proxy listen=tcp:0.0.0.0:2222 connect=tcp:127.0.0.1:22
Device ssh-nethack added to nethack
util01@ordilocal:~$

Ouvrir un shell root dans le conteneur nethack :

util01@ordilocal:~$ lxc exec nethack -- bash
root@nethack:~#

Créer l'utilisateur de compilation util01 dans le conteneur :

root@nethack:~# adduser util01

3. Paquets (root, dans le conteneur)

Mettre le système à jour et installer les outils de compilation (NetHack et dgamelaunch), SQLite, le serveur SSH, rsync et quelques utilitaires :

root@nethack:~# apt update && apt full-upgrade -y
root@nethack:~# apt install -y git gcc make curl gettext libncurses-dev \
    build-essential autoconf automake bison flex \
    libsqlite3-dev sqlite3 openssh-server rsync \
    mc vim btop

4. Installation de NetHack 5.0.0

4.1 Récupérer la branche

Passer sous l'utilisateur util01 :

root@nethack:~# su - util01
util01@nethack:~$

Créer le dossier ~/bin, qui recevra le script de lancement du jeu :

util01@nethack:~$ mkdir -p ~/bin

Cloner la branche cybernethack du dépôt :

util01@nethack:~$ git clone --branch cybernethack https://github.com/HackTechDev/Nethack500_Lubuntu2604.git

Entrer dans le dossier des sources :

util01@nethack:~$ cd Nethack500_Lubuntu2604
util01@nethack:~/Nethack500_Lubuntu2604$

4.2 Installer dans `~/nethack500`

Par défaut, le dépôt installe dans ~/nh/install/.... Deux fichiers sont à adapter :

sys/unix/hints/linux.500 : chemins compilés dans le jeu
install.sh : dossier dont il sauvegarde et restaure les parties
Modifier les chemins d'installation dans le fichier hints : jeu dans ~/nethack500, script de lancement dans ~/bin :

util01@nethack:~/Nethack500_Lubuntu2604$ sed -i \
  -e 's|^PREFIX=\$(wildcard ~)/nh/install$|PREFIX=/home/util01|' \
  -e 's|^HACKDIR=\$(PREFIX)/games/lib/nethackdir$|HACKDIR=/home/util01/nethack500|' \
  -e 's|^SHELLDIR = \$(PREFIX)/games$|SHELLDIR = /home/util01/bin|' \
  sys/unix/hints/linux.500

Adapter install.sh au nouveau dossier, pour la sauvegarde et la restauration des parties et pour les messages de fin :

util01@nethack:~/Nethack500_Lubuntu2604$ sed -i \
  -e 's|^HACKDIR="\$HOME/nh/install/games/lib/nethackdir"$|HACKDIR="$HOME/nethack500"|' \
  -e 's|~/nh/install/games/nethack|~/bin/nethack|g' \
  install.sh

Vérifier que seuls ces deux fichiers ont été modifiés :

util01@nethack:~/Nethack500_Lubuntu2604$ git diff --stat
 install.sh               | 8 ++++----
 sys/unix/hints/linux.500 | 6 +++---
 2 files changed, 7 insertions(+), 7 deletions(-)
util01@nethack:~/Nethack500_Lubuntu2604$

Contrôler les chemins pris en compte (lignes 421 à 430) :

util01@nethack:~/Nethack500_Lubuntu2604$ grep -nE '^(PREFIX|HACKDIR|SHELLDIR|VARDIR)' sys/unix/hints/linux.500
411:PREFIX=$(abspath $(NHSROOT))
413:HACKDIR=$(PREFIX)/playground
416:VARDIRPERM = 0700
421:PREFIX=/home/util01
422:HACKDIR=/home/util01/nethack500
423:SHELLDIR = /home/util01/bin
424:VARDIRPERM = 0755
430:VARDIR = $(HACKDIR)
util01@nethack:~/Nethack500_Lubuntu2604$

4.3 Compiler et installer

Compiler et installer le jeu avec les interfaces tty et curses :

util01@nethack:~/Nethack500_Lubuntu2604$ ./install.sh --console

Le script configure le build avec hints/linux.500, télécharge Lua, compile, sauvegarde les parties existantes, installe, puis copie config/nethackrc dans ~/.nethackrc.

Lancer le jeu en local pour le tester, en partie normale puis en mode debug :

util01@nethack:~/Nethack500_Lubuntu2604$ ~/bin/nethack           # partie normale
util01@nethack:~/Nethack500_Lubuntu2604$ ~/bin/nethack -D        # mode debug (util01 est dans WIZARDS)

5. Installation de dgamelaunch

Revenir dans le dossier personnel de util01 :

util01@nethack:~/Nethack500_Lubuntu2604$ cd ~
util01@nethack:~$

Cloner les sources de dgamelaunch :

util01@nethack:~$ git clone https://github.com/paxed/dgamelaunch.git

Entrer dans le dossier des sources :

util01@nethack:~$ cd dgamelaunch

Configurer la compilation : comptes SQLite, mémoire partagée, emplacement du fichier de config, et options GCC tolérantes pour ce code ancien :

util01@nethack:~/dgamelaunch$ ./autogen.sh --enable-sqlite --enable-shmem \
    --with-config-file=/opt/nethack/dgamelaunch.conf \
    CFLAGS="-O2 -std=gnu17 -fcommon \
      -Wno-error=implicit-function-declaration \
      -Wno-error=incompatible-pointer-types \
      -Wno-error=int-conversion"

Compiler dgamelaunch :

util01@nethack:~/dgamelaunch$ make

Revenir en root :

util01@nethack:~/dgamelaunch$ exit
logout
root@nethack:~#

Créer le dossier d'installation. Le binaire doit être setuid root pour entrer dans le chroot, puis il abandonne ses privilèges :

root@nethack:~# mkdir -p /opt/nethack

Installer le binaire en setuid root (droits 4755) :

root@nethack:~# install -o root -g root -m 4755 /home/util01/dgamelaunch/dgamelaunch /opt/nethack/

6. Le chroot (root)

6.1 Script de base

Aller dans le dossier des sources de dgamelaunch :

root@nethack:~# cd /home/util01/dgamelaunch

Ouvrir le script de création du chroot dans un éditeur :

root@nethack:/home/util01/dgamelaunch# vim dgl-create-chroot

Remplacer les variables en tête du script par :

CHROOT="/opt/nethack/chroot/"
USRGRP="util01:util01"
COMPRESSBIN="/bin/gzip"
SQLITE_DBFILE="/dgldir/dgamelaunch.db"
NETHACKBIN="/home/util01/nethack500/nethack"
NH_PLAYGROUND_FIXED="/home/util01/nethack500/"
NHSUBDIR="/home/util01/nethack500/"
NH_VAR_PLAYGROUND="/home/util01/nethack500/"

Neutraliser la ligne mknod du script : la création de fichiers spéciaux est interdite dans un conteneur non privilégié ; /dev/urandom sera fourni par LXD plus bas :

root@nethack:/home/util01/dgamelaunch# sed -i 's/^mknod urandom c 1 9$/: # urandom fourni par LXD (unix-char)/' dgl-create-chroot

Corriger le script pour qu'il crée les dossiers parents du chemin du jeu (mkdir -p) :

root@nethack:/home/util01/dgamelaunch# sed -i 's|^mkdir "\$CHROOT/\$NHSUBDIR"$|mkdir -p "$CHROOT/$NHSUBDIR"|' dgl-create-chroot

Vérifier que la correction est en place :

root@nethack:/home/util01/dgamelaunch# grep -n 'mkdir -p "\$CHROOT/\$NHSUBDIR"' dgl-create-chroot                                                                                                                   
157:mkdir -p "$CHROOT/$NHSUBDIR"

Supprimer un éventuel chroot créé lors d'un essai précédent, pour repartir propre :

root@nethack:/home/util01/dgamelaunch# rm -rf /opt/nethack/chroot

Lancer la création du chroot :

root@nethack:/home/util01/dgamelaunch# ./dgl-create-chroot                                                                                                                                                          
Setting up chroot in /opt/nethack/chroot                                                                                                                                                                            
Creating SQLite database at /dgldir/dgamelaunch.db                                                                                                                                                                  
Copying /bin/gzip to bin                                                                                                                                                                                            
Edit /opt/nethack/chroot/etc/dgamelaunch.conf to suit your needs.                                                                                                                                                   
Copied text editors 'ee' and 'virus' to chroot.
Copying /home/util01/nethack500/nethack
Copying NetHack playground stuff.
cp: cannot stat '/home/util01/nethack500/*.lev': No such file or directory
root@nethack:/home/util01/dgamelaunch#

Le script s'arrête sur cp: cannot stat '*.lev' : c'est normal en 5.0, ces fichiers de la 3.4.3 n'existent plus. Ce qu'il n'a pas fait (copie complète du jeu, bibliothèques, terminfo) est complété à la main à l'étape 6.2.

Quitter le conteneur pour revenir sur l'hôte :

root@nethack:~# exit
exit
util01@ordilocal:~$

Depuis l'hôte, créer /dev/urandom dans le chroot (mknod est interdit dans un conteneur non privilégié) :

util01@ordilocal:~$ lxc config device add nethack chroot-urandom unix-char source=/dev/urandom path=/opt/nethack/chroot/dev/urandom mode=0666
Device chroot-urandom added to nethack
util01@ordilocal:~$

Vérifier que /dev/urandom existe bien dans le chroot :

util01@ordilocal:~$ lxc exec nethack -- ls -l /opt/nethack/chroot/dev/urandom
crw-rw-rw- 1 root root 1, 9 Nov  1 08:46 /opt/nethack/chroot/dev/urandom
util01@ordilocal:~$

Si le chroot est un jour supprimé (rm -rf /opt/nethack/chroot), /dev/urandom et /dev/null disparaissent avec lui : un lxc restart nethack sur l'hôte les fait recréer par LXD.

6.2 Compléments pour NetHack 5.0

Le script date de NetHack 3.4.3 : on copie à la main le jeu complet et ce dont il a besoin.

Revenir dans le conteneur en root :

util01@ordilocal:~$ lxc exec nethack -- bash
root@nethack:~#

Définir les variables de chemin : racine du chroot (C) et dossier du jeu (NH) :

root@nethack:~# C=/opt/nethack/chroot
root@nethack:~# NH=/home/util01/nethack500

Copier le jeu complet dans le chroot (binaire, nhdat, fr.mo, aides traduites, sysconf…) :

root@nethack:~# mkdir -p $C$NH
root@nethack:~# rsync -a $NH/ $C$NH/

Créer les répertoires de dgamelaunch et les donner à util01 :

root@nethack:~# mkdir -p $C/dgldir/{inprogress-nh500,userdata,ttyrec,rcfiles} $C/mail
root@nethack:~# chown -R util01:util01 $C/dgldir $C/mail $C/home/util01

Copier dans le chroot les bibliothèques utilisées par le binaire :

root@nethack:~# for lib in $(ldd $NH/nethack | grep -o '/[^ ]*'); do
    mkdir -p "$C$(dirname $lib)"; cp -n "$lib" "$C$lib"
done

Vérifier qu'aucune bibliothèque ne manque :

root@nethack:~# for lib in $(ldd $NH/nethack | grep -o '/[^ ]*'); do
    [ -e "$C$lib" ] && echo "OK  $lib" || echo "MANQUE $lib"
done
OK  /usr/lib/x86_64-linux-gnu/libncursesw.so.6
OK  /usr/lib/x86_64-linux-gnu/libtinfo.so.6
OK  /usr/lib/x86_64-linux-gnu/libm.so.6
OK  /usr/lib/x86_64-linux-gnu/libc.so.6
OK  /lib64/ld-linux-x86-64.so.2
root@nethack:~#

Copier terminfo, le fuseau horaire et les locales UTF-8 (symboles Unicode, accents) :

root@nethack:~# mkdir -p $C/usr/share $C/usr/lib $C/lib $C/etc
root@nethack:~# cp -a /usr/share/terminfo $C/usr/share/
root@nethack:~# [ -d /lib/terminfo ] && cp -a /lib/terminfo $C/lib/
root@nethack:~# cp /etc/localtime $C/etc/
root@nethack:~# cp -a /usr/lib/locale $C/usr/lib/

6.3 sysconf du serveur

Le sysconf du chroot est indépendant de celui de util01. On le règle pour le serveur.

Tous les joueurs tournent sous l'uid util01. Avec CHECK_PLNAME=1, WIZARDS est comparé au pseudo dgamelaunch et non au compte Unix. Sans cette option, WIZARDS=util01 donnerait le mode debug à tous les joueurs.

Réserver le mode debug à ton pseudo (ici sam), comparer WIZARDS au pseudo, et enregistrer un récapitulatif texte de chaque partie :

root@nethack:~# sed -i -e 's|^WIZARDS=.*|WIZARDS=sam|' -e 's|^#CHECK_PLNAME=1|CHECK_PLNAME=1|' \
       -e 's|^#DUMPLOGFILE=.*|DUMPLOGFILE=/dgldir/userdata/%n/dumplog/%t.txt|' $C$NH/sysconf

Vérifier ces réglages (SHELLERS doit rester commenté, pour que personne ne puisse ouvrir un shell avec !) :

root@nethack:~# grep -nE '^#?(WIZARDS|CHECK_PLNAME|DUMPLOGFILE|SHELLERS)=' $C$NH/sysconf
16:WIZARDS=sam
33:#SHELLERS=
47:CHECK_PLNAME=1
141:DUMPLOGFILE=/dgldir/userdata/%n/dumplog/%t.txt

Pour d'autres réglages, ouvrir le sysconf du chroot dans un éditeur :

root@nethack:~# vim $C$NH/sysconf

6.4 Test direct

Les options GDBPATH et GREPPATH servent à produire un rapport de débogage avec gdb si le jeu plante. Sur le serveur, il vaut mieux les désactiver plutôt que de copier grep et gdb dans le chroot, et garder seulement la trace par la libc.

Définir la variable S, chemin du sysconf du chroot :

root@nethack:~# S=/opt/nethack/chroot/home/util01/nethack500/sysconf

Commenter GDBPATH et GREPPATH, et désactiver la trace par gdb :

root@nethack:~# sed -i -e 's|^GDBPATH=|#GDBPATH=|' \
       -e 's|^GREPPATH=|#GREPPATH=|' \
       -e 's|^PANICTRACE_GDB=1|PANICTRACE_GDB=0|' "$S"

Vérifier les lignes modifiées :

root@nethack:~# grep -nE 'GDBPATH|GREPPATH|PANICTRACE' "$S"
152:# if the program is built with the PANICTRACE compile-time option enabled.
153:# By default PANICTRACE is enabled if (NH_DEVEL_STATUS != NH_STATUS_RELEASED),
159:#GDBPATH=/usr/bin/gdb
160:#GREPPATH=/bin/grep
163:PANICTRACE_GDB=0
164:PANICTRACE_LIBC=2
root@nethack:~#

Redéfinir la variable C (racine du chroot) :

root@nethack:~# C=/opt/nethack/chroot

Copier libgcc_s.so.1 dans le chroot ; la libc en a besoin pour afficher la trace en cas de crash :

root@nethack:~# for f in /lib/x86_64-linux-gnu/libgcc_s.so.1 /usr/lib/x86_64-linux-gnu/libgcc_s.so.1; do
    [ -e "$f" ] && mkdir -p "$C$(dirname $f)" && cp "$f" "$C$f"
done

Créer un /etc/passwd minimal dans le chroot (root et util01), pour que le jeu trouve le nom du compte :

root@nethack:~# grep -E '^(root|util01):' /etc/passwd > $C/etc/passwd

Créer de même un /etc/group minimal :

root@nethack:~# grep -E '^(root|util01):' /etc/group  > $C/etc/group

Quitter le conteneur pour revenir sur l'hôte :

root@nethack:~# exit

Depuis l'hôte, créer /dev/null dans le chroot :

util01@ordilocal:~$ lxc config device add nethack chroot-null unix-char source=/dev/null path=/opt/nethack/chroot/dev/null mode=0666
Device chroot-null added to nethack

Revenir dans le conteneur en root :

util01@ordilocal:~$ lxc exec nethack -- bash

Lancer le jeu dans le chroot sous l'utilisateur util01, pour tester :

root@nethack:~# LANG=C.UTF-8 chroot --userspec=util01:util01 /opt/nethack/chroot /home/util01/nethack500/nethack -u test

7. Configuration de dgamelaunch (root)

7.1 Fichiers de départ

Aller dans le dossier des sources de dgamelaunch :

root@nethack:~# cd /home/util01/dgamelaunch
root@nethack:/home/util01/dgamelaunch#

Définir la variable C (racine du chroot) :

root@nethack:/home/util01/dgamelaunch# C=/opt/nethack/chroot

Copier la configuration d'exemple dans /opt/nethack :

root@nethack:/home/util01/dgamelaunch# cp examples/dgamelaunch.conf /opt/nethack/dgamelaunch.conf

Copier les menus et la bannière d'exemple dans le chroot :

root@nethack:/home/util01/dgamelaunch# cp examples/dgl_menu_*.txt examples/dgl-banner $C/ 2>/dev/null

Remplacer les références à NetHack 3.4.3 par NetHack 5.0.0 et par le chemin du jeu :

root@nethack:/home/util01/dgamelaunch# sed -i -e 's|/nh343/nethack|/home/util01/nethack500/nethack|g' \
       -e 's/nh343/nh500/g' -e 's/NH343/NH500/g' -e 's/3\.4\.3/5.0.0/g' \
    /opt/nethack/dgamelaunch.conf $C/dgl_menu_*.txt $C/dgl-banner

Redéfinir la variable C, au cas où elle aurait été perdue :

root@nethack:/home/util01/dgamelaunch# C=/opt/nethack/chroot

Vérifier qu'il ne reste aucune référence à la 3.4.3 :

root@nethack:/home/util01/dgamelaunch# grep -nE 'nh343|NH343|3\.4\.3' /opt/nethack/dgamelaunch.conf $C/dgl_menu_*.txt $C/dgl-banner   # ne doit rien afficher

Afficher les réglages du jeu dans la configuration, pour contrôle :

root@nethack:/home/util01/dgamelaunch# grep -nE 'game_path|game_args|rc_template|rc_fmt|inprogressdir|NETHACKOPTIONS|save/' /opt/nethack/dgamelaunch.conf
256:#  game_path = "/bin/nethackstub"
269:#  game_args = "/bin/nethackstub",
279:#  # rc_template = "/dgl-default-rcfile"
297:#  inprogressdir = "%rinprogress-nethackstub/"
320:  game_path = "/home/util01/nethack500/nethack"
324:  game_args = "/home/util01/nethack500/nethack", "-u", "%n"
327:  rc_template = "/dgl-default-rcfile.nh500"
329:  rc_fmt = "%ruserdata/%n/%n.nh500rc"
331:  inprogressdir = "%rinprogress-nh500/"
340:  commands = cp "/nh500/var/save/%u%n.gz" "/nh500/var/save/%u%n.gz.bak",
341:  # set NETHACKOPTIONS to point to the rcfile
342:             setenv "NETHACKOPTIONS" "@%ruserdata/%n/%n.nh500rc",
356:#  game_path = "/bin/crawlss017"
360:#  game_args = "/bin/crawlss017",
367:#  rc_template = "/dgl-default-rcfile.crawl"
368:#  rc_fmt = "%rrcfiles/%n.crawlrc"
369:#  inprogressdir = "%rinprogress-crawlss017/"
379:#  game_path = "/bin/crawlss020"
383:#  game_args = "/bin/crawlss020",
390:#  rc_template = "/dgl-default-rcfile.crawl"
391:#  rc_fmt = "/crawlss020/plr/%n/%n.crawlrc"
392:#  inprogressdir = "%rinprogress-crawlss020/"
root@nethack:/home/util01/dgamelaunch#

Récupérer l'uid et le gid de util01 dans les variables U et G :

root@nethack:/home/util01/dgamelaunch# U=$(id -u util01); G=$(id -g util01)

Régler le chemin du chroot, l'utilisateur sous lequel tournent les parties, le dossier des sauvegardes, et ajouter LANG en UTF-8 :

root@nethack:/home/util01/dgamelaunch# sed -i -e 's|^chroot_path = .*|chroot_path = "/opt/nethack/chroot/"|' \
       -e "s|^shed_uid = .*|shed_uid = $U|" \
       -e "s|^shed_gid = .*|shed_gid = $G|" \
       -e 's|/nh500/var/save/|/home/util01/nethack500/save/|g' \
       -e '/setenv "NETHACKOPTIONS"/a\             setenv "LANG" "C.UTF-8",' \
    /opt/nethack/dgamelaunch.conf

Vérifier ces réglages :

root@nethack:/home/util01/dgamelaunch# sed -n '/^chroot_path/p;/^shed_[ug]id/p;338,348p' /opt/nethack/dgamelaunch.conf
chroot_path = "/opt/nethack/chroot/"
shed_uid = 1001
shed_gid = 1001

  # back up savefile
  commands = cp "/home/util01/nethack500/save/%u%n.gz" "/home/util01/nethack500/save/%u%n.gz.bak",
  # set NETHACKOPTIONS to point to the rcfile
             setenv "NETHACKOPTIONS" "@%ruserdata/%n/%n.nh500rc",
             setenv "LANG" "C.UTF-8",
  # set up nethack mail stuff, assuming it's compiled with it...
             setenv "MAIL" "/mail/%n",
             setenv "SIMPLEMAIL" "1",
  # don't let the mail file grow
             unlink "/mail/%n"
root@nethack:/home/util01/dgamelaunch#

Personnaliser la bannière : date du message du jour et nom du serveur :

root@nethack:/home/util01/dgamelaunch# sed -i -e 's|"\$MOTDTIME" = "[^"]*"|"$MOTDTIME" = "2026.11.01"|' \
       -e 's|"\$SERVERID" = "[^"]*"|"$SERVERID" = "$ATTR(14)NetHack 5.0 cybernethack$ATTR()"|' \
    /opt/nethack/dgamelaunch.conf

Vérifier la bannière :

root@nethack:/home/util01/dgamelaunch# grep -n 'MOTDTIME\|SERVERID' /opt/nethack/dgamelaunch.conf | head -3
54:bannervars = [ "$MOTDTIME" = "2026.11.01",
55:            "$SERVERID" = "$ATTR(14)NetHack 5.0 cybernethack$ATTR()",
198:# $VERSION and $SERVERID will be replaced, as per the bannerfile above.
root@nethack:/home/util01/dgamelaunch#

7.2 Options par défaut des joueurs

On reprend la configuration du dépôt (curses, symboles Unicode), qui contient déjà OPTIONS=language:fr@cyber.

Copier le nethackrc du dépôt comme modèle d'options des nouveaux joueurs :

root@nethack:/home/util01/dgamelaunch# cp /home/util01/Nethack500_Lubuntu2604/config/nethackrc $C/dgl-default-rcfile.nh500

Rendre le modèle lisible par tous :

root@nethack:/home/util01/dgamelaunch# chmod 644 $C/dgl-default-rcfile.nh500

Chaque joueur reçoit une copie de ce fichier à l'inscription et peut la modifier depuis le menu (touche o). Les joueurs doivent avoir un terminal en UTF-8. Pour un serveur ouvert à tous, tu peux retirer les lignes symset et glyph, pour revenir à l'ASCII.

Choisir la langue : français avec le thème cyberpunk :

root@nethack:/home/util01/dgamelaunch# LANGUE=fr@cyber

Dans le modèle et dans les fichiers des joueurs déjà inscrits, supprimer toutes les lignes language puis en ajouter une seule (les fichiers absents sont ignorés) :

root@nethack:/home/util01/dgamelaunch# for f in /opt/nethack/chroot/dgl-default-rcfile.nh500 /opt/nethack/chroot/dgldir/userdata/*/*.nh500rc; do
    [ -e "$f" ] || continue
    sed -i '/^OPTIONS=language:/d' "$f"
    echo "OPTIONS=language:$LANGUE" >> "$f"
done

Vérifier qu'il ne reste qu'une ligne language par fichier :

root@nethack:/home/util01/dgamelaunch# grep -c '^OPTIONS=language:' /opt/nethack/chroot/dgl-default-rcfile.nh500 /opt/nethack/chroot/dgldir/userdata/*/*.nh500rc
/opt/nethack/chroot/dgl-default-rcfile.nh500:1
/opt/nethack/chroot/dgldir/userdata/sam/sam.nh500rc:1
/opt/nethack/chroot/dgldir/userdata/sammy/sammy.nh500rc:1
/opt/nethack/chroot/dgldir/userdata/test/test.nh500rc:1
root@nethack:/home/util01/dgamelaunch#

Sur une installation neuve, seul le modèle est listé.

7.3 Test local

Lancer dgamelaunch en local pour tester le menu et une partie :

root@nethack:/home/util01/dgamelaunch# /opt/nethack/dgamelaunch -f /opt/nethack/dgamelaunch.conf

Inscription : r Connexion : l Jouer : p

Quitter avec #quit.

Revenir dans le dossier personnel de root :

root@nethack:/home/util01/dgamelaunch# cd
root@nethack:~#

8. Accès SSH public (root)

Créer le compte système nethack, utilisé par les joueurs pour se connecter :

root@nethack:~# useradd -m -s /bin/sh nethack

Supprimer son mot de passe, pour une connexion sans mot de passe :

root@nethack:~# passwd -d nethack
passwd: password changed.
root@nethack:~#

Configurer sshd pour ce seul compte : mot de passe vide accepté, pas de tunnel ni de transfert, lancement forcé de dgamelaunch :

root@nethack:~# cat > /etc/ssh/sshd_config.d/50-nethack.conf <<'EOF'
Match User nethack
    PasswordAuthentication yes
    PermitEmptyPasswords yes
    KbdInteractiveAuthentication no
    PermitTTY yes
    X11Forwarding no
    AllowTcpForwarding no
    AllowAgentForwarding no
    PermitTunnel no
    ForceCommand /opt/nethack/dgamelaunch -f /opt/nethack/dgamelaunch.conf
EOF

Vérifier la syntaxe de la configuration SSH, puis redémarrer le service :

root@nethack:~# sshd -t && systemctl restart ssh

Se connecter au serveur depuis une autre machine :

util01@ordilocal:~$ ssh -p 2222 nethack@IP-DE-L-HOTE

Soit, dans mon cas, en local :

util01@ordilocal:~$ ssh -p 2222 nethack@192.168.1.228

9. Mettre à jour le jeu servi

Après une modification de la branche, on recompile en util01, puis on recopie le jeu dans le chroot sans toucher aux parties des joueurs ni au sysconf du serveur.

Sur l'hôte, faire un instantané du conteneur avant la mise à jour :

util01@ordilocal:~$ lxc snapshot nethack avant-maj

Dans le conteneur, en util01 : récupérer les modifications de la branche en gardant les deux fichiers adaptés, puis recompiler et réinstaller :

util01@nethack:~/Nethack500_Lubuntu2604$ git stash && git pull && git stash pop
util01@nethack:~/Nethack500_Lubuntu2604$ ./install.sh --console

En root : recopier le jeu dans le chroot, sans les sauvegardes, les scores ni le sysconf du serveur :

root@nethack:~# rsync -a \
  --exclude save --exclude record --exclude logfile --exclude xlogfile \
  --exclude livelog --exclude perm --exclude sysconf \
  /home/util01/nethack500/ /opt/nethack/chroot/home/util01/nethack500/

Une nouvelle version peut rendre les sauvegardes incompatibles : préviens les joueurs avant.

Sources

HackTechDev/Nethack500_Lubuntu2604, branche cybernethack (INSTALL.md, install.sh)
Annonce de NetHack 5.0.0
Compiling – NetHack Wiki
paxed/dgamelaunch
Dgamelaunch – Wikihack