Deep Salvage
Mon premier jeu original : un jeu en ligne de récupération d'épaves, avec un océan simulé sur la carte graphique et des serveurs de zone.

Fonctionnalités principales
- Océan simulé par FFT (méthode de Tessendorf) sur trois cascades, en compute shaders
- Écume, transparence, caustiques et vue sous-marine
- Maillage en clipmap jusqu'à 40 km, quatre niveaux de qualité (téléphone à PC)
- Copie déterministe de la mer sur le serveur pour la flottaison
- Serveurs de zone faisant autorité à 30 Hz, prédiction et interpolation côté client
- Service de connexion en Go avec tickets signés
Défis et solutions
- 01
Problème. Par tempête, 25 % de la surface dépassait la pente maximale d'une vraie vague et se repliait.
Solution. Budget de pente calculé sur le processeur qui réduit le déplacement de toutes les cascades ensemble.
- 02
Problème. Le serveur doit connaître la hauteur de l'eau sans carte graphique.
Solution. Somme directe des 160 vagues les plus fortes, avec un hachage commun et une mer qui se répète toutes les 1 024 s : seule l'horloge est synchronisée.
- 03
Problème. Des blocages de 100 à 500 ms en production.
Solution. Mesures montrant qu'ils venaient de l'hébergeur ; la prédiction et le tampon d'interpolation en masquent la plupart.
Présentation
Deep Salvage est mon premier jeu original : un jeu en ligne de récupération d'épaves en mer, dans un style proche de Sea of Thieves. Le joueur part du port, navigue jusqu'à une épave, plonge pour fouiller, remonte ses trouvailles et les revend. Plus on s'éloigne des îles, plus la mer est agitée et plus les épaves sont riches. Le jeu est en développement : la mer, les îles, les zones et le multijoueur fonctionnent, la boucle de jeu complète reste à construire.

J'ai d'abord commencé le jeu sur Roblox. J'ai mesuré les limites du moteur (pas de compute shaders, environ 7 maillages modifiables par joueur, textures sans mipmaps) et conclu qu'il ne permettrait pas d'atteindre la mer que je voulais. J'ai donc reconstruit le jeu sous Godot 4, avec une version modifiée du moteur qui intègre les technologies NVIDIA (DLSS, Reflex, génération d'images) et AMD FSR. Des versions de test sont publiées pour Windows, macOS, Linux et Android.
Simuler l'océan sur la carte graphique
La mer repose sur la méthode de Tessendorf, utilisée dans les films et dans Sea of Thieves : au lieu de dessiner les vagues une par une, on décrit la mer par son spectre, c'est-à-dire la quantité de vagues de chaque taille et de chaque direction, puis on reconstruit la surface avec une transformée de Fourier rapide (FFT). Le spectre utilisé est JONSWAP, un modèle océanographique qui dépend de la force du vent et de la distance sur laquelle il souffle.
Chaque image, quatre compute shaders en GLSL s'exécutent sur la carte graphique : le premier fait évoluer les vagues dans le temps, les deux suivants calculent la FFT sur les lignes puis sur les colonnes, le dernier prépare les niveaux de détail. La mer est découpée en trois cascades de 256 × 256 points (571 m, 97 m et 23,3 m), choisies pour que leurs répétitions ne s'alignent jamais et que l'on ne voie pas de motif.

La figure 2 montre le résultat en pleine mer. Pour arriver là, il a fallu mesurer et corriger plusieurs défauts. Par tempête, les vagues étaient bien trop pointues (25 % de la surface dépassait la limite physique d'une vague) : j'ai ajouté un budget de pente calculé sur le processeur, qui réduit le déplacement de toutes les cascades ensemble. Le résultat : plus aucune vague repliée sur elle-même.
J'ai aussi optimisé la FFT en mesurant chaque étape avec les horodatages de Vulkan. En regroupant cinq passes en deux et en précalculant les coefficients en mémoire partagée, son coût est passé de 0,64 ms à 0,11 ms par image. Une version en base 4 a été essayée et abandonnée, faute de gain mesurable.
Écume, transparence et monde sous-marin

La figure 3 compare deux versions de l'eau. L'écume naît là où la surface se replie (quand le jacobien du déplacement devient négatif), puis elle est transportée par le vent et s'efface progressivement. Les bateaux et les caisses laissent aussi une traînée d'écume. Sous l'eau, chaque pixel teste si son rayon traverse la surface : une caméra à moitié immergée voit donc le dessus et le dessous séparés par une ligne d'eau. Les caustiques (la lumière concentrée par les vagues sur le fond) sont calculées en suivant le soleil réfracté à travers chaque point de la surface.
Le maillage de la mer est un clipmap : des anneaux carrés de plus en plus grossiers autour de la caméra, jusqu'à 40 km. Il se déplace par pas entiers pour que les sommets ne « glissent » pas, et quatre niveaux de qualité (de 64 à 160 carrés par anneau) permettent de faire tourner le jeu sur téléphone comme sur un PC puissant.
La même mer sur le serveur
Dans un jeu en ligne, le serveur doit savoir à quelle hauteur flotte chaque bateau, mais il n'a pas de carte graphique. J'ai donc écrit une copie de la mer sur le processeur : elle additionne directement les 160 vagues les plus fortes au point demandé. Pour que le client et le serveur calculent exactement la même mer, les nombres aléatoires viennent d'un hachage identique sur les deux, et les fréquences des vagues sont arrondies pour que la mer se répète parfaitement toutes les 1 024 secondes. La mer n'est donc jamais envoyée sur le réseau : seule l'horloge est synchronisée.
La flottaison découpe chaque objet en colonnes d'eau, calcule un plan moyen sous la coque et applique une poussée et un frottement par rapport au mouvement de l'eau. Un premier bateau entrait en résonance et roulait de 25 à 58° par mer calme ; un autre se retournait et « s'envolait » de 10 m. Je les ai stabilisés en lisant des vagues plus lisses, en appliquant la poussée au niveau des colonnes et en amortissant le mouvement vertical.
Architecture réseau

La figure 4 montre une partie à plusieurs. Le jeu demande d'abord l'adresse d'une zone à un service écrit en Go, qui renvoie un ticket signé (HMAC-SHA256, valable 30 secondes, utilisable une seule fois). Le client se connecte ensuite en UDP chiffré (ENet et DTLS) à un serveur de zone : c'est le même projet Godot lancé sans affichage, qui fait autorité et calcule le monde 30 fois par seconde.
Pour que le jeu reste réactif malgré la latence, le client prédit son propre mouvement avec exactement la même fonction que le serveur, puis corrige en douceur s'il s'est trompé. Les autres joueurs sont affichés avec 100 ms de retard et interpolés, avec un tampon qui s'agrandit quand le réseau se dégrade. Sur un test de 40 joueurs simulés, une étape du serveur prend 1,4 ms en moyenne et chaque joueur reçoit 152 kbit/s.
En production, j'ai observé des blocages de 100 à 500 ms. Après plusieurs mesures (un programme qui dort 1 ms se réveillait jusqu'à 354 ms plus tard), j'ai montré qu'ils venaient de l'hébergeur et non du code. La prédiction et le tampon d'interpolation en cachent la plupart.
Ce que j'ai repris et ce que j'ai appris
Je ne suis pas parti de zéro : le spectre et l'ombrage de départ viennent du projet libre GodotOceanWaves (licence MIT), la mémoire de l'écume du godot-water-shader d'Emil Jerkovic, et plusieurs techniques de tidewater (three.js) et des conférences de Rare sur Sea of Thieves. Mon travail a été de les assembler, de les adapter au jeu en ligne, de mesurer et de corriger. Ce projet m'a fait progresser plus que tous les autres en mathématiques appliquées, en programmation GPU et en réseau.