NetSnapshot defines the game traffic after the handshake: delta snapshots of quantized entity records, the client's input packet and a reliable match notice. SnapshotSender builds each client's snapshot against the newest one it acknowledged, tells it only about entities near the player it is watching, and keeps every snapshot under 1,200 bytes, nearest first, with a staleness bonus so nothing starves. SnapshotReceiver rebuilds the picture, ignores old and repeated snapshots and asks for a fresh start if it is ever sent a delta on something it doesn't hold. NetGame joins the transport to the match: people who connect become participants, their inputs go through ServerLoop.submit() once per tick, and snapshots go out 20 times a second. `--server --listen` makes the headless server take network players and wait in the lobby for the first of them. Measured by test on a 24-player match start with every player a client, a tenth of packets lost and late acknowledgements: 2.4 KB/s mean and 2.5 KB/s for the worst client, packet headers included, against a 40 KB/s limit. Closes #33 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
303 lines
12 KiB
GDScript
303 lines
12 KiB
GDScript
extends TestCase
|
|
|
|
## Issue N1: a real NetServer and NetClients over loopback UDP. Handshake, refusals,
|
|
## clean leaves, timeouts, and hostile or broken peers.
|
|
|
|
const HOST: String = "127.0.0.1"
|
|
|
|
var server: NetServer
|
|
var clients: Array[NetClient] = []
|
|
## Every server event since the test began.
|
|
var seen: Array[Dictionary] = []
|
|
var raw_hosts: Array[ENetConnection] = []
|
|
## Game packets the server handed to its owner since the test began.
|
|
var handed: int = 0
|
|
|
|
|
|
func before_each() -> void:
|
|
server = NetServer.new()
|
|
server.match_seed = 4242
|
|
clients.clear()
|
|
seen.clear()
|
|
handed = 0
|
|
raw_hosts.clear()
|
|
assert_eq(server.listen(0, HOST), OK)
|
|
assert_true(server.port() > 0)
|
|
|
|
|
|
func after_each() -> void:
|
|
for client: NetClient in clients:
|
|
client.leave()
|
|
for host: ENetConnection in raw_hosts:
|
|
host.destroy()
|
|
server.close()
|
|
|
|
|
|
func _client(wanted: String) -> NetClient:
|
|
var client: NetClient = NetClient.new()
|
|
clients.append(client)
|
|
assert_eq(client.connect_to(HOST, server.port(), wanted), OK)
|
|
return client
|
|
|
|
|
|
## Polls everything until `done` is true or `limit_msec` passes. Returns `done`'s answer.
|
|
func _pump(done: Callable, limit_msec: int = 4000) -> bool:
|
|
var started: int = Time.get_ticks_msec()
|
|
while Time.get_ticks_msec() - started < limit_msec:
|
|
server.poll()
|
|
seen.append_array(server.events)
|
|
handed += server.packets.size()
|
|
for client: NetClient in clients:
|
|
client.poll()
|
|
for host: ENetConnection in raw_hosts:
|
|
_service_raw(host)
|
|
if done.call():
|
|
return true
|
|
OS.delay_msec(2)
|
|
return bool(done.call())
|
|
|
|
|
|
func _events(type: String) -> Array[Dictionary]:
|
|
var found: Array[Dictionary] = []
|
|
for event: Dictionary in seen:
|
|
if event["type"] == type:
|
|
found.append(event)
|
|
return found
|
|
|
|
|
|
# A bare ENet peer, for sending what a real client never would.
|
|
|
|
var _raw_state: Dictionary = {}
|
|
|
|
|
|
func _raw() -> ENetPacketPeer:
|
|
var host: ENetConnection = ENetConnection.new()
|
|
assert_eq(host.create_host(1, NetProtocol.CHANNEL_COUNT), OK)
|
|
var peer: ENetPacketPeer = host.connect_to_host(HOST, server.port(), NetProtocol.CHANNEL_COUNT)
|
|
raw_hosts.append(host)
|
|
_raw_state[host] = {"connected": false, "disconnect_data": -1, "packets": []}
|
|
assert_true(_pump(func() -> bool: return _raw_state[host]["connected"]), "the raw peer connected")
|
|
return peer
|
|
|
|
|
|
func _service_raw(host: ENetConnection) -> void:
|
|
while true:
|
|
var event: Array = host.service(0)
|
|
if event[0] == ENetConnection.EVENT_NONE or event[0] == ENetConnection.EVENT_ERROR:
|
|
return
|
|
var state: Dictionary = _raw_state[host]
|
|
if event[0] == ENetConnection.EVENT_CONNECT:
|
|
state["connected"] = true
|
|
elif event[0] == ENetConnection.EVENT_DISCONNECT:
|
|
state["disconnect_data"] = int(event[2])
|
|
elif event[0] == ENetConnection.EVENT_RECEIVE:
|
|
state["packets"].append((event[1] as ENetPacketPeer).get_packet())
|
|
|
|
|
|
func test_a_client_joins() -> void:
|
|
var client: NetClient = _client(" Mara\tof the Reef ")
|
|
assert_eq(client.state, NetClient.CONNECTING)
|
|
assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED), client.status_text())
|
|
assert_eq(client.handle, 1)
|
|
assert_eq(client.player_name, "Mara of the Reef")
|
|
assert_eq(client.match_seed, 4242)
|
|
assert_eq(client.max_players, Tuning.SOLO_PLAYERS)
|
|
assert_eq(client.tick_rate, Tuning.TICK_RATE_HZ)
|
|
assert_eq(client.server_version, NetProtocol.VERSION)
|
|
assert_eq(_events("joined"), [{"type": "joined", "handle": 1, "name": "Mara of the Reef"}] as Array[Dictionary])
|
|
assert_eq(server.player_count(), 1)
|
|
assert_eq(server.guest_count(), 0)
|
|
assert_eq(server.name_of(1), "Mara of the Reef")
|
|
assert_eq(client.status_text(), "Joined as Mara of the Reef.")
|
|
|
|
|
|
func test_a_version_mismatch_is_refused_clearly() -> void:
|
|
var client: NetClient = NetClient.new()
|
|
client.protocol_version = NetProtocol.VERSION + 1
|
|
clients.append(client)
|
|
assert_eq(client.connect_to(HOST, server.port(), "Mara"), OK)
|
|
assert_true(_pump(func() -> bool: return client.state == NetClient.CLOSED), client.state_name())
|
|
assert_eq(client.close_reason, NetProtocol.REASON_VERSION)
|
|
assert_eq(client.server_version, NetProtocol.VERSION)
|
|
var text: String = client.status_text()
|
|
assert_true(text.contains("older version") and text.contains("protocol %d" % NetProtocol.VERSION), text)
|
|
assert_eq(server.player_count(), 0)
|
|
assert_eq(_events("refused"), [{"type": "refused", "reason": NetProtocol.REASON_VERSION}] as Array[Dictionary])
|
|
assert_true(_events("joined").is_empty())
|
|
|
|
|
|
func test_a_full_server_says_so() -> void:
|
|
server.max_players = 2
|
|
var first: NetClient = _client("One")
|
|
var second: NetClient = _client("Two")
|
|
assert_true(_pump(func() -> bool: return first.state == NetClient.JOINED and second.state == NetClient.JOINED))
|
|
var third: NetClient = _client("Three")
|
|
assert_true(_pump(func() -> bool: return third.state == NetClient.CLOSED))
|
|
assert_eq(third.close_reason, NetProtocol.REASON_FULL)
|
|
assert_eq(third.status_text(), "The server is full.")
|
|
assert_eq(server.player_count(), 2)
|
|
# A place opens when someone leaves.
|
|
first.leave()
|
|
assert_true(_pump(func() -> bool: return server.player_count() == 1))
|
|
var fourth: NetClient = _client("Four")
|
|
assert_true(_pump(func() -> bool: return fourth.state == NetClient.JOINED))
|
|
assert_eq(fourth.handle, 3, "handles are never reused")
|
|
|
|
|
|
func test_duplicate_names_get_a_number() -> void:
|
|
var first: NetClient = _client("Mara")
|
|
assert_true(_pump(func() -> bool: return first.state == NetClient.JOINED))
|
|
var second: NetClient = _client("mara")
|
|
var third: NetClient = _client("Mara")
|
|
assert_true(_pump(func() -> bool: return second.state == NetClient.JOINED and third.state == NetClient.JOINED))
|
|
var names: Array[String] = [first.player_name, second.player_name, third.player_name]
|
|
names.sort()
|
|
assert_eq(names.size(), 3)
|
|
assert_true(names.has("Mara") and (names.has("mara 2") or names.has("Mara 2")), "names %s" % [names])
|
|
assert_ne(second.player_name.to_lower(), third.player_name.to_lower())
|
|
|
|
|
|
func test_a_clean_leave_is_seen_at_once() -> void:
|
|
server.peer_timeout_min_msec = 60000
|
|
server.peer_timeout_max_msec = 60000
|
|
var client: NetClient = _client("Mara")
|
|
assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED))
|
|
client.leave()
|
|
assert_eq(client.state, NetClient.CLOSED)
|
|
assert_eq(client.close_reason, NetProtocol.REASON_LEFT)
|
|
assert_true(_pump(func() -> bool: return not _events("left").is_empty(), 2000), "the server heard the goodbye, not a timeout")
|
|
assert_eq(_events("left"), [{"type": "left", "handle": 1, "name": "Mara", "reason": NetProtocol.REASON_LEFT}] as Array[Dictionary])
|
|
assert_eq(server.player_count(), 0)
|
|
|
|
|
|
func test_a_client_that_vanishes_times_out() -> void:
|
|
server.close()
|
|
server.peer_timeout_min_msec = 300
|
|
server.peer_timeout_max_msec = 600
|
|
assert_eq(server.listen(0, HOST), OK)
|
|
var client: NetClient = _client("Mara")
|
|
assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED))
|
|
# Pull the plug: no goodbye.
|
|
client._drop()
|
|
clients.clear()
|
|
assert_true(_pump(func() -> bool: return not _events("left").is_empty(), 8000), "the server noticed")
|
|
assert_eq(_events("left")[0]["reason"], NetProtocol.REASON_LOST)
|
|
assert_eq(server.player_count(), 0)
|
|
|
|
|
|
func test_a_silent_guest_is_dropped() -> void:
|
|
server.handshake_timeout_msec = 200
|
|
_raw()
|
|
var host: ENetConnection = raw_hosts[0]
|
|
assert_true(_pump(func() -> bool: return server.guest_count() == 1 or _raw_state[host]["disconnect_data"] >= 0))
|
|
assert_true(_pump(func() -> bool: return _raw_state[host]["disconnect_data"] >= 0), "the guest was disconnected")
|
|
assert_eq(_raw_state[host]["disconnect_data"], NetProtocol.REASON_HANDSHAKE_TIMEOUT)
|
|
assert_eq(NetProtocol.decode_reject(_raw_state[host]["packets"][0])["reason"], NetProtocol.REASON_HANDSHAKE_TIMEOUT)
|
|
assert_eq(server.guest_count(), 0)
|
|
assert_eq(server.player_count(), 0)
|
|
|
|
|
|
func test_malformed_handshakes_are_refused_and_the_server_carries_on() -> void:
|
|
var good: PackedByteArray = NetProtocol.encode_hello("Mara")
|
|
var huge: PackedByteArray = PackedByteArray()
|
|
huge.resize(60000)
|
|
huge.fill(0x41)
|
|
var wrong_magic: PackedByteArray = good.duplicate()
|
|
wrong_magic[1] = 0x00
|
|
var bad_name: PackedByteArray = good.slice(0, 7)
|
|
bad_name.append_array(PackedByteArray([2, 0xC3, 0x28]))
|
|
var packets: Array[PackedByteArray] = [
|
|
PackedByteArray([0]), PackedByteArray([NetProtocol.MSG_HELLO]), good.slice(0, 6), wrong_magic, huge, bad_name,
|
|
NetProtocol.encode_welcome(1, 1, 24, "Mara"), NetProtocol.encode_reject(NetProtocol.REASON_FULL),
|
|
]
|
|
for bytes: PackedByteArray in packets:
|
|
var peer: ENetPacketPeer = _raw()
|
|
peer.send(NetProtocol.CHANNEL_CONTROL, bytes, ENetPacketPeer.FLAG_RELIABLE)
|
|
# A good HELLO on the wrong channel is no handshake either.
|
|
var stray: ENetPacketPeer = _raw()
|
|
stray.send(NetProtocol.CHANNEL_STATE, good, ENetPacketPeer.FLAG_RELIABLE)
|
|
var expected: int = packets.size() + 1
|
|
assert_true(_pump(func() -> bool: return _events("refused").size() >= expected), "refused %d of %d" % [_events("refused").size(), expected])
|
|
for event: Dictionary in _events("refused"):
|
|
assert_eq(event["reason"], NetProtocol.REASON_BAD_HELLO)
|
|
assert_eq(server.bad_packets, expected)
|
|
assert_true(_pump(func() -> bool:
|
|
for host: ENetConnection in raw_hosts:
|
|
if _raw_state[host]["disconnect_data"] < 0:
|
|
return false
|
|
return true), "every bad peer was disconnected")
|
|
assert_eq(server.guest_count(), 0)
|
|
assert_eq(server.player_count(), 0)
|
|
# Still serving.
|
|
var client: NetClient = _client("Mara")
|
|
assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED))
|
|
|
|
|
|
func test_random_packets_from_guests_and_players_never_crash_the_server() -> void:
|
|
var rng: RandomNumberGenerator = RandomNumberGenerator.new()
|
|
rng.seed = 77
|
|
var member: NetClient = _client("Mara")
|
|
assert_true(_pump(func() -> bool: return member.state == NetClient.JOINED))
|
|
for _round: int in 12:
|
|
var peer: ENetPacketPeer = _raw()
|
|
for _packet: int in 6:
|
|
var bytes: PackedByteArray = PackedByteArray()
|
|
bytes.resize(rng.randi_range(0, 300))
|
|
for index: int in bytes.size():
|
|
bytes[index] = rng.randi_range(0, 255)
|
|
peer.send(rng.randi_range(0, 1), bytes, ENetPacketPeer.FLAG_RELIABLE)
|
|
# A player who keeps sending HELLOs and junk stays a player and changes nothing. The
|
|
# HELLOs are dropped; junk on the game channel goes to the owner, who can't read it.
|
|
for _packet: int in 20:
|
|
member._peer.send(NetProtocol.CHANNEL_CONTROL, NetProtocol.encode_hello("Someone Else"), ENetPacketPeer.FLAG_RELIABLE)
|
|
member._peer.send(NetProtocol.CHANNEL_STATE, PackedByteArray([1, 2, 3]), ENetPacketPeer.FLAG_RELIABLE)
|
|
assert_true(_pump(func() -> bool: return _events("refused").size() >= 12 and server.bad_packets >= 32 and handed >= 20), "refused %d, dropped %d, handed on %d" % [_events("refused").size(), server.bad_packets, handed])
|
|
assert_eq(handed, 20)
|
|
assert_eq(server.player_count(), 1)
|
|
assert_eq(server.name_of(1), "Mara")
|
|
assert_eq(_events("joined").size(), 1)
|
|
assert_eq(member.state, NetClient.JOINED)
|
|
|
|
|
|
func test_no_server_means_no_answer() -> void:
|
|
var port: int = server.port()
|
|
server.close()
|
|
var client: NetClient = NetClient.new()
|
|
client.connect_timeout_msec = 300
|
|
clients.append(client)
|
|
assert_eq(client.connect_to(HOST, port, "Mara"), OK)
|
|
assert_true(_pump(func() -> bool: return client.state == NetClient.CLOSED, 3000))
|
|
assert_eq(client.close_reason, NetProtocol.REASON_NO_ANSWER)
|
|
assert_true(client.status_text().contains("No answer"))
|
|
|
|
|
|
func test_a_server_shutting_down_tells_its_players() -> void:
|
|
var client: NetClient = _client("Mara")
|
|
assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED))
|
|
server.close()
|
|
assert_false(server.is_listening())
|
|
assert_eq(server.port(), 0)
|
|
assert_true(_pump(func() -> bool: return client.state == NetClient.CLOSED))
|
|
assert_eq(client.close_reason, NetProtocol.REASON_SHUTDOWN)
|
|
assert_eq(client.status_text(), "The server shut down.")
|
|
|
|
|
|
func test_a_kicked_player_is_told_and_removed() -> void:
|
|
var client: NetClient = _client("Mara")
|
|
assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED))
|
|
assert_true(server.kick(1))
|
|
assert_eq(server.events[-1], {"type": "left", "handle": 1, "name": "Mara", "reason": NetProtocol.REASON_KICKED})
|
|
assert_false(server.kick(1))
|
|
assert_eq(server.player_count(), 0)
|
|
assert_true(_pump(func() -> bool: return client.state == NetClient.CLOSED))
|
|
assert_eq(client.close_reason, NetProtocol.REASON_KICKED)
|
|
assert_false(client.send(NetProtocol.CHANNEL_STATE, PackedByteArray([1]), false))
|
|
|
|
|
|
func test_two_servers_cannot_share_a_port() -> void:
|
|
var other: NetServer = NetServer.new()
|
|
expect_error("Couldn't create an ENet host")
|
|
assert_ne(other.listen(server.port(), HOST), OK)
|
|
assert_false(other.is_listening())
|
|
assert_true(server.is_listening())
|