Eric chose option B on #72. The drop is now the GDD's launch: - A packet ship sails a seeded straight line past the island, offshore, as close in as it can while keeping 45 m of open water from any land (eight-way probes; up to 32 headings, then the four world sides). - Jump fires the lifeline mortar along the look heading. How high the player aims sets the charge (-10 to 45 degrees: 16 to 110 m/s over the ground; every shot climbs at 75 m/s). The climb can't be steered and the kite can't open until the arc tops out. Riders still aboard at the end are fired towards the middle of the island. - Drop.reach() mirrors the fall for both ways down (kite at the top, or a fall with the kite opening by itself); bots, the soak and autoplay clients and the tutorial pilot aim with Drop.aim_charge(). - Bots fire at their landing spot once abeam of it, when in easy reach at their own staggered moment, or just before the route ends, and open the kite early only when the spot is beyond the rest of a fall. - Art: VesselModels.ship() (two-masted packet, tanned square sails, a salt-white boot-top, a bowsprit and the mortar on its bed, mirrored to face the island), the figure's gull-kite (figure.py), and a lifeline cord from the muzzle to each player still climbing. - Renamed barge to ship and wing-sail to gull-kite throughout code, tests, captures, docs and the tutorial text. make match now defaults to seed 2, where the scripted player still harvests and builds. Closes #72 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
318 lines
13 KiB
GDScript
318 lines
13 KiB
GDScript
extends TestCase
|
|
|
|
## Issue N2: SnapshotSender and SnapshotReceiver together, over a link that loses,
|
|
## delays and repeats packets. Interest management and the size budget.
|
|
|
|
const HANDLE: int = 1
|
|
const STEP: int = Tuning.NET_SNAPSHOT_INTERVAL_TICKS
|
|
|
|
var sim: Simulation
|
|
var viewer: SimEntity
|
|
var sender: SnapshotSender
|
|
var receiver: SnapshotReceiver
|
|
var tick: int = 0
|
|
## Every packet built for the client, delivered or not.
|
|
var packets: Array[PackedByteArray] = []
|
|
|
|
|
|
func before_each() -> void:
|
|
sim = Simulation.new(5, SimGround.flat())
|
|
viewer = sim.entities.find(sim.add_player())
|
|
viewer.position = Vector3(500.0, 0.0, 500.0)
|
|
sender = SnapshotSender.new()
|
|
sender.add_client(HANDLE)
|
|
receiver = SnapshotReceiver.new()
|
|
tick = 0
|
|
packets.clear()
|
|
|
|
|
|
func _other(at: Vector3) -> SimEntity:
|
|
var player: SimEntity = sim.entities.find(sim.add_player())
|
|
player.position = at
|
|
return player
|
|
|
|
|
|
## Builds the next snapshot. Delivers it and returns the acknowledgement unless told not to.
|
|
func _send(deliver: bool = true, acknowledge: bool = true) -> PackedByteArray:
|
|
tick += STEP
|
|
var bytes: PackedByteArray = sender.build(HANDLE, sim, viewer.id, tick, Match.PLAY)
|
|
packets.append(bytes)
|
|
assert_true(bytes.size() <= Tuning.NET_SNAPSHOT_MAX_BYTES, "snapshot of %d bytes" % bytes.size())
|
|
if deliver:
|
|
receiver.apply(bytes)
|
|
if acknowledge:
|
|
sender.acknowledge(HANDLE, receiver.ack_tick())
|
|
return bytes
|
|
|
|
|
|
## Fails unless the client's picture is exactly what it may see, as it is now.
|
|
func _assert_in_step(context: String) -> void:
|
|
var visible: Array[int] = SnapshotSender.interest(sim, viewer)
|
|
assert_eq(receiver.entities.size(), visible.size(), "%s: entity count" % context)
|
|
for entity_id: int in visible:
|
|
if not receiver.entities.has(entity_id):
|
|
fail("%s: entity %d is missing" % [context, entity_id])
|
|
continue
|
|
assert_eq(receiver.entities[entity_id], NetSnapshot.record_of(sim.entities.find(entity_id)), "%s: entity %d" % [context, entity_id])
|
|
|
|
|
|
func test_first_snapshot_is_full_and_later_ones_carry_only_changes() -> void:
|
|
var other: SimEntity = _other(Vector3(520.0, 0.0, 500.0))
|
|
var first: PackedByteArray = _send()
|
|
assert_eq(NetSnapshot.decode_snapshot(first)["baseline"], 0)
|
|
assert_eq(receiver.own_id, viewer.id)
|
|
_assert_in_step("first")
|
|
var quiet: Dictionary = NetSnapshot.decode_snapshot(_send())
|
|
assert_eq(quiet["baseline"], tick - STEP)
|
|
assert_eq((quiet["records"] as Array).size(), 0, "nothing moved")
|
|
other.position.x += 1.0
|
|
var moved: Dictionary = NetSnapshot.decode_snapshot(_send())
|
|
assert_eq((moved["records"] as Array).size(), 1)
|
|
assert_eq(moved["records"][0][2], 0b1, "only the position group")
|
|
_assert_in_step("moved")
|
|
assert_eq(sender.stats(HANDLE)["full"], 1)
|
|
|
|
|
|
func test_header_carries_the_tide_the_clock_and_the_command_echo() -> void:
|
|
sim.tide = Tide.new(0)
|
|
sim.sea_level = 3.25
|
|
sim.tick = 77
|
|
sender.note_command(HANDLE, 75)
|
|
sender.note_command(HANDLE, 60)
|
|
_send()
|
|
assert_near(receiver.sea_level, 3.25, 0.001)
|
|
assert_eq(receiver.sim_tick, 77)
|
|
assert_eq(receiver.command_tick, 75)
|
|
assert_eq(receiver.match_phase, Match.PLAY)
|
|
|
|
|
|
func test_the_client_recovers_from_lost_snapshots_and_lost_acknowledgements() -> void:
|
|
var others: Array[SimEntity] = []
|
|
for index: int in 12:
|
|
others.append(_other(Vector3(480.0 + index * 4.0, 0.0, 510.0)))
|
|
var rng: RandomNumberGenerator = RandomNumberGenerator.new()
|
|
rng.seed = 2026
|
|
var delivered: int = 0
|
|
for round: int in 400:
|
|
for other: SimEntity in others:
|
|
if rng.randf() < 0.6:
|
|
other.position += Vector3(rng.randf_range(-1.0, 1.0), 0.0, rng.randf_range(-1.0, 1.0))
|
|
other.yaw = rng.randi_range(0, 65535)
|
|
if rng.randf() < 0.05:
|
|
other.health = rng.randi_range(1, 100)
|
|
if round == 150:
|
|
sim.remove_player(others.pop_back().id)
|
|
var arrives: bool = rng.randf() >= 0.4
|
|
_send(arrives, rng.randf() >= 0.4)
|
|
if arrives:
|
|
delivered += 1
|
|
_assert_in_step("round %d" % round)
|
|
assert_true(delivered > 150 and delivered < 300, "the link lost a real share: %d of 400 arrived" % delivered)
|
|
assert_eq(receiver.missing_baseline, 0, "a delta never builds on something the client didn't confirm")
|
|
assert_eq(receiver.malformed, 0)
|
|
assert_eq(sender.stats(HANDLE)["full"], 1, "loss alone never needs a second full snapshot")
|
|
|
|
|
|
func test_duplicates_and_stale_snapshots_are_ignored() -> void:
|
|
var other: SimEntity = _other(Vector3(520.0, 0.0, 500.0))
|
|
var old: PackedByteArray = _send()
|
|
other.position.x += 5.0
|
|
var newer: PackedByteArray = _send()
|
|
assert_false(receiver.apply(old), "an older snapshot arriving late")
|
|
assert_false(receiver.apply(newer), "the same snapshot twice")
|
|
assert_eq(receiver.ignored_old, 2)
|
|
_assert_in_step("after repeats")
|
|
|
|
|
|
func test_a_long_silence_falls_back_to_a_full_snapshot() -> void:
|
|
var other: SimEntity = _other(Vector3(520.0, 0.0, 500.0))
|
|
_send()
|
|
# Longer than the server remembers: everything it could build on is forgotten.
|
|
for _round: int in Tuning.NET_SNAPSHOT_HISTORY + 5:
|
|
other.position.x += 0.1
|
|
_send(false, false)
|
|
var bytes: PackedByteArray = _send()
|
|
assert_eq(NetSnapshot.decode_snapshot(bytes)["baseline"], 0)
|
|
_assert_in_step("after the silence")
|
|
assert_true(sender.stats(HANDLE)["full"] >= 2)
|
|
|
|
|
|
func test_a_client_that_lost_its_baseline_asks_again_and_recovers() -> void:
|
|
_other(Vector3(520.0, 0.0, 500.0))
|
|
_send()
|
|
_send()
|
|
# A client that restarted its picture: it holds nothing the server builds on.
|
|
receiver = SnapshotReceiver.new()
|
|
_send()
|
|
assert_eq(receiver.missing_baseline, 1)
|
|
assert_eq(receiver.ack_tick(), 0)
|
|
assert_eq(receiver.entities.size(), 0)
|
|
_send()
|
|
_assert_in_step("after asking again")
|
|
|
|
|
|
func test_no_data_about_entities_outside_the_interest_area() -> void:
|
|
var range: float = Tuning.NET_INTEREST_PLAYERS_METRES
|
|
var near: SimEntity = _other(viewer.position + Vector3(range - 5.0, 0.0, 0.0))
|
|
var far: SimEntity = _other(viewer.position + Vector3(range + 5.0, 0.0, 0.0))
|
|
var far_item: int = Inventory.spawn_pickup(sim, viewer.position + Vector3(0.0, 0.0, Tuning.NET_INTEREST_PICKUPS_METRES + 3.0), 1, 1)
|
|
var near_item: int = Inventory.spawn_pickup(sim, viewer.position + Vector3(0.0, 0.0, Tuning.NET_INTEREST_PICKUPS_METRES - 3.0), 1, 1)
|
|
for _round: int in 10:
|
|
far.position.z += 1.0
|
|
far.health -= 1
|
|
_send()
|
|
assert_true(receiver.entities.has(near.id) and receiver.entities.has(near_item))
|
|
for bytes: PackedByteArray in packets:
|
|
var snapshot: Dictionary = NetSnapshot.decode_snapshot(bytes)
|
|
for entry: Array in snapshot["records"]:
|
|
assert_true(entry[0] != far.id and entry[0] != far_item, "a record for an entity out of range")
|
|
assert_false((snapshot["removed"] as PackedInt32Array).has(far.id), "even its ID stays unsaid")
|
|
# It walks into range: now the client hears of it, in full.
|
|
far.position = viewer.position + Vector3(range - 1.0, 0.0, 0.0)
|
|
_send()
|
|
assert_true(receiver.entities.has(far.id))
|
|
assert_eq(Array(receiver.added), [far.id])
|
|
# And out again: it is removed, and nothing more is said about it.
|
|
far.position = viewer.position + Vector3(range + 1.0, 0.0, 0.0)
|
|
_send()
|
|
assert_false(receiver.entities.has(far.id))
|
|
assert_eq(Array(receiver.removed), [far.id])
|
|
var before: int = packets.size()
|
|
for _round: int in 5:
|
|
far.position.z -= 1.0
|
|
_send()
|
|
for index: int in range(before, packets.size()):
|
|
assert_eq((NetSnapshot.decode_snapshot(packets[index])["records"] as Array).size(), 0)
|
|
_assert_in_step("at the end")
|
|
|
|
|
|
func test_height_does_not_hide_a_player_overhead() -> void:
|
|
var above: SimEntity = _other(viewer.position + Vector3(10.0, 150.0, 0.0))
|
|
_send()
|
|
assert_true(receiver.entities.has(above.id))
|
|
|
|
|
|
func test_a_crowd_is_spread_over_several_snapshots_nearest_first() -> void:
|
|
var ids: Array[int] = []
|
|
for index: int in 600:
|
|
var angle: float = index * 0.37
|
|
var reach: float = 2.0 + float(index) / 600.0 * (Tuning.NET_INTEREST_PICKUPS_METRES - 4.0)
|
|
ids.append(Inventory.spawn_pickup(sim, viewer.position + Vector3(cos(angle) * reach, 0.0, sin(angle) * reach), 1, 1))
|
|
var first: PackedByteArray = _send()
|
|
assert_true(first.size() > Tuning.NET_SNAPSHOT_MAX_BYTES - 16, "the first snapshot is full to the brim")
|
|
assert_true(receiver.entities.has(viewer.id), "the client's own player always travels")
|
|
var got: int = receiver.entities.size() - 1
|
|
assert_true(got > 50 and got < 600, "%d of 600 fitted" % got)
|
|
var furthest_got: float = 0.0
|
|
var nearest_missing: float = 1.0e9
|
|
for entity_id: int in ids:
|
|
var distance: float = sim.entities.find(entity_id).position.distance_to(viewer.position)
|
|
if receiver.entities.has(entity_id):
|
|
furthest_got = maxf(furthest_got, distance)
|
|
else:
|
|
nearest_missing = minf(nearest_missing, distance)
|
|
assert_true(furthest_got <= nearest_missing + 0.1, "nearest first: got out to %.1f m, missing from %.1f m" % [furthest_got, nearest_missing])
|
|
for _round: int in 12:
|
|
_send()
|
|
_assert_in_step("after a dozen snapshots")
|
|
assert_true(sender.stats(HANDLE)["deferred"] > 0)
|
|
|
|
|
|
func test_a_distant_entity_is_not_starved_by_a_busy_foreground() -> void:
|
|
# More near entities changing every snapshot than one snapshot can hold.
|
|
var busy: Array[SimEntity] = []
|
|
for index: int in 200:
|
|
busy.append(_other(viewer.position + Vector3(5.0 + index * 0.5, 0.0, 3.0)))
|
|
var distant: SimEntity = _other(viewer.position + Vector3(0.0, 0.0, Tuning.NET_INTEREST_PLAYERS_METRES - 10.0))
|
|
for _round: int in 30:
|
|
_send()
|
|
var seen: int = 0
|
|
for round: int in 60:
|
|
for other: SimEntity in busy:
|
|
other.position.z += 0.25
|
|
other.yaw = (other.yaw + 500) % 65536
|
|
distant.position.x += 0.5
|
|
var before: PackedInt32Array = receiver.entities.get(distant.id, PackedInt32Array())
|
|
_send()
|
|
if receiver.entities.get(distant.id, PackedInt32Array()) != before:
|
|
seen += 1
|
|
assert_true(sender.stats(HANDLE)["deferred"] > 0, "the snapshots really were over full")
|
|
assert_true(seen >= 3, "the distant player was updated %d times in 60 snapshots" % seen)
|
|
|
|
|
|
func test_a_new_match_starts_from_nothing() -> void:
|
|
_other(Vector3(520.0, 0.0, 500.0))
|
|
_send()
|
|
_send()
|
|
# A new simulation reuses entity IDs for different things.
|
|
sender.reset()
|
|
sim = Simulation.new(6, SimGround.flat())
|
|
viewer = sim.entities.find(sim.add_player())
|
|
viewer.position = Vector3(100.0, 0.0, 100.0)
|
|
Inventory.spawn_pickup(sim, Vector3(101.0, 0.0, 100.0), 1, 1)
|
|
var bytes: PackedByteArray = _send()
|
|
assert_eq(NetSnapshot.decode_snapshot(bytes)["baseline"], 0)
|
|
_assert_in_step("new match")
|
|
assert_eq(receiver.malformed, 0)
|
|
|
|
|
|
func test_no_viewer_means_an_empty_snapshot() -> void:
|
|
_other(Vector3(520.0, 0.0, 500.0))
|
|
tick += STEP
|
|
var bytes: PackedByteArray = sender.build(HANDLE, sim, 0, tick, Match.LOBBY)
|
|
assert_true(receiver.apply(bytes))
|
|
assert_eq(receiver.entities.size(), 0)
|
|
assert_eq(receiver.own_id, 0)
|
|
assert_eq(receiver.match_phase, Match.LOBBY)
|
|
|
|
|
|
func test_the_own_block_goes_only_to_a_living_player_watching_themself() -> void:
|
|
var other: SimEntity = _other(Vector3(520.0, 0.0, 500.0))
|
|
viewer.velocity = Vector3(1.5, 0.0, -2.25)
|
|
sim.sea_level = 1.5
|
|
tick += STEP
|
|
var mine: Dictionary = NetSnapshot.decode_snapshot(sender.build(HANDLE, sim, viewer.id, tick, Match.PLAY, viewer.id))
|
|
assert_eq(mine["self"]["position"], viewer.position)
|
|
assert_eq(mine["self"]["velocity"], viewer.velocity)
|
|
assert_eq(mine["self"]["water"], 1.5)
|
|
assert_eq(mine["self"]["water_mask"], NetSnapshot.WATER_EVERYWHERE, "no flood on a test ground: the sea is everywhere")
|
|
tick += STEP
|
|
var watching: Dictionary = NetSnapshot.decode_snapshot(sender.build(HANDLE, sim, other.id, tick, Match.PLAY, viewer.id))
|
|
assert_true((watching["self"] as Dictionary).is_empty(), "spectating someone else")
|
|
viewer.eliminated = true
|
|
tick += STEP
|
|
var out: Dictionary = NetSnapshot.decode_snapshot(sender.build(HANDLE, sim, viewer.id, tick, Match.PLAY, viewer.id))
|
|
assert_true((out["self"] as Dictionary).is_empty(), "eliminated")
|
|
tick += STEP
|
|
var lobby: Dictionary = NetSnapshot.decode_snapshot(sender.build(HANDLE, sim, 0, tick, Match.LOBBY, 0))
|
|
assert_true((lobby["self"] as Dictionary).is_empty(), "no player")
|
|
|
|
|
|
func test_the_own_block_says_which_cells_around_the_player_are_flooded() -> void:
|
|
# A real island: the sea reaches the shore cells and not the land beside them.
|
|
var island: Simulation = Simulation.new(11)
|
|
var flood: Flood = island.flood
|
|
var player: SimEntity = island.entities.find(island.add_player())
|
|
var found: bool = false
|
|
for cz: int in range(1, flood.side - 1):
|
|
for cx: int in range(1, flood.side - 1):
|
|
var here: bool = flood.flooded[cz * flood.side + cx] != 0
|
|
var east: bool = flood.flooded[cz * flood.side + cx + 1] != 0
|
|
if here and not east:
|
|
player.position = Vector3((cx + 0.5) * flood.cell, 0.0, (cz + 0.5) * flood.cell)
|
|
found = true
|
|
break
|
|
if found:
|
|
break
|
|
assert_true(found, "a shore cell")
|
|
var own: Dictionary = SnapshotSender.own_block(island, player)
|
|
assert_eq(own["water"], flood.sea_level)
|
|
var mask: int = own["water_mask"]
|
|
assert_true(mask & (1 << 4) != 0, "the player's own cell is flooded")
|
|
assert_true(mask & (1 << 5) == 0, "the cell to the east is dry")
|
|
for dz: int in range(-1, 2):
|
|
for dx: int in range(-1, 2):
|
|
var at: Vector3 = player.position + Vector3(dx * flood.cell, 0.0, dz * flood.cell)
|
|
var wet: bool = island.water_level_at(at) > Flood.NO_WATER
|
|
assert_eq(mask & (1 << ((dz + 1) * 3 + dx + 1)) != 0, wet, "cell %d, %d" % [dx, dz])
|