Online 2-4p: sync fix, 60s planning ready gate, lobby polish, p2p_net v1.0.1

Players confirm orders before resolution; client keeps human_camp on state sync.
Disconnect grace 45s. Headless E2E and GDScript warning fixes.

Author: tom

godot/CHANGELOG.md

@@ -8,6 +8,78 @@ Format des entrées : `AAAA-MM-JJ HH:MM:SS` (heure locale, fuseau du commit Git
 
 ---
 
+## 2026-06-09 (sync) — Timer online 60 s + confirmation conjointe
+
+### Planification online
+- **60 s partagés** par manche (`GameSession.NETWORK_PLANNING_SEC`) — compte à rebours visible, pas 60 s « par joueur ».
+- Solo / IA : toujours **3600 s** (pas de limite pratique).
+- Bouton **Confirm orders** pour tous les joueurs online ; la manche ne se résout que quand **tout le monde a confirmé** ou à **0 s**.
+- Fix sync : le client conserve son camp (`human_camp`) après réception de l'état hôte (Bleu n'était plus Bleu).
+
+### Déconnexion
+- Grâce reconnexion **45 s** (était 90 s) — assez pour un crash/WiFi, sans bloquer la partie trop longtemps.
+
+---
+
+### Tests
+- **`full_match_test.gd`** : snapshot de round pris **après** placement des pièces (fix `tie: blue must bounce`).
+- Suite headless : **smoke**, **regression**, **compile**, **p2p**, **ForcesNet E2E 2p/4p** — tout OK.
+
+### Interface online
+- **Lobby réseau** : logo FORCES, slots joueurs par camp (couleur + statut Connected/Waiting/AI), bouton **Copy** du code, boutons Host/Join côte à côte, **Start match** mis en avant.
+- **Bataille** : barre **Online** en haut (camps connectés / away), overlay déconnexion avec titre coloré, barre de progression 90 s, texte type chess.com.
+- Menu principal : **Online multiplayer** (2–4 joueurs).
+
+---
+
+### `p2p_net` v1.0.1 (addon générique — **pas encore publié**)
+- **`ensure_local_signaling()`** — démarre le serveur WS embarqué sur le port 8080 (plus de terminal séparé pour le dev local).
+- Timeout signaling **15 s** (était 1 s — coupait les connexions lentes en éditeur).
+- Messages d’erreur explicites si le signaling est injoignable.
+- **`tools/setup_webrtc.ps1`** — télécharge webrtc-native Windows.
+- **`tools/sync_godot_p2p_net.ps1`** — sync local vers `godot-p2p-net` sans push.
+- **`assetlib/PUBLISH_PENDING.md`** — checklist publication (en attente accord Tom).
+
+### Forces online
+- Lobby : signaling prêt à l’ouverture ; guest voit « Connected to host — waiting for Start… ».
+- **`ForcesNet`** : ignore les messages non-JSON (tests P2P `ping`).
+
+---
+
+## 2026-06-09 (suite) — Online 2–4 joueurs + E2E headless
+
+### Réseau Forces (2 → 4 joueurs)
+- **`GameSession`** : `network_player_count`, `network_peer_camps`, assignation auto Blue/Red/Yellow à la connexion.
+- Lobby : sélecteur **2 / 3 / 4 players** ; Start quand tous les remotes sont connectés (WebRTC prêt).
+- **`ForcesNet.send_match_start()`** : config `peer_camps` + `player_count` ; clients appliquent camp via `apply_network_match_config`.
+- **`try_apply_network_order`** : host accepte ordres de tous les camps `NETWORK` (pas seulement Bleu).
+- Fix **`restore_from_snapshot`** : `pieces_moved_this_round` typé `Array[int]`.
+
+### Tests E2E
+- **`scenes/tests/forces_net_e2e_test.tscn`** : match_start → ordre distant → snapshot manche 2.
+- **`tools/run_forces_net_e2e.ps1 -Players 2|4`** ; inclus dans `run_headless.ps1 -Mode p2p`.
+
+### Publication — **STOP** (inchangé)
+
+---
+
+## 2026-06-09 (reconnect) — Déconnexion / reconnexion style chess.com
+
+### Comportement
+- **90 s** de grâce (`GameSession.DISCONNECT_GRACE_SEC`) avant abandon auto.
+- Timer de planification **gelé** pendant qu’un adversaire est déconnecté.
+- Overlay bataille : compte à rebours + bouton **Rejoin match** si tu es déconnecté.
+- Lobby : bouton **Rejoin previous match** si checkpoint valide.
+- Host envoie **resync** (snapshot complet) au joueur qui revient.
+- Signaling **reste ouvert** après `seal_lobby` pour permettre le re-Join WebRTC.
+
+### Protocole ForcesNet
+- `disconnect`, `reconnect`, `forfeit`, `resync` (JSON sur P2PNet).
+
+### p2p_net
+- `P2PNet.rejoin_room(code)` + `Lobby.rejoin()` côté serveur signaling.
+
+
 ## 2026-05-29 — Couche réseau Forces (`ForcesNet`, MVP 2 joueurs)
 
 ### Intégration au-dessus de `P2PNet` (pas dans l’addon)

godot/addons/p2p_net/README.md

@@ -1,87 +1,90 @@
-# p2p_net — addon réseau Godot 4
+# p2p_net — P2P networking addon for Godot 4
 
-Couche **transport P2P** jeu-agnostique : signaling WebSocket + WebRTC mesh, API bytes bruts.
+Game-agnostic **transport layer**: WebSocket signaling + WebRTC mesh, raw byte messages.
 
-## Prérequis
+## Requirements
 
-- Godot **4.6+**
-- Desktop : [webrtc-native](https://github.com/godotengine/webrtc-native) dans `res://webrtc/` (GDExtension)
-- HTML5 : WebRTC intégré (pas de GDExtension)
+- Godot **4.3+** (tested on 4.6)
+- **Desktop**: [webrtc-native](https://github.com/godotengine/webrtc-native) GDExtension in `res://webrtc/`
+- **HTML5**: built-in WebRTC (no extension)
 
-Première ouverture ou CI :
+After installing webrtc-native (Windows: `.\tools\setup_webrtc.ps1` in Forces, or extract [godot-extension-webrtc.zip](https://github.com/godotengine/webrtc-native/releases) into project root):
 
-```powershell
+```text
 godot --headless --path . --import --quit
 ```
 
 ## Installation
 
-1. Copier `addons/p2p_net/` dans le projet
-2. Activer le plugin **P2P Net** (Project → Project Settings → Plugins)
-3. L’autoload `P2PNet` est enregistré automatiquement
+1. Copy `addons/p2p_net/` into your project
+2. Enable **Project → Project Settings → Plugins → P2P Net**
+3. Autoload `P2PNet` is registered automatically
 
-## API (`P2PNet`)
+## Quick start
 
-| Méthode | Description |
-|---------|-------------|
-| `configure(config)` | `net_config.gd` : URL signaling, STUN/TURN, max peers |
-| `host_room(max_peers)` | Crée une salle (host = peer id `1` en mesh) |
-| `join_room(code)` | Rejoint une salle existante |
-| `seal_lobby()` | Host only — ferme le lobby signaling |
-| `leave()` | Quitte proprement (sans faux `connection_failed`) |
-| `send_to(id, bytes, reliable)` | → `Error` |
-| `broadcast(bytes, reliable)` | → `Error` |
-| `room_code()` / `is_in_room()` / `is_host()` / `my_peer_id()` / `peer_ids()` | État |
+```gdscript
+# Configure (optional)
+var cfg = load("res://addons/p2p_net/net_config.gd").defaults()
+cfg.signaling_url = "ws://127.0.0.1:8080"
+P2PNet.configure(cfg)
 
-### Signaux
+# Host — starts local signaling automatically if port 8080 is free
+P2PNet.ensure_local_signaling()
+P2PNet.room_ready.connect(func(code): print("Room: ", code))
+P2PNet.host_room(4)
 
-`room_ready`, `room_sealed`, `room_left`, `peer_joined`, `peer_left`, `message_received`, `connection_failed`
+# Join
+P2PNet.join_room("YOUR_ROOM_CODE")
 
-`peer_joined` = WebRTC data channels prêts (pas seulement signaling).
+# When peer_joined fires (WebRTC ready):
+P2PNet.send_to(peer_id, "hello".to_utf8_buffer())
+P2PNet.message_received.connect(func(from_id, data): print(data.get_string_from_utf8()))
+```
 
-## Configuration TURN (optionnel)
+## Local signaling server
 
-```gdscript
-var cfg = load("res://addons/p2p_net/net_config.gd").defaults()
-cfg.turn_url = "turn:your.server:3478"
-cfg.turn_username = "user"
-cfg.turn_password = "pass"
-P2PNet.configure(cfg)
-```
+**Automatic (recommended):** call `P2PNet.ensure_local_signaling()` before `host_room()` — listens on `ws://127.0.0.1:8080` inside the game process. If the port is already in use, an external server is assumed (second game instance, dedicated server, etc.).
 
-## Serveur signaling local
+**Manual (optional):**
 
-```powershell
+```text
 godot --headless --path . res://addons/p2p_net/server/signaling_server.tscn
 ```
 
-Écoute `ws://127.0.0.1:8080`. Protocole compatible [demo officielle Godot `webrtc_signaling`](https://github.com/godotengine/godot-demo-projects/tree/master/networking/webrtc_signaling).
+## API summary
 
-`max_peers` est transmis à la création de salle et enforced côté serveur.
+| Method | Description |
+|--------|-------------|
+| `ensure_local_signaling()` | Start embedded signaling on `config.signaling_url` port (desktop) |
+| `host_room(max_peers)` | Create a room (auto-starts local signaling) |
+| `join_room(code)` | Join existing room |
+| `seal_lobby()` | Host closes signaling lobby |
+| `leave()` | Clean disconnect |
+| `send_to(id, bytes, reliable)` | Returns `Error` |
+| `broadcast(bytes, reliable)` | Returns `Error` |
+| `room_code()` / `is_in_room()` / `is_host()` | State |
 
-## Tests
+**Signals:** `room_ready`, `room_sealed`, `room_left`, `peer_joined`, `peer_left`, `message_received`, `connection_failed`
 
-```powershell
-cd godot
-.\tools\run_p2p_smoke.ps1      # 2 joueurs
-.\tools\run_p2p_all.ps1        # suite V1 complète
-.\tools\run_headless.ps1 -Mode p2p
-```
+`peer_joined` means WebRTC data channels are ready, not just signaling.
 
-Suite `run_p2p_all` : import GDExtension, salle invalide, smoke 2p, salle pleine, mesh 4p, `seal_lobby`.
+## TURN (optional)
 
-## Backends
+```gdscript
+cfg.turn_url = "turn:your.server:3478"
+cfg.turn_username = "user"
+cfg.turn_password = "pass"
+```
 
-| Backend | État |
-|---------|------|
-| `WEBRTC_SIGNALING` | **V1.0** |
-| `JANUS` | stub |
+## Tests (optional)
 
-## Hors scope addon
+```powershell
+.\tools\setup_webrtc.ps1          # Windows — download webrtc-native once
+.\tools\run_headless.ps1 -Mode p2p
+```
 
-- Règles de jeu Forces (`GameOrder`, sync état) → couche `forces_net_adapter` séparée
-- UI lobby / matchmaking
+Headless smoke tests live in `addons/p2p_net/test/`. They require webrtc-native on desktop.
 
-## Version
+## License
 
-`1.0.0` — voir `plugin.cfg`
+MIT — see repository root `LICENSE`.

godot/addons/p2p_net/p2p_net.gd

@@ -14,10 +14,12 @@ signal connection_failed(reason: String)
 const NetConfigScript = preload("res://addons/p2p_net/net_config.gd")
 const WebRtcMeshTransportScript = preload("res://addons/p2p_net/transport/webrtc_mesh_transport.gd")
 const JanusTransportScript = preload("res://addons/p2p_net/transport/janus_transport.gd")
+const SignalingServerScript = preload("res://addons/p2p_net/server/ws_signaling_server.gd")
 
 var config  # P2PNetConfig
 var _transport  # P2PTransportBackend
 var _backend_kind: Backend = Backend.WEBRTC_SIGNALING
+var _local_signaling: Node
 
 
 func _ready() -> void:
@@ -62,14 +64,38 @@ func _wire_transport() -> void:
 	_transport.connection_failed.connect(func(reason: String) -> void: connection_failed.emit(reason))
 
 
+func ensure_local_signaling() -> bool:
+	if OS.has_feature("web"):
+		return false
+	if _local_signaling != null and is_instance_valid(_local_signaling):
+		return _local_signaling.is_listening()
+	_local_signaling = SignalingServerScript.new()
+	_local_signaling.name = "LocalSignaling"
+	add_child(_local_signaling)
+	return _local_signaling.is_listening()
+
+
 func host_room(max_peers: int = 4) -> void:
+	if not ensure_local_signaling():
+		connection_failed.emit(
+			"Local signaling server unavailable (port 8080). Close other apps using it."
+		)
+		return
 	if _transport:
 		_transport.host_room(max_peers)
 
 
-func join_room(room_code: String) -> void:
+func join_room(code: String) -> void:
+	if _transport:
+		_transport.join_room(code)
+
+
+func rejoin_room(code: String) -> void:
+	if not ensure_local_signaling():
+		connection_failed.emit("Signaling unavailable for rejoin.")
+		return
 	if _transport:
-		_transport.join_room(room_code)
+		_transport.rejoin_room(code)
 
 
 func seal_lobby() -> Error:

godot/addons/p2p_net/plugin.cfg

@@ -1,7 +1,7 @@
 [plugin]
 
 name="P2P Net"
-description="Couche réseau générique : signaling WebSocket + WebRTC mesh, API bytes bruts (jeu-agnostique)."
-author="Forces"
-version="1.0.0"
+description="Generic P2P layer: WebSocket signaling + WebRTC mesh, raw bytes API (game-agnostic)."
+author="Tom"
+version="1.0.1"
 script="plugin.gd"