libreverse/README.md

# Service LIBREVERSE

Service de mondes virtuels en 3D du candidat chaton de Libre en communs.

Responsable: Christian Momon (@cpm)

La première version de ce document est librement adaptée d'une fiche de Devinsy.

# Site web

Pour l'instant pas d'utilisation de flux web. Cela n'empêchera pas les gens d'essayer d'aller sur la page web https://libreverse.chalec.org/.

Donc une page d'information permet d'apporter une réponse à ce cas, par exemple en donnant des informations sur comment se connecter, comment configurer son client, où trouver un client…

Il s'agit d'une simle page XHTML faite à la main et placée dans `/var/www/libreverse.chalec.org/`.

## Installation basique
Installation d'un service nginx pour :
- l'installation d'une page d'information sur comment se connecter à Libreverse ;
- une redirection vers la page du service sur le site https://www.chalec.org/ ;
- l'éventuel déploiement de StatoolInfos ;
- …

Installer les paquets :
```
apt-get install nginx python3-certbot-nginx
```

Ouvrir les ports http (80) et https (443) :
```
ufw allow 'Nginx HTTP'
ufw allow 'Nginx HTTPS'
```

Configurer a minima le site web dans `/etc/nginx/sites-available/libreverse.chalec.org` :
```
server
{
    listen 80;
    listen [::]:80;

    server_name libreverse.chalec.org; 

    access_log /var/log/nginx/libreverse.chalec.org-access.log;
    error_log /var/log/nginx/libreverse.chalec.org-error.log;
}
```

Activer la configuration :
```
cd /etc/nginx/sites-enabled/
ln -s ../sites-available/libreverse.chalec.org
```

Vérifier que c'est bon et recharger :
```
nginx -t && systemctl reload nginx
```

Configurer le certificat SSl : 
```
certbot --nginx 
```

Mettre beau le fichier `/etc/nginx/sites-enabled/libreverse.chalec.org` :
``` 
server
{
    listen 80;
    listen [::]:80;

    server_name libreverse.chalec.org;

    access_log /var/log/nginx/libreverse.chalec.org-access.log;
    error_log /var/log/nginx/libreverse.chalec.org-error.log;

    #return 302 https://$host$request_uri;
    return 302 https://libreverse.chalec.org$request_uri;
}

server
{
    set_real_ip_from  192.169.1.1;
    real_ip_header proxy_protocol;
    listen [::]:443 ssl ipv6only=on;
    listen 443 ssl proxy_protocol;

    server_name libreverse.chalec.org;

    access_log /var/log/nginx/libreverse.chalec.org-access.log;
    error_log /var/log/nginx/libreverse.chalec.org-error.log;

    ssl_certificate /etc/letsencrypt/live/libreverse.chalec.org/fullchain.pem; # managed by Certbot
    ssl_certificate_key /etc/letsencrypt/live/libreverse.chalec.org/privkey.pem; # managed by Certbot
    include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot

    root /var/www/libreverse.chalec.org;
    location = /
    {
            index index.xhtml;
    }
}
``` 

Vérifier que c'est bon et recharger :
```
nginx -t && systemctl reload nginx
```

# Installation de Minetest

Ouvrir le port par défaut : 
```
ufw allow 30000/udp
```

Installer le serveur Minetest :
```
apt-get install minetest-server minetestmapper
```

Pour privilégier le nommage des mondes, désactiver le monde par défaut :
```
systemctl stop minetest-server
systemctl disabled minetest-server
systemctl disabled minetest-server@minetest
```

Installer Postgresql :
```
apt-get install postgresql postgresql-contrib
```

Optimiser la configuration de Postgresql :
- avoir au moins 512MB de mémoire disponible pour Minetest hors Postgresql ;
- modifier `/etc/postgresql/13/main/postgresql.conf` :
```
-shared_buffers = 128MB                  # min 128kB
+shared_buffers = 512MB                  # min 128kB
```

# Mineclone2

## Installation
Récupérer le zip :
* https://content.minetest.net/packages/Wuzzy/mineclone2/
* cliquer sur le bouton `Download`

Décompresser :
```
unzip mineclone2_6745.zip
```

Ranger dans l'arborescence de Minetest :
```
mv mineclone2 /usr/share/games/minetest/games/
```

## Module de protection de zone

Afin d'éviter le vandalisme, il est classique d'activer des fonctionnalités de protection de zone. Cela consiste à permettre au joueur de réserver une zone de blocs où il sera le seul à pouvoir casser/rajouter un bloc ou prendre/déposer dans un coffre.

Rappel : [documentation d'installation d'un mod](https://wiki.minetest.net/Installing_Mods). 

Le module [node_ownership](https://forum.minetest.net/viewtopic.php?t=846) est très connu mais obsolète.

Le module [areas](https://content.minetest.net/packages/ShadowNinja/areas/) semble à jour, maintenu et très utilisé ([voir graphique](https://wiki.minetest.net/Mods/fr)). Notamment, ce module est [utilisé sur Framinetest](https://framacloud.org/fr/cultiver-son-jardin/minetest.html).

Télécharger l'archive, puis dézipper et renommer : 
```
wget https://github.com/ShadowNinja/areas/archive/master.zip
unzip master.zip
mv areas-master areas
```

Déplacer dans le dossier du monde :
```
mkdir -p /srv/libreverse.chalec.org/worlds/libreverse/worldmods
systemctl stop minetest-server.service
mv areas /srv/libreverse.chalec.org/worlds/libreverse/worldmods/
systemctl start minetest-server.service
```

Une aide est disponible en tapant /help dans le jeu.

Les réglages se font dans `/srv/libreverse.chalec.org/worlds/libreverse/worldmods/areas/settingtypes.txt`.

Les zones sont stockées dans `/srv/libreverse.chalec.org/worlds/libreverse/areas.dat`.


# Bouton Download sur la page .
wget https://content.minetest.net/uploads/4RFYnfBJUR.zip
unzip  

mv dans root@libre-service.eu:/usr/share/games/minetest/games/mineclone2/mods/ + dans world.mt, ajouter load = true

nan dans root@libre-service.eu:/srv/minetest.libre-service.eu/worlds/30009-mineclone2/worldmods et pas la peine de toucher au wold.mt

pour info, fichier des zones dans lemonde/areas.dat, c'est du JSON



## Création d'un monde

Choisir un port et l'ouvrir (remplacer X par un chiffre dédié) : 
```
ufw allow 3000X/udp
```

Créer un fichier de configuration élémentaire :
```
cp /etc/minetest/minetest.conf /etc/minetest/fooland.conf
```

Éditer le fichier de configuration `/etc/minetest/fooland.conf` : 
```
- server_name = My Minetest server
+ server_name = Chalec – Mineclone2 – Fooland

- server_description = Minetest server powered by Debian
+ server_description = Le libreverse pour tout le monde sur Chalec

-# server_address = game.minetest.net
+ server_address = libreverse.chalec.org

-# server_url = http://minetest.net
+ server_url = https://libreverse.chalec.org/

-port = 30000
+port = 3000X

- default_game = minetest
+ default_game = mineclone2

- motd = Welcome to Minetest. Enjoy your stay!
+ motd = Bienvenue sur le Libreverse de Chalec \o/

-# map-dir =
+map-dir = /srv/libreverse.chalec.org/worlds/fooland

- max_users = 15
+ max_users = 64

- enable_damage = false
+ enable_damage = true

- # disallow_empty_password = false
+ disallow_empty_password = true
```

Créer le dossier des mondes dans l'espace du service :
```
mkdir -p /srv/libreverse.chalec.org/worlds
chown Debian-minetest /srv/libreverse.chalec.org/worlds
```

Créer le nouveau monde :
```
systemctl start minetest-server@fooland.service
```

Le démarrer au prochain boot :
```
systemctl enable minetest-server@fooland.service
```

Tester le nouveau monde en se connectant avec un client Minetest.

## Migration dans Posgreql
Créer un compte dédié (si pas déjà fait) :
```
    su - postgres -c "psql -c \"create user minetestdba with password 'XXXXXXXX'; \" "
```

Créer une base de données :
```
su - postgres -c "psql -c \"CREATE DATABASE minetestdb_fooland OWNER minetestdba; \""
```

Associer le compte dédié avec la base fraîchement créée :
```
su - postgres -c "psql -c \"GRANT ALL PRIVILEGES ON DATABASE minetestdb_fooland TO minetestdba; \""
```

Définir la base de données dans `/srv/libreverse.chalec.org/worlds/fooland/world.mt` :
```
pgsql_connection = host=127.0.0.1 port=5432 user=minetestdba password=XXXXX dbname=minetestdb_fooland
pgsql_auth_connection = host=127.0.0.1 port=5432 user=minetestdba password=XXXXXX dbname=minetestdb_fooland
pgsql_player_connection = host=127.0.0.1 port=5432 user=minetestdba password=XXXXXX dbname=minetestdb_fooland
```

Migrer le nouveau monde vers le backend Postgres :
```
systemctl stop minetest-server@fooland.service
/usr/games/minetestserver --migrate postgresql --world /srv/libreverse.chalec.org/worlds/fooland
/usr/games/minetestserver --migrate-auth postgresql --world /srv/libreverse.chalec.org/worlds/fooland
/usr/games/minetestserver --migrate-players postgresql --world /srv/libreverse.chalec.org/worlds/fooland
chown Debian-minetest.games /srv/libreverse.chalec.org/worlds/fooland/world.mt
systemctl start minetest-server@fooland.service
```

## IPV4 vs IPV6 
Pour l'instant, pas trouvé comment activer et ipv4 et ipv6. Donc activation de ipv6 dans `/etc/minetest/minetest.conf` :
```
serverlist_url = v6.servers.minetest.net
ipv6_server = true
```

## Jouer
Liens utiles :
- Mineclone2 : https://wiki.minetest.net/Games/MineClone_2/Differences_from_Minetest_Game
- Database backends : https://wiki.minetest.net/Database_backends
- Server commands : https://wiki.minetest.net/Server_commands
- Item strings : https://wiki.minetest.net/Itemstrings
- Privileges : https://wiki.minetest.net/Privilegesc

## Génération une carte du monde

### Migration du backend
La procédure utilise `minetestmapper` qui ne gère pas Postgresql, donc une étape va consister à convertir la base de donnée.

Copier temporairement la base :
```
su - postgres -c "psql -c \"CREATE DATABASE test with template minetestdb_libremine; \""
```

Copier temporairement l'arborescence du monde :
```
cp /srv/libreverse.chalec.org/worlds/libremine /srv/libreverse.chalec.org/worlds/test
```

Modifier le paramétrage de la base de données dans le fichier de paramétrage du monde :
```
sed -i 's/minetestdb_libremine/test/g' /srv/libreverse.chalec.org/worlds/test/world.mt
```

Migrer le `backend` du monde (minetestmapper ne sais pas gérer postgresql):
```
/usr/games/minetestserver --migrate sqlite3 --world /srv/libreverse.chalec.org/worlds/test
/usr/games/minetestserver --migrate-players sqlite3 --world /srv/libreverse.chalec.org/worlds/test
```

### Correspondance des couleurs

Minetestmapper sait traduire les blocs Minetest en pixel de couleur mais Mineclone2 apporte de nouveaux blocs. La liste des correspondances de couleurs est donc à générer :
```
./mtsedit -m Mineclone2 -C > mineclone-colors.txt
```

### Génération
```
/usr/games/minetestmapper -i /srv/libreverse.chalec.org/worlds/test/ -o /srv/libreverse.chalec.org/foo.png --colors /srv/libreverse.chalec.org/mineclone-colors.txt --draworigin --drawscale
```

### Nettoyage

Supprimer la base temporaire :
```
su - postgres -c "psql -c \"DROP DATABASE test; \""
```

Supprimer l'arborescence temporaire :
```
rm -fr /srv/libreverse.chalec.org/worlds/test
```

# Gestion du SpawnPoint

Par défaut, tous les joueurs apparaissent et ré-apparaissent exactement au même point.

Une légère dispersion s'opère si le spawnpoint est au milieu d'un lac. En fait, cette dispersion est modeste.

Deux stratégies possibles :
a) soit on sacralise un carré de 1400 cubes d'arêtes pour conserver un aspect pionner aux nouveaux arrivant ;
b) soit on se fait plaisir là où on est et quand la zone ne sera plus très pionnière bah on déplace le spawnpoint plus loin (voire beaucoup plus loin).

En fait, la dispersion est plus modeste qu'espérée et de toute façon, au bout d'un moment, la zone d'arrivée ne sera plus pionnière.

En conséquence, le choix b) s'impose. Prévoir de déplacer le spawnpoint quand la zone n'est plus suffisamment pionnière.

Voir le fichier `/etc/minetest/minetest.conf` :
```
#    If this is set, players will always (re)spawn at the given position.
#    type: string
static_spawnpoint = 123, 4, 567
```