Files
tidewall/src/net/net_server.gd
T
claudeandClaude Opus 5.5 05c7568ec1 N8: 24-client network soak, and the server fixes it found
make soak runs a real server and 24 headless clients in three processes for
two whole matches in real time. Each client reaches the server through its own
UdpRelay, which adds 60 ms, +/-20 ms jitter and 2% loss each way, so ENet runs
unchanged over a bad link. SoakPlayer drives each client from what a client
knows: it drops, glides, heads for high ground, harvests and tries to build.
tools/soak_report.gd checks world hashes against the server's, errors,
unreadable packets, every client playing every match with its connection
intact, memory between matches, and the p99 tick with the network's share.
make soak-selfcheck proves a drifted client world is caught.

Server changes: --matches=N, --world-hash-every=N, tick timing that includes
after_tick, and memory in match and progress lines.

What the soak found and fixed:
- Snapshot building for 24 clients took the p99 tick to 13.8 ms, over the
  12 ms budget, against a 2.8 ms simulation. Encoded records are now shared
  between clients for the tick, unchanged records skip the field diff, and
  clients are spread over the snapshot interval by handle. p99 is 7.3 ms.
- ENet peers had a timeout limit of 0, which gives up on a peer as soon as any
  reliable message has waited the minimum timeout. Now ENet's default, 32.

Not fixed: one or two clients still lose their connection about 15 s into the
second match's drop in each run (see the issue), so the soak still fails and
N8 stays open.

Refs #39

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 21:56:01 -05:00

242 lines
9.0 KiB
GDScript

## The server's end of the transport: listens with ENet, takes each new connection
## through the handshake, and reports who joined and who left. It decides nothing about
## the match; whoever owns it reads `events` after each poll().
##
## A connection is a guest until its HELLO is accepted. Guests can't do anything else,
## get one try, and are dropped if they stay silent past the handshake timeout. Player
## handles are positive, count up from 1 and are never reused while the server runs.
class_name NetServer
extends RefCounted
## Milliseconds a new connection has to send its HELLO.
var handshake_timeout_msec: int = 5000
## ENet drops a peer that acknowledges nothing for between these two times.
var peer_timeout_min_msec: int = 5000
var peer_timeout_max_msec: int = 15000
## Players allowed at once. Further clients are told the server is full.
var max_players: int = Tuning.SOLO_PLAYERS
## Sent to each client in its WELCOME, so it can generate the same island.
var match_seed: int = 0
## What happened during the last poll(): {"type": "joined", "handle", "name"},
## {"type": "left", "handle", "name", "reason"} and {"type": "refused", "reason"}.
var events: Array[Dictionary] = []
## Game packets from joined players during the last poll(), in arrival order:
## {"handle", "bytes"}. Whoever owns the server decodes them.
var packets: Array[Dictionary] = []
## The most game packets kept from one player in one poll(); the rest are dropped.
var max_packets_per_poll: int = 32
## Malformed or unexpected packets dropped so far.
var bad_packets: int = 0
## New connections allowed from one address per window. Generous enough for a LAN
## party behind one router joining at once; a flood from one address is turned away.
var connect_limiter: SourceLimiter = SourceLimiter.new(32, 10000, 4096)
## Connections from one address still in the handshake at once.
var max_guests_per_address: int = 8
var _host: ENetConnection = null
## Peers that haven't finished the handshake: ENetPacketPeer -> msec they connected.
var _guests: Dictionary = {}
## Peers being turned away: ENetPacketPeer -> the reason, until ENet reports them gone.
var _leaving: Dictionary = {}
## Handle -> {"peer": ENetPacketPeer, "name": String}.
var _players: Dictionary = {}
## ENetPacketPeer -> handle.
var _handle_of: Dictionary = {}
var _next_handle: int = 1
## Handle -> game packets kept from them during this poll().
var _packets_from: Dictionary = {}
## Starts listening on UDP `port` (0 picks a free one) on `address`. Returns OK or the
## error, and leaves the server closed on failure.
func listen(port: int, address: String = "*") -> Error:
close()
var host: ENetConnection = ENetConnection.new()
# Room for a few guests beyond the player limit, so a full server can say so.
var error: Error = host.create_host_bound(address, port, max_players + 8, NetProtocol.CHANNEL_COUNT)
if error != OK:
return error
_host = host
return OK
func is_listening() -> bool:
return _host != null
## The UDP port in use, or 0 when closed.
func port() -> int:
return _host.get_local_port() if _host != null else 0
func player_count() -> int:
return _players.size()
func guest_count() -> int:
return _guests.size()
func handles() -> Array[int]:
var result: Array[int] = []
for handle: int in _players:
result.append(handle)
result.sort()
return result
## The accepted name of a player, or an empty string.
func name_of(handle: int) -> String:
return String(_players[handle]["name"]) if _players.has(handle) else ""
## Services the socket: accepts connections, runs handshakes, notices departures.
## Call it every frame. `now_msec` is for tests; it defaults to the engine's clock.
func poll(now_msec: int = -1) -> void:
events.clear()
packets.clear()
_packets_from.clear()
if _host == null:
return
var now: int = now_msec if now_msec >= 0 else Time.get_ticks_msec()
while true:
var event: Array = _host.service(0)
var kind: int = event[0]
if kind == ENetConnection.EVENT_NONE or kind == ENetConnection.EVENT_ERROR:
break
var peer: ENetPacketPeer = event[1]
match kind:
ENetConnection.EVENT_CONNECT:
peer.set_timeout(NetProtocol.PEER_TIMEOUT_LIMIT, peer_timeout_min_msec, peer_timeout_max_msec)
var address: String = peer.get_remote_address()
if not connect_limiter.allow(address, now) or _guests_from(address) >= max_guests_per_address:
_refuse(peer, NetProtocol.REASON_BUSY)
continue
_guests[peer] = now
ENetConnection.EVENT_DISCONNECT:
_gone(peer, int(event[2]))
ENetConnection.EVENT_RECEIVE:
_received(peer, int(event[3]), peer.get_packet())
for peer: ENetPacketPeer in _guests.keys():
if now - int(_guests[peer]) >= handshake_timeout_msec:
_refuse(peer, NetProtocol.REASON_HANDSHAKE_TIMEOUT)
## Sends `bytes` to a player. Returns false if they aren't connected.
func send(handle: int, channel: int, bytes: PackedByteArray, reliable: bool) -> bool:
if not _players.has(handle):
return false
var peer: ENetPacketPeer = _players[handle]["peer"]
var flags: int = ENetPacketPeer.FLAG_RELIABLE if reliable else ENetPacketPeer.FLAG_UNSEQUENCED
return peer.send(channel, bytes, flags) == OK
## Removes a player, telling them why. They are reported as "left" at once.
func kick(handle: int, reason: int = NetProtocol.REASON_KICKED) -> bool:
if not _players.has(handle):
return false
var peer: ENetPacketPeer = _players[handle]["peer"]
events.append({"type": "left", "handle": handle, "name": name_of(handle), "reason": reason})
_players.erase(handle)
_handle_of.erase(peer)
_leaving[peer] = reason
peer.send(NetProtocol.CHANNEL_CONTROL, NetProtocol.encode_reject(reason), ENetPacketPeer.FLAG_RELIABLE)
peer.peer_disconnect_later(reason)
return true
## Stops listening. Everyone connected is told the server shut down.
func close() -> void:
if _host == null:
return
for peer: ENetPacketPeer in _guests.keys() + _handle_of.keys() + _leaving.keys():
if peer.is_active():
peer.peer_disconnect_now(NetProtocol.REASON_SHUTDOWN)
_host.flush()
_host.destroy()
_host = null
_guests.clear()
_leaving.clear()
_players.clear()
_handle_of.clear()
func _received(peer: ENetPacketPeer, channel: int, bytes: PackedByteArray) -> void:
if _leaving.has(peer):
return
if _handle_of.has(peer):
# Game traffic goes to the owner. A second HELLO, anything on the control
# channel, and a flood are dropped.
var handle: int = _handle_of[peer]
var count: int = int(_packets_from.get(handle, 0))
if channel != NetProtocol.CHANNEL_STATE or bytes.is_empty() or count >= max_packets_per_poll:
bad_packets += 1
return
_packets_from[handle] = count + 1
packets.append({"handle": handle, "bytes": bytes})
return
if not _guests.has(peer):
return
var hello: Dictionary = NetProtocol.decode_hello(bytes) if channel == NetProtocol.CHANNEL_CONTROL else {}
if hello.is_empty():
bad_packets += 1
_refuse(peer, NetProtocol.REASON_BAD_HELLO)
elif int(hello["version"]) != NetProtocol.VERSION:
_refuse(peer, NetProtocol.REASON_VERSION)
elif _players.size() >= max_players:
_refuse(peer, NetProtocol.REASON_FULL)
else:
_guests.erase(peer)
var handle: int = _next_handle
_next_handle += 1
var player_name: String = _unique_name(String(hello["name"]))
_players[handle] = {"peer": peer, "name": player_name}
_handle_of[peer] = handle
peer.send(NetProtocol.CHANNEL_CONTROL, NetProtocol.encode_welcome(handle, match_seed, max_players, player_name), ENetPacketPeer.FLAG_RELIABLE)
events.append({"type": "joined", "handle": handle, "name": player_name})
## Turns a guest away: tells it why, then disconnects once that has been delivered.
func _refuse(peer: ENetPacketPeer, reason: int) -> void:
_guests.erase(peer)
_leaving[peer] = reason
events.append({"type": "refused", "reason": reason})
peer.send(NetProtocol.CHANNEL_CONTROL, NetProtocol.encode_reject(reason), ENetPacketPeer.FLAG_RELIABLE)
peer.peer_disconnect_later(reason)
func _gone(peer: ENetPacketPeer, data: int) -> void:
_guests.erase(peer)
_leaving.erase(peer)
if not _handle_of.has(peer):
return
var handle: int = _handle_of[peer]
# A client that says goodbye sends REASON_LEFT; one that just vanishes sends nothing.
var reason: int = NetProtocol.REASON_LEFT if data == NetProtocol.REASON_LEFT else NetProtocol.REASON_LOST
events.append({"type": "left", "handle": handle, "name": name_of(handle), "reason": reason})
_players.erase(handle)
_handle_of.erase(peer)
func _guests_from(address: String) -> int:
var count: int = 0
for peer: ENetPacketPeer in _guests:
if peer.get_remote_address() == address:
count += 1
return count
## `wanted`, or `wanted` with a number after it if someone here already has that name.
func _unique_name(wanted: String) -> String:
var taken: Dictionary = {}
for handle: int in _players:
taken[String(_players[handle]["name"]).to_lower()] = true
if not taken.has(wanted.to_lower()):
return wanted
for number: int in range(2, max_players + 2):
var suffix: String = " %d" % number
var candidate: String = wanted.substr(0, NetProtocol.NAME_MAX_CHARS - suffix.length()).strip_edges() + suffix
if not taken.has(candidate.to_lower()):
return candidate
return wanted