- NetSession::enter($id, $maxPeers) rejoint ou crée une salle d'identifiant long (room-id.patch du relais), newRoomId(), isRoomId(), attach() (autre transport / faux en test), MAX_PAYLOAD = 65535, erreur room-id si le relais ne garde pas l'identifiant - HttpServer + HttpRequest + HttpResponse : HTTP/1.1 sur le bureau, poll() par frame, fichiers par blocs de 64 Ko avec Range (206/416), HEAD, keep-alive, filtre d'adresse (isPrivateAddress), ports 47610+ - tests HttpServerTest, NetRoomTest (faux transport + vrai relais), docs/reseau.md, AGENTS.md §9 Co-Authored-By: Claude Opus 5.5 <[email protected]>
109 lines
6.7 KiB
Markdown
109 lines
6.7 KiB
Markdown
# Réseau (multijoueur en ligne)
|
|
|
|
Basé sur [php-wasm-network](https://git.jumphp.net/jumphp/php-wasm-network) : même API en natif
|
|
(WebSocket en PHP pur) et dans le navigateur (extension `wasmnet` du moteur + `php-wasm-network.js` :
|
|
WebSocket, et WebRTC direct entre navigateurs quand c'est possible). Rien ne bloque la frame (sauf la
|
|
toute première connexion sur le bureau, 5 s maximum).
|
|
|
|
## Serveur
|
|
|
|
```bash
|
|
bin/jumphp relay up # ws://localhost:8090/ws (logs : bin/jumphp relay logs)
|
|
```
|
|
|
|
Image `docker/relay` (le serveur `server/bin/server.php` du même commit que le moteur). En production :
|
|
le dossier `server/` de php-wasm-network (Caddy TLS + relais + coturn pour WebRTC), puis `net_url:
|
|
wss://domaine/ws` dans `project.yaml` ou `?net=wss://domaine/ws` dans l'URL du jeu. Une page en HTTPS exige
|
|
`wss://`.
|
|
|
|
## Côté jeu
|
|
|
|
1. **Salon** : `LobbyScene` (créer une salle → code de 4 lettres, rejoindre avec un code, partie rapide) ;
|
|
paramètres `next`, `nextParams`, `back`, `players`, `auto` (`quick` / `host` / code). `?room=ABCD` dans
|
|
l'URL rejoint directement la salle.
|
|
2. **Partie** : la scène reçoit `['online' => true, 'net' => NetSession, 'host' => bool, 'peer' => int]`.
|
|
3. **Messages** : un octet de type + données. JSON pour le rare (`sendJson`), `pack()` pour l'état fréquent
|
|
(`send($type, pack('gg', $x, $y), reliable: false)`). Lecture : événement `message` (`$from`, `$type`,
|
|
`$payload`), `MessageCodec::unpack()` / `unjson()`.
|
|
4. **Autorité** : l'hôte simule et envoie des instantanés (~20/s), les autres envoient leurs entrées / état
|
|
(~30/s), affichés avec `SnapshotBuffer` (100-120 ms dans le passé, interpolés).
|
|
|
|
Exemple complet : `games/pong/src/Scene/PlayScene.php` (+ `src/Net/PongProtocol.php`).
|
|
|
|
Événements de `NetSession` : `open`, `close`, `error` (`no-room`, `room-full`...), `room`, `peerJoin`,
|
|
`peerLeave`, `host` (l'hôte est parti : un autre le devient), `message`, `pong` (après `ping()`).
|
|
Limites : 16 joueurs par salle, 64 Ko par message, `reliable: false` n'a d'effet qu'en WebRTC.
|
|
|
|
## Salles privées par identifiant long (cloud, appairage)
|
|
|
|
Pour relier les appareils d'un même compte (ou d'un appairage) sans code à taper : chacun appelle
|
|
`enter()` avec le même identifiant long et imprévisible (32 à 64 caractères `[A-Za-z0-9_-]`). Le premier
|
|
crée la salle, les suivants y entrent, un appareil qui revient y rentre à nouveau. Jamais listée.
|
|
|
|
```php
|
|
$room = NetSession::newRoomId(); // 32 caractères, 192 bits (à garder côté compte)
|
|
$net = $engine->net();
|
|
$net->connect(); // ou attach($connection) pour un autre transport / un faux en test
|
|
$net->enter($room, maxPeers: 8); // crée ou rejoint ; maxPeers ne compte que pour celui qui crée
|
|
$net->on('peerJoin', fn (int $peer) => ...); // présence : peerJoin / peerLeave, peers()
|
|
$net->sendJson(40, ['t' => 'want', 'entry' => $id, 'offset' => 0], to: $peer);
|
|
$net->send(41, $bytes, to: $peer); // binaire, jusqu'à NetSession::MAX_PAYLOAD = 65535 octets
|
|
```
|
|
|
|
Il faut le relais patché (`docker/relay/room-id.patch`, déjà dans l'image de `bin/jumphp relay up` et de la
|
|
prod) : un relais d'origine ignore l'identifiant et répond avec un code de 4 lettres, `NetSession` quitte
|
|
alors cette salle et émet l'erreur `room-id`. Autres erreurs : `room-full`. `join($id)` garde la casse d'un
|
|
identifiant long. Une salle vide disparaît 90 s après le départ du dernier. Le relais voit tout ce qui passe :
|
|
chiffrer ce qui est privé (le cloud de WinZik chiffre ses blocs en AES-256-GCM).
|
|
|
|
Tests : `engine/tests/Net/NetRoomTest.php` (faux transport, et deux sessions contre le vrai relais quand
|
|
`bin/jumphp relay up` tourne ; `JUMPHP_TEST_RELAY=ws://hôte:port/ws` pour un autre).
|
|
|
|
## Serveur HTTP local (`HttpServer`, bureau seulement)
|
|
|
|
Un petit serveur HTTP/1.1 non bloquant pour partager des fichiers sur le réseau local (le PC sert un MP3 au
|
|
téléphone). `poll()` accepte, lit et écrit ce qui est prêt, une quantité bornée par appel (1 Mo par client) :
|
|
l'appeler à chaque frame, ou `attach()` (minuteur de la boucle toutes les 5 ms, arrêté par `close()`).
|
|
|
|
```php
|
|
$server = new HttpServer(allow: fn (string $ip) => HttpServer::isPrivateAddress($ip));
|
|
$server->handle('/f/', fn (HttpRequest $r) => isset($tokens[$r->path])
|
|
? HttpResponse::file($tokens[$r->path], 'audio/mpeg') : null); // null = 404
|
|
$port = $server->listen(); // 0.0.0.0, premier port libre à partir de 47610 (20 essais)
|
|
// chaque frame : $server->poll(); ... $server->close();
|
|
```
|
|
|
|
- Gestionnaires par préfixe de chemin (le plus long gagne) ; `HttpRequest` : `method`, `path` (décodé, sans
|
|
query), `query`, `headers` (noms en minuscules), `body` (1 Mo max), `remoteAddress`.
|
|
- Réponses : `HttpResponse::text()`, `json()`, `status(404)`, `file($chemin, $type)` : lu par blocs de 64 Ko,
|
|
jamais en entier ; `Range: bytes=a-b`, `a-`, `-n` (206, `Content-Range`), au-delà de la fin 416
|
|
(`bytes */taille`), plusieurs plages = fichier entier ; `HEAD`, `Content-Length`, `Accept-Ranges`.
|
|
- Keep-alive HTTP/1.1 (requêtes en file traitées une par une), `Connection: close` respecté, clients
|
|
inactifs fermés après 30 s, plusieurs clients en même temps.
|
|
- Filtre d'adresse : un client refusé reçoit 403 puis est fermé. `HttpServer::isPrivateAddress()` : boucle
|
|
locale, RFC 1918, lien local (169.254/16, fe80::/10), ULA fc00::/7, IPv4 mappées.
|
|
- Pas dans le navigateur (aucune socket d'écoute) : `HttpServer::isSupported()` est faux et `listen()` lève
|
|
une `RuntimeException`. Sous Windows, le pare-feu demande l'autorisation à la première écoute sur 0.0.0.0.
|
|
|
|
Tests : `engine/tests/Net/HttpServerTest.php` (GET, Range, 404, 416, HEAD, keep-alive, deux clients en même
|
|
temps, filtre d'adresse, fichier de 20 Mo envoyé par blocs sans le charger).
|
|
|
|
## Tester sans écran
|
|
|
|
Deux processus en temps réel (`JUMPHP_REALTIME=1`), appariés par « partie rapide » :
|
|
|
|
```bash
|
|
bin/jumphp relay up
|
|
P='{"next":"App\\Scene\\PlayScene","nextParams":{"mode":"online"},"back":"App\\Scene\\TitleScene","auto":"quick"}'
|
|
for n in a b; do
|
|
docker run --rm --network host --user "$(id -u):$(id -g)" -v "$PWD:/workspace" -w /workspace/games/pong \
|
|
-e HOME=/tmp -e JUMPHP_SMOKE=1 -e JUMPHP_REALTIME=1 -e JUMPHP_MAX_FRAMES=600 \
|
|
-e JUMPHP_SCREENSHOT=var/screenshots/net-$n.png -e 'JUMPHP_SCENE=JumPHP\Net\LobbyScene' \
|
|
-e "JUMPHP_SCENE_PARAMS=$P" -e JUMPHP_NET_URL=ws://127.0.0.1:8090/ws jumphp/desktop:dev php app.php &
|
|
sleep 1
|
|
done; wait
|
|
```
|
|
|
|
Les deux captures montrent la même partie (hôte à gauche, invité à droite). Navigateur contre bureau :
|
|
lancer un des deux clients ci-dessus puis `bin/jumphp webshot pong 14 '[[1.5,"ArrowDown"],[2,"ArrowDown"],[2.5,"Enter"],[4,"ArrowDown"],[4.5,"ArrowDown"],[5,"Enter"]]'`
|
|
(ONLINE puis QUICK MATCH).
|