> For the complete documentation index, see [llms.txt](https://docs.edgegap.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.edgegap.com/fr/docs/sample-projects/unity-netcodes/small-network-relay.md).

# Relais de petit réseau Lightnet

Hébergez un petit relais réseau extensible sur Edgegap et jouez à Tanks via celui-ci sur Mirror, FishNet, PurrNet ou Netcode for Game Objects, avec des codes de salle ou le matchmaking Edgegap.

Découvrez comment exécuter votre propre petit relais réseau sur Edgegap, avec un exemple de jeu Unity qui passe par celui-ci en utilisant [Mirror](https://mirror-networking.com/), [FishNet](https://fish-networking.gitbook.io/docs), [PurrNet](https://purrnet.dev/) ou [Netcode for GameObjects (NGO)](https://docs-multiplayer.unity3d.com/netcode/current/about/).

Le relais est un petit serveur .NET basé sur [LightNet](https://github.com/edgegap/server-sample-unity-smart-relays). Edgegap l’héberge et l’orchestre comme n’importe quel autre serveur : un déploiement, démarré près de vos joueurs. Un joueur héberge une salle et obtient un code à 6 lettres, les autres joueurs rejoignent avec ce code. Aucun joueur n’ouvre de port : tout le monde, y compris l’hôte, est un client du relais.

Cet exemple montre :

* **un serveur relais** dans une `linux/amd64` image Docker, à l’écoute sur le port `7777` pour TCP (messages fiables) et UDP (messages non fiables),
* **des salles avec un code de connexion** - plusieurs salles peuvent partager un seul déploiement de relais,
* **l’exemple Tanks sur quatre netcodes** - Mirror, FishNet, PurrNet et NGO dans un seul projet Unity, une seule build,
* **un seul réglage pour changer le netcode** - dans un asset de réglages, un menu de l’éditeur, dans le jeu avant de se connecter, ou en ligne de commande,
* **un matchmaking Edgegap facultatif** - désactivé par défaut : **Trouver une partie** regroupe les joueurs proches sur un relais près d’eux, un joueur par salle l’héberge, les joueurs qui cherchent plus tard rejoignent les salles en cours, et un relais dont les salles sont pleines en ouvre de nouvelles avant qu’un autre relais ne démarre,
* **connexion chiffrée facultative** - `wss://` via la mise à niveau TLS d’Edgegap, à côté de TCP et UDP en clair,
* **tests automatisés** - les clients du jeu passent par le relais sur chaque netcode, avec des codes de salle ou via le matchmaker.

{% hint style="success" %}
**Il s’agit d’une configuration client-hôte**: le joueur hôte fonctionne comme serveur et le relais transmet les octets entre les joueurs.
{% endhint %}

{% hint style="info" %}
Alternative - [serveurs dédiés](https://docs.edgegap.com/fr/learn/orchestration/deployments.md#orchestration) empêchent l’avantage du joueur hôte et la partie survit au départ de l’hôte.
{% endhint %}

## ✔️ Préparation

Avant de commencer, vous aurez besoin de :

* [Projet d’exemple Small Network Relay](https://github.com/edgegap/server-sample-lightnet-relay),
* [Unity `6000.0.54f1`](https://unity.com/releases/editor/archive), pour ouvrir et compiler le jeu,
* [.NET 8 SDK](https://dotnet.microsoft.com/download/dotnet/8.0) (facultatif), uniquement pour exécuter le relais hors de Docker.

<details>

<summary><a href="https://www.docker.com/products/docker-desktop/">Installez Docker Desktop (ou Docker CLI)</a></summary>

* [Installez Docker Desktop à partir de la source officielle](https://www.docker.com/products/docker-desktop/) (aucun compte requis).
* Redémarrez votre ordinateur après avoir terminé l'installation.

</details>

Le dépôt comporte quatre parties :

| Dossier                  | Ce que c’est                                                                                                               |
| ------------------------ | -------------------------------------------------------------------------------------------------------------------------- |
| `LightNet`               | Le cœur réseau LightNet sous forme de package Unity, ainsi que le protocole du relais et son client agnostique au netcode. |
| `relay-server`           | Serveur relais - application console .NET 8 construite à partir des mêmes sources, et son Dockerfile.                      |
| `tanks`                  | le projet Unity : l’exemple Tanks de Mirror sur Mirror, FishNet, PurrNet et NGO.                                           |
| `matchmaker-config.json` | configuration facultative du matchmaker, voir [Matchmaking facultatif](#optional-matchmaking).                             |

## 🔀 Choisir le netcode

Le netcode est le `netcode` champ de `tanks/Assets/Tanks/Resources/TanksSettings.asset`: `Mirror`, `FishNet`, `PurrNet` ou `NGO`. Le même asset contient l’adresse et le port du relais.

Vous pouvez aussi le changer :

* dans l’éditeur Unity, avec le **Tanks > Netcode** menu — cela ouvre aussi la scène de ce netcode,
* dans le jeu, avec les boutons de netcode en haut de l’écran, avant d’héberger ou de rejoindre,
* en ligne de commande, avec `-netcode FishNet`.

| Netcode | Version | Sync des tanks                                                                                     |
| ------- | ------- | -------------------------------------------------------------------------------------------------- |
| Mirror  | 66.0.9  | `SyncVar`, `Command`, `ClientRpc`, côté client autoritaire `NetworkTransform`                      |
| FishNet | 4.7.4   | `SyncVar<int>`, `ServerRpc`, `ObserversRpc`, côté client autoritaire `NetworkTransform`            |
| PurrNet | 1.24.1  | `SyncVar<int>`, `ServerRpc`, `ObserversRpc`, côté propriétaire autoritaire `NetworkTransform`      |
| NGO     | 1.13.0  | `NetworkVariable<int>`, `ServerRpc`, `ClientRpc`, côté propriétaire autoritaire `NetworkTransform` |

{% hint style="warning" %}
**L’hôte et chaque joueur doivent utiliser le même netcode.** Le relais ne vérifie pas la compatibilité du netcode.
{% endhint %}

Chaque netcode a son propre transport de relais, construit sur le même client de relais (`RelayPeer`): `MirrorRelayTransport`, `FishNetRelayTransport`, `PurrNetRelayTransport` et `NgoRelayTransport`). Pour utiliser le relais dans votre propre jeu, copiez le `LightNet` package et le transport correspondant à votre netcode.

## ⚡ Déployer et se connecter

### 1. Exécuter le relais localement

☑️ Depuis la racine du dépôt, construisez et exécutez l’image du relais :

{% code collapsedlinecount="10" %}

```bash
docker build --platform linux/amd64 -f relay-server/Dockerfile -t lightnet-relay:dev .
docker run -p 7777:7777/tcp -p 7777:7777/udp -p 7778:7778/tcp lightnet-relay:dev
```

{% endcode %}

☑️ Ouvrez `tanks` dans Unity, choisissez un netcode, et compilez avec **Tanks > Compiler le client Windows**, ou appuyez sur Play sur `Assets/Tanks/Scenes/Boot.unity`.

☑️ Dans le premier jeu, appuyez sur **Host**: le code de la salle s’affiche à l’écran. Dans le deuxième jeu, saisissez le code et appuyez sur **Join room**.

✅ Vous pouvez maintenant passer à l’étape suivante.

### 2. Pousser l’image du relais

☑️ Pour commencer, vous devrez [créer un compte gratuit chez Edgegap](https://app.edgegap.com/auth/register). Aucune carte de crédit requise.

☑️ Trouvez votre [Registre de conteneurs](https://docs.edgegap.com/fr/learn/advanced-features/edgegap-container-registry.md) nom de projet et identifiants.

☑️ Connectez-vous au registre de conteneurs d’Edgegap avec Docker, en utilisant le nom de projet de votre registre, votre nom d’utilisateur et votre jeton :

{% tabs %}
{% tab title="Bash (Linux)" %}

```bash
project='<REGISTRY_PROJECT>';
username='robot$<REGISTRY_ORGANIZATION_ID>+client-push';
token='<REGISTRY_TOKEN>';

echo "$token" | docker login registry.edgegap.com -u "$username" --password-stdin 2>&1
```

{% endtab %}

{% tab title="PowerShell (Windows)" %}

```powershell
$project = '<REGISTRY_PROJECT>'
$username = 'robot$<REGISTRY_ORGANIZATION_ID>+client-push'
$token = '<REGISTRY_TOKEN>'

echo "$token" | docker login registry.edgegap.com -u "$username" --password-stdin 2>&1
```

{% endtab %}
{% endtabs %}

☑️ Étiquetez et poussez l’image du relais, avec une nouvelle étiquette pour chaque build :

{% code collapsedlinecount="10" %}

```bash
docker tag lightnet-relay:dev registry.edgegap.com/<project>/lightnet-relay:<tag>
docker push registry.edgegap.com/<project>/lightnet-relay:<tag>
```

{% endcode %}

{% hint style="danger" %}
:x: **NE PAS - écraser des étiquettes existantes ni utiliser `latest` comme étiquette** - cela déploiera un cache obsolète.\
:white\_check\_mark: **FAITES - augmentez toujours votre étiquette de version** et déployez la nouvelle build.
{% endhint %}

{% hint style="warning" %}
Chaque organisation obtient son propre projet de registre, **assurez-vous de modifier les commandes pour qu’elles correspondent aux vôtres.**
{% endhint %}

✅ Vous pouvez maintenant passer à l’étape suivante.

### 3. Créer une version d’application

☑️ [Créez une application](https://app.edgegap.com/application-management/applications/list) nommée `lightnet-relay`, et une version avec :

* image `registry.edgegap.com/<project>/lightnet-relay` et votre étiquette,
* votre nom d’utilisateur et jeton du registre de conteneurs, afin qu’Edgegap puisse récupérer votre image,
* ressources 0,25 vCPU et 512 Mo de mémoire,
* un [port](https://docs.edgegap.com/fr/learn/orchestration/application-and-versions.md) `7777`, nommé `relay`, protocole **TCP/UDP**,
* facultatif, pour la [connexion chiffrée](#encrypted-connection): un second port `7778`, nommé `relay-ws`, protocole **WS**, avec **mise à niveau TLS** activée,
* [durée maximale](https://docs.edgegap.com/fr/learn/orchestration/application-and-versions.md) 30 minutes pour les tests.

{% hint style="warning" %}
Utilisez une seule entrée de port avec le protocole **TCP/UDP**, et non des entrées `7777` TCP et `7777` UDP séparées. Edgegap donne alors à TCP et UDP le même port externe, de sorte que les joueurs n’ont besoin que d’un seul numéro de port.
{% endhint %}

Paramètres de relais facultatifs, sous forme [de variables d’environnement sur la version de l’application](https://docs.edgegap.com/fr/learn/orchestration/application-and-versions.md#injected-variables):

| Variable                  | Par défaut | Ce que cela fait                                                                                                                                                            |
| ------------------------- | ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `RELAY_TCP_PORT`          | `7777`     | port pour les messages fiables                                                                                                                                              |
| `RELAY_UDP_PORT`          | `7777`     | port pour les messages non fiables                                                                                                                                          |
| `RELAY_MAX_PEERS`         | `256`      | nombre maximal de connexions simultanées, sur toutes les salles                                                                                                             |
| `RELAY_IDLE_EXIT_SECONDS` | `600`      | arrêter le relais lorsqu’aucune salle n’existe depuis aussi longtemps, `0` = jamais (les relais lancés par le matchmaker s’arrêtent lorsque leur dernière salle se termine) |
| `RELAY_WS_PORT`           | `7778`     | port pour la connexion WebSocket, `0` = désactivé                                                                                                                           |
| `RELAY_MATCH_MAX_PLAYERS` | `4`        | joueurs par salle sur les relais lancés par le matchmaker ; le remplissage par backfill complète jusqu’à ce nombre                                                          |
| `RELAY_MAX_ROOMS`         | `4`        | salles par relais lancé par le matchmaker                                                                                                                                   |
| `RELAY_SOLO_ROOM_SECONDS` | `120`      | fermer une salle dont l’hôte est seul depuis aussi longtemps ; le jeu recherche alors à nouveau                                                                             |
| `MATCHMAKER_URL`          |            | URL de l’API du matchmaker, pour [le backfill](#optional-matchmaking)                                                                                                       |
| `MATCHMAKER_TOKEN`        |            | jeton d’authentification du matchmaker, pour le backfill                                                                                                                    |

✅ Vous pouvez maintenant passer à l’étape suivante.

### 4. Déployer et jouer

☑️ [Déployez votre nouvelle version d’application](https://app.edgegap.com/deployment-management/deployments/create) près de vos joueurs. Lorsqu’il est prêt, notez son nom d’hôte (`<id>.pr.edgegap.net`) et le port externe de `relay`.

☑️ Dans les deux jeux, **définissez l’adresse et le port du relais à l’écran avant de vous connecter**, ou lancez-les depuis la ligne de commande (alternative) :

{% code collapsedlinecount="10" %}

```bash
Tanks.exe -netcode NGO -relay <id>.pr.edgegap.net -relayPort <port externe> -host
Tanks.exe -netcode NGO -relay <id>.pr.edgegap.net -relayPort <port externe> -join <code>
```

{% endcode %}

☑️ Hébergez une salle dans le premier jeu et rejoignez-la avec le code du second.

{% hint style="info" %}
Le journal du relais montre un joueur qui se connecte et se déconnecte juste après le démarrage du déploiement : il s’agit du contrôle de disponibilité d’Edgegap, pas d’un joueur.
{% endhint %}

<figure><img src="https://3008966946-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FsR0dHSFv9ymoC0DO5G8J%2Fuploads%2Fz9xjzvZwKSIp9IeC9qo8%2Fimage.png?alt=media&amp;token=e3f345ac-848d-4469-b66f-3655cd393cf3" alt=""><figcaption></figcaption></figure>

{% hint style="info" %}
Le port externe de votre déploiement sur le cloud Edgegap sera choisi aléatoirement, afin qu'un attaquant potentiel (hacker) soit ralenti et détecté avant de pouvoir causer des dommages.
{% endhint %}

{% hint style="warning" %}
**Désactiver le VPN lors des tests** pour des conditions plus réalistes et recevoir un [déploiement à faible latence](https://docs.edgegap.com/fr/learn/orchestration/deployments.md#server-placement).
{% endhint %}

☑️ Une fois que vous avez vérifié que vous pouvez vous connecter à votre déploiement sans problème et que vous avez fini les tests, **Arrêtez votre déploiement** pour libérer de la capacité dans votre compte pour la prochaine build.

* En cas de problème, [inspectez les journaux du tableau de bord de votre déploiement](https://app.edgegap.com/deployment-management/deployments/list).
* Si vous ne parvenez pas à identifier le problème, nous traînons dans notre [Discord Communautaire](https://discord.gg/NgCnkHbsGp) et heureux de vous aider.

🙌 Félicitations pour votre premier déploiement sur Edgegap ! Si vous souhaitez en savoir plus, continuez à lire.

## 🎯 Matchmaking facultatif

Les codes de salle fonctionnent entre amis. Pour mettre en relation des joueurs qui ne se connaissent pas, activez le [Matchmaking](https://docs.edgegap.com/fr/learn/matchmaking.md): les joueurs appuient sur **Trouver une partie**, le matchmaker regroupe 2 à 4 joueurs proches les uns des autres et lance un relais pour leur partie, près d’eux. Le relais choisit ensuite un joueur pour héberger et donne le code de salle aux autres, afin que personne n’ait à taper de code. Les joueurs qui appuient sur **Trouver une partie** plus tard rejoignent des salles avec des places libres, et un relais dont les salles sont pleines en ouvre de nouvelles, avant que le matchmaker ne lance un autre relais. Il est désactivé par défaut, et l’hébergement et la connexion par code continuent de fonctionner à côté.

Comment une partie démarre :

1. Le jeu de chaque joueur mesure sa latence aux balises d’Edgegap et crée un ticket de matchmaking.
2. Le matchmaker regroupe les tickets et déploie un relais à partir de votre version d’application. Edgegap donne à ce relais la liste des tickets appariés (`MM_TICKET_IDS`).
3. Chaque jeu se connecte au relais avec l’ID de son ticket. Le premier joueur apparié à demander héberge la salle de la partie, les autres la rejoignent. Les tickets qui ne font pas partie de la partie sont refusés.
4. Tant qu’une salle a des places libres, le relais demande au matchmaker d’ajouter plus de joueurs via des backfills. Une fois que chaque salle est pleine, il propose une nouvelle salle à la place. Voir l’étape 3 ci-dessous.
5. Lorsque la dernière salle se termine, le relais supprime ses backfills et arrête son propre déploiement, de sorte qu’une partie terminée ne coûte rien.

Un relais déployé sans matchmaker fonctionne comme auparavant, avec des codes de salle.

### 1. Créer un matchmaker

☑️ Ouvrez `matchmaker-config.json` depuis le dépôt et définissez `application.name` et `version` sur la version de votre application de l’étape 3 :

{% code title="matchmaker-config.json" lineNumbers="true" expandable="true" collapsedlinecount="10" %}

```json
{
  "version": "3.3.3",
  "inspect": true,
  "max_deployment_retry_count": 3,
  "profiles": {
    "casual": {
      "ticket_expiration_period": "30s",
      "ticket_removal_period": "1m",
      "group_inactivity_removal_period": "5m",
      "application": {
        "name": "lightnet-relay",
        "version": "<votre version>"
      },
      "rules": {
        "initial": {
          "match_size": {
            "type": "player_count",
            "attributes": {
              "team_count": 1,
              "min_team_size": 9999,
              "max_team_size": 9999
            }
          },
          "beacons": {
            "type": "latencies",
            "attributes": {
              "difference": 100,
              "max_latency": 150
            }
          }
        },
        "expansions": {
          "10": {
            "match_size": {
              "team_count": 1,
              "min_team_size": 2,
              "max_team_size": 4
            }
          }
        }
      }
    }
  }
}
```

{% endcode %}

Pendant ses 10 premières secondes, un ticket ne peut rejoindre qu’un relais qui a de la place (`min_team_size` `9999` ne peut pas être satisfait). Après 10 secondes, la règle habituelle s’applique, et 2 à 4 joueurs en attente obtiennent un nouveau relais.

La `règle des balises` garde les joueurs avec des joueurs proches d’eux : une balise compte si la latence du joueur vers elle est inférieure à 150 ms, et les latences des joueurs appariés vers elle doivent être comprises à 100 ms près les unes des autres. Le jeu envoie ses latences dans chaque ticket (**Balises de latence du matchmaker** dans `TanksSettings.asset`, activé par défaut).

{% hint style="warning" %}
**Les navigateurs ne peuvent pas pinguer les balises.** Pour une build WebGL, utilisez un profil sans la règle `règle des balises` et désactivez **Balises de latence du matchmaker** cela.
{% endhint %}

☑️ Dans le tableau de bord, ouvrez [Matchmaker](https://app.edgegap.com/matchmaker-management-v2/matchmakers/list), cliquez sur **Créer un matchmaker**, téléversez le fichier, puis **Créer et démarrer**.

☑️ Lorsque le matchmaker est **En ligne**, copiez son **URL de l’API** et **Jeton d’authentification**.

{% hint style="info" %}
Le jeton d’authentification peut être inclus sans risque dans votre jeu : il permet aux joueurs de créer des tickets et ne donne aucun accès à votre compte Edgegap.
{% endhint %}

☑️ Ajoutez-les à votre version d’application en tant que variables d’environnement `MATCHMAKER_URL` et `MATCHMAKER_TOKEN`, afin que les relais puissent remplir les places libres (étape 3).

✅ Vous pouvez maintenant passer à l’étape suivante.

### 2. Trouver une partie

☑️ Dans `tanks/Assets/Tanks/Resources/TanksSettings.asset`, activez **Utiliser le matchmaker** et collez l’ **URL du matchmaker** et **jeton du matchmaker**. Le profil (`casual`) et le nom du port (`relay`) correspondent déjà à la configuration ci-dessus.

☑️ Compilez le jeu, lancez deux copies et appuyez sur **Trouver une partie** dans les deux. Ou lancez-les depuis la ligne de commande :

{% code collapsedlinecount="10" %}

```bash
Tanks.exe -netcode NGO -matchmaker https://<id>.edgegap.net -matchmakerToken <token> -findMatch
```

{% endcode %}

☑️ Les deux jeux affichent l’état de la partie, puis l’un héberge et l’autre rejoint : les deux tanks apparaissent dans les deux jeux.

{% hint style="warning" %}
**Testez avec deux joueurs.** Une partie nécessite au moins 2 joueurs, donc un seul ticket continue de chercher et expire après 30 secondes.
{% endhint %}

Le client de matchmaking est `Assets/Tanks/Core/TanksMatchmaker.cs`, basé sur le [SDK Unity d’Edgegap](https://github.com/edgegap/sdk-unity-sessions-matchmaker-server-browser). Il ne dépend jamais du netcode : il place l’adresse du relais dans les réglages et démarre le jeu en tant qu’hôte ou joueur, comme le font les **Host** et **Join room** boutons.

✅ Vous pouvez maintenant passer à l’étape suivante.

### 3. Un relais, plusieurs salles

Un relais lancé par le matchmaker continue de fonctionner pour lui après le démarrage de sa première partie, via des backfills. Un backfill est un ticket détenu par le relais qui porte sa propre adresse. Lorsque le matchmaker place le ticket d’un joueur dans l’un d’eux, ce joueur obtient l’adresse du relais, demande son rôle comme les autres et rejoint ou héberge une salle. Le jeu n’a rien d’autre à faire : c’est le même **Trouver une partie** flux.

* **Les salles avec des places libres passent en premier.** Tant qu’une salle compte moins de `RELAY_MATCH_MAX_PLAYERS` (par défaut `4`) joueurs, dans la salle ou en route, le relais garde jusqu’à 3 backfills ouverts pour elle. Un joueur placé là rejoint cette salle.
* **Puis de nouvelles salles.** Une fois que chaque salle est pleine et que le relais a moins de `RELAY_MAX_ROOMS` (par défaut `4`) salles, il propose une nouvelle salle. Le joueur qui y est placé l'héberge, et la salle se remplit comme les autres.
* **Seulement les joueurs à proximité.** Le relais envoie les tickets des joueurs de la salle avec ses backfills, donc la `règle des balises` règle compare un nouveau joueur à ceux-ci.
* **Un hôte laissé seul** pendant `RELAY_SOLO_ROOM_SECONDS` (par défaut `120`) est informé que la salle est fermée, et le jeu cherche une autre partie de lui-même.
* **Le relais s'arrête lorsque sa dernière salle se termine**, et non lorsqu'un hôte part. Il supprime d'abord ses backfills, afin qu'aucun joueur ne soit envoyé vers un relais qui n'existe plus.
* **Limites de débit.** Au maximum 5 backfills sont ouverts par relais, créés à au moins 0,3 seconde d'intervalle.

☑️ Lorsqu'une partie se déroule entre deux jeux, appuyez sur **Trouver une partie** dans un troisième : il rejoint la salle en cours, et les trois jeux voient chacun trois tanks.

☑️ Remplissez une salle avec 4 jeux, puis appuyez sur **Trouver une partie** dans deux autres : le premier héberge une nouvelle salle sur le même relais, et le second la rejoint.

{% hint style="info" %}
Sans `MATCHMAKER_URL` et `MATCHMAKER_TOKEN` sur la version de l'application, le relais consigne `backfill : désactivé` : ses salles n'acceptent pas de nouveaux joueurs et il n'ouvre aucune nouvelle salle.
{% endhint %}

Le code de backfill du relais se trouve dans `relay-server/MatchBackfill.cs` et `relay-server/RelayServer.cs`.

## 🔒 Connexion chiffrée

Par défaut, le trafic du jeu via le relais n'est **pas chiffré** : il passe en TCP et UDP en clair. Ce qui protège les joueurs, c'est que personne ne voit l'adresse IP d'un autre joueur, et avec le matchmaker, seuls les joueurs appariés obtiennent le code de la salle. Les appels au matchmaker utilisent HTTPS.

Pour le chiffrement, les joueurs peuvent se connecter via un WebSocket à la place. Avec **mise à niveau TLS** sur le `relay-ws` port (étape 3), Edgegap détient le certificat et la connexion est `wss://` : le trafic entre chaque joueur et Edgegap est chiffré, et le relais n'a besoin d'aucun certificat.

☑️ Donnez au jeu une `wss://` adresse de relais au lieu d'un nom d'hôte, avec le port externe de `relay-ws` : à l'écran, dans `TanksSettings.asset`, ou dans la ligne de commande :

{% code collapsedlinecount="10" %}

```bash
Tanks.exe -netcode NGO -relay wss://<id>.pr.edgegap.net:<relay-ws external port> -host
```

{% endcode %}

☑️ Avec le matchmaker, activez **Utiliser le WebSocket du matchmaker** dans `TanksSettings.asset` (ou `-matchmakerWebSocket`) : le jeu se connecte au `relay-ws` port.

{% hint style="warning" %}
**WebSocket fonctionne uniquement sur TCP** : les messages « non fiables » arrivent de manière fiable et dans l'ordre, ce qui ajoute de la latence sur une mauvaise connexion. Cela convient mieux aux jeux coopératifs et au tour par tour qu'aux jeux de tir rapides, c'est donc une option à côté de TCP et UDP. Les joueurs sur TCP et UDP et les joueurs sur WebSocket peuvent partager une salle.
{% endhint %}

{% hint style="info" %}
Connectez-vous avec le nom d'hôte (`<id>.pr.edgegap.net`), pas l'adresse IP : le certificat est destiné au nom d'hôte. Le chiffrement s'arrête chez Edgegap : le relais, ainsi que le jeu de l'hôte, voient toujours ce qu'ils transfèrent, comme avec n'importe quel relais.
{% endhint %}

## 🌐 Jouer dans le navigateur

Une version WebGL du jeu fonctionne via le même relais sur `wss://`. Un joueur dans un navigateur peut héberger une salle ou en rejoindre une, avec les quatre netcodes, et la partager avec des joueurs sur des versions de bureau.

Les navigateurs n'ont pas de sockets TCP ou UDP, et les versions WebGL n'ont pas de .NET `ClientWebSocket` et pas de threads. Ainsi, dans une version WebGL, LightNet de l'exemple utilise le WebSocket natif du navigateur via un petit pont, `LightNet/Runtime/Relay/RelayWebSocket.jslib`. Les transports de netcode sont les mêmes que sur ordinateur.

☑️ Dans Unity, sélectionnez **Tanks > Générer le client WebGL**. La compilation va dans `tanks/Builds/WebGL`, non compressée, de sorte que n'importe quel serveur de fichiers statiques puisse la servir.

☑️ Ouvrez la page avec l'adresse du relais `wss://` dans l'URL, en utilisant le port externe de `relay-ws`. Une version WebGL n'a pas de ligne de commande, elle lit donc les mêmes options depuis l'adresse de la page. Le champ relais et les **Host** et **Join room** boutons à l'écran fonctionnent aussi.

{% code collapsedlinecount="10" %}

```
index.html?netcode=FishNet&relay=wss://<id>.pr.edgegap.net:<relay-ws external port>&host
index.html?netcode=FishNet&relay=wss://<id>.pr.edgegap.net:<relay-ws external port>&join=<room code>
```

{% endcode %}

{% hint style="warning" %}
**Gardez l'onglet de l'hôte au premier plan.** Les navigateurs mettent en pause les pages dans les onglets en arrière-plan, donc une salle hébergée dans un navigateur s'arrête lorsque son onglet est masqué. Une version de bureau fait un hôte plus stable.
{% endhint %}

{% hint style="info" %}
Une page servie en HTTPS ne peut ouvrir que `wss://`, pas `ws://`. Dans le navigateur, tout le trafic est fiable et ordonné, comme avec n'importe quelle connexion WebSocket. Avec le matchmaker, les navigateurs ne peuvent pas pinger les balises, donc utilisez un profil sans la `règle des balises` règle.
{% endhint %}

## 🧪 Test automatisé

Avec une version Windows et un relais en cours d'exécution (localement ou sur Edgegap), `e2e.sh` lance un hôte et un client sur chaque netcode :

{% code collapsedlinecount="10" %}

```bash
./e2e.sh <id>.pr.edgegap.net <external port>
./e2e.sh 127.0.0.1 7777 FishNet NGO
./e2e.sh wss://<id>.pr.edgegap.net:<relay-ws external port> 0
```

{% endcode %}

Le client se déplace et tire. Un netcode est validé lorsque les deux jeux voient deux tanks, ont tous deux reçu des données sur les canaux fiable et non fiable, ont tous deux vu apparaître un projectile, et que l'hôte a vu le tank du client bouger.

Avec un matchmaker, `e2e-matchmaker.sh` exécute le même test via lui : pour chaque netcode, deux jeux appuient sur **Trouver une partie** et jouent la partie sur le relais lancé par le matchmaker. Avec `BACKFILL=1`, un troisième jeu appuie sur **Trouver une partie** une fois que la partie est en cours et doit la rejoindre via backfill. Avec `MULTIROOM=1`, quatre jeux remplissent une salle, puis un cinquième doit héberger une nouvelle salle sur le même relais et un sixième doit la rejoindre. Avec `MM_WEBSOCKET=1`, les jeux se connectent via `wss://`.

{% code collapsedlinecount="10" %}

```bash
./e2e-matchmaker.sh https://<id>.edgegap.net <token>
./e2e-matchmaker.sh https://<id>.edgegap.net <token> FishNet NGO
BACKFILL=1 ./e2e-matchmaker.sh https://<id>.edgegap.net <token>
MM_WEBSOCKET=1 BACKFILL=1 ./e2e-matchmaker.sh https://<id>.edgegap.net <token>
MULTIROOM=1 ./e2e-matchmaker.sh https://<id>.edgegap.net <token>
```

{% endcode %}

## 💡 Bon à savoir

* **Comment le relais transfère les données** - les messages de l'hôte vont à un seul joueur, et les messages de chaque joueur vont uniquement à l'hôte. Les joueurs ne communiquent jamais directement entre eux. Les messages fiables passent par TCP et les messages non fiables par UDP, ou tous deux via un seul WebSocket.
* **Taille des messages** - jusqu'à 1 177 octets par message non fiable et 16 Ko par message fiable. Les transports signalent ces limites à leur netcode.
* **Lorsque l'hôte quitte** - la salle se ferme et le relais déconnecte ses joueurs. Les netcodes de cet exemple ne migrent pas l'hôte.
* **Un relais ou plusieurs** - un seul déploiement sert de nombreuses salles lorsque les joueurs utilisent des codes de salle. Avec le [matchmaker](#optional-matchmaking), chaque relais héberge jusqu'à `RELAY_MAX_ROOMS` salles à proximité de ses joueurs, et un nouveau relais ne démarre que lorsque les relais à proximité sont pleins.
* **Modifications apportées à LightNet** - LightNet de l'exemple fonctionne derrière le NAT et le redirectionnement de port : le relais répond au trafic UDP de chaque joueur à l'adresse d'où il provient. Consultez le README du dépôt pour la liste complète.
