Files
tidewall/test/server/test_world_replication.gd
T
claudeandClaude Opus 5.5 aa797580a7 #72: The packet ship, the lifeline mortar and the gull-kite
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>
2026-11-15 12:49:21 -05:00

209 lines
10 KiB
GDScript

extends TestCase
## Issue N5 end to end: a ClientGame plays a whole scripted match against a real server
## on a real island, and its copy of the world has to agree with the server's all the
## way through. The match is seed 2 with two people and 22 bots. One person is the
## scripted player, who lands, loots, harvests and builds. The other is the network
## client, who leaps over land, puts up two walls ahead of the server's answer, and
## then a floor the server turns down.
const DT: float = 1.0 / Tuning.TICK_RATE_HZ
const CLIENT: int = 2
const BUILD: int = PlayerCommand.BUTTON_BUILD | PlayerCommand.BUTTON_FIRE
## Ticks between the client's attempts to build.
const ATTEMPT_EVERY: int = 20
const LIMIT_TICKS: int = 25 * 60 * Tuning.TICK_RATE_HZ
var loop: ServerLoop
var game: NetGame
var client: ClientGame
var leap_tick: int = 0
## Build attempts the client has made, and the tick of the last.
var attempts: int = 0
var last_attempt: int = -1000
var wanted_attempts: int = 0
func _input(tick: int) -> PlayerCommand:
var me: SimEntity = client.prediction.player
var centre: Vector3 = Vector3(Tuning.WORLD_SIZE_METRES * 0.5, 0.0, Tuning.WORLD_SIZE_METRES * 0.5)
var yaw: float = atan2(centre.x - me.position.x, centre.z - me.position.z)
if me.drop_state == Drop.ABOARD:
return PlayerCommand.from_input(tick, Vector2.ZERO, yaw, 0.0, PlayerCommand.BUTTON_JUMP if tick >= leap_tick else 0)
if me.drop_state != Drop.NONE:
return PlayerCommand.from_input(tick, Vector2(0.0, 1.0), yaw, 0.0)
if attempts < wanted_attempts and tick - last_attempt >= ATTEMPT_EVERY and me.on_ground and Building.is_allowed(me):
last_attempt = tick
attempts += 1
# Two walls on sides of the cell it stands in, then a floor beside it.
var kind: int = StructureSet.WALL if attempts <= 2 else StructureSet.FLOOR
return PlayerCommand.from_input(tick, Vector2.ZERO, mini(attempts, 2) * PI * 0.5, 0.0, BUILD, kind, Materials.DRIFTWOOD)
return PlayerCommand.from_input(tick, Vector2.ZERO, yaw, 0.0)
## One round: the client's packets go up, the server runs a tick, and everything it
## sends comes down, reliable messages first as they were sent.
func _round() -> void:
for bytes: PackedByteArray in client.outbox:
game.take_input(CLIENT, bytes)
client.outbox.clear()
loop.run_tick()
game.after_tick()
for event: Dictionary in loop.match_flow.events:
if event["type"] == "phase":
client.receive(NetProtocol.CHANNEL_CONTROL, game.match_notice())
if not game.world_changes.is_empty():
client.receive(NetProtocol.CHANNEL_CONTROL, game.world_changes)
if game.own_changes.has(CLIENT):
client.receive(NetProtocol.CHANNEL_CONTROL, game.own_changes[CLIENT])
if game.snapshot_due():
client.receive(NetProtocol.CHANNEL_STATE, game.snapshot_for(CLIENT))
client.advance(DT)
func _agrees(message: String) -> bool:
client.replica.sync(loop.sim.tick)
var same: bool = NetWorld.world_hash(client.world) == NetWorld.world_hash(loop.sim)
assert_true(same, "%s: the client's world differs at tick %d" % [message, loop.sim.tick])
return same
func test_a_clients_world_agrees_with_the_servers_through_a_scripted_match() -> void:
loop = ServerLoop.new(2, 2, 22)
loop.play_humans_by_script()
var flow: Match = loop.match_flow
var sim: Simulation = loop.sim
var mine: SimEntity = sim.entities.find(flow.entity_of[CLIENT])
# Seat 2 is the network client's, not a script's.
for index: int in range(loop.scripted.size() - 1, -1, -1):
if loop.scripted[index].player_id == mine.id:
loop.scripted.remove_at(index)
assert_eq(loop.scripted.size(), 1)
game = NetGame.new(loop, NetServer.new())
game.adopt(CLIENT)
# Fire the mortar a little way into the voyage.
leap_tick = mini(Tuning.TICK_RATE_HZ * 4, sim.drop.duration_ticks / 2)
client = ClientGame.new()
client.sample_input = _input
client.receive(NetProtocol.CHANNEL_CONTROL, game.match_notice())
client.receive(NetProtocol.CHANNEL_CONTROL, game.world_notice())
assert_eq(client.world.props.layout_hash(), sim.props.layout_hash(), "the same props on both ends")
_agrees("at the start")
assert_eq(client.world.loot.chest_positions, sim.loot.chest_positions, "the client rolled the same chests")
assert_true(client.world.loot.chest_positions.size() > 0)
assert_eq(client.world.tide.levels, sim.tide.levels)
var wall_cost: int = StructureSet.cost_of(StructureSet.WALL)
var landed: bool = false
var refused: bool = false
var differed: int = 0
var carried_checks: int = 0
var most_pending: int = 0
var most_pieces: int = 0
var scripted: SimEntity = sim.entities.find(loop.scripted[0].player_id)
while flow.phase != Match.RESULTS and loop.ticks < LIMIT_TICKS and differed == 0:
_round()
most_pending = maxi(most_pending, client.replica.pending_count())
most_pieces = maxi(most_pieces, sim.structures.count())
if scripted.drop_state == Drop.NONE and scripted.on_ground and not scripted.eliminated and loop.scripted[0].step != ScriptedPlayer.DONE:
# On this seed bots meet the scripted player soon after landing. Topping up its
# health and armor until its script is done keeps it alive to harvest and
# build, which this test needs to replicate; the fights aren't under test.
scripted.armor = Tuning.PLAYER_MAX_ARMOR
scripted.health = Tuning.PLAYER_MAX_HEALTH
if not landed and mine.drop_state == Drop.NONE and mine.on_ground and not mine.eliminated:
# On the ground: hand it driftwood for two walls and a floor, and let it
# try the walls.
landed = true
mine.materials[Materials.DRIFTWOOD] = wall_cost * 2 + StructureSet.cost_of(StructureSet.FLOOR)
wanted_attempts = 2
elif landed and not refused and client.replica.confirmed == 2 and wanted_attempts == 2:
wanted_attempts = 3
elif wanted_attempts == 3 and not refused and client.replica.pending_count() == 1:
# The floor is down on the client and its command is on the way. The
# server finds the driftwood gone before it runs that tick.
refused = true
mine.materials[Materials.DRIFTWOOD] = 0
if loop.ticks == 4 * 60 * Tuning.TICK_RATE_HZ + 10 and sim.props.destroyed.is_empty():
# Bots no longer shoot up the scenery much (H3), so break a prop near the
# scripted player for the props' replication to be tested.
var near: PackedInt32Array = sim.props.near(scripted.position, 200.0)
if not near.is_empty():
sim.damage_prop(near[0], 1 << 20)
if loop.ticks % 150 == 0:
if not _agrees("during the match"):
differed += 1
if client.playing() and client.replica.pending_count() == 0 and not client.replica.own.is_empty():
carried_checks += 1
assert_eq(client.replica.own["materials"], mine.materials, "materials at tick %d" % sim.tick)
assert_eq(client.replica.own["slot_items"], mine.slot_items)
assert_eq(client.replica.own["ammo"], mine.ammo)
assert_eq(flow.phase, Match.RESULTS, "the match ended, after %d ticks" % loop.ticks)
_agrees("after the match")
assert_true(landed, "the client's player reached the ground")
assert_eq(client.replica.confirmed, 2, "two walls placed ahead of the server and kept")
assert_true(refused)
assert_eq(client.replica.rolled_back, 1, "the floor taken back")
assert_eq(client.replica.pending_count(), 0)
assert_true(most_pending >= 1)
assert_true(carried_checks > 0, "what the client carries was compared %d times" % carried_checks)
assert_eq(client.replica.gaps, 0)
assert_eq(client.bad_packets, 0)
assert_eq(game.bad_inputs, 0)
# The match had something of everything to replicate.
var destroyed_props: int = sim.props.destroyed.size()
var opened: int = sim.loot.chest_opened.count(1)
assert_true(most_pieces >= 3, "%d pieces stood at once" % most_pieces)
assert_true(sim.structures.removed.size() + sim.structures.count() >= 4, "the scripted player built too")
assert_true(destroyed_props > 0, "%d props destroyed" % destroyed_props)
assert_eq(client.world.props.destroyed.size(), destroyed_props)
assert_true(opened > 0, "%d chests opened" % opened)
assert_eq(client.world.loot.chest_opened, sim.loot.chest_opened)
assert_eq(client.world.loot.crate_contents.size(), sim.loot.crate_contents.size())
print("N5 match: %d ticks, %d WORLD messages, %d bytes (%.0f B/s), %d pieces built, %d removed, %d props destroyed, %d chests opened, largest correction %.2f m" % [
sim.tick, game.world.messages, game.world.bytes_made, game.world.bytes_made / (sim.tick * DT),
sim.structures.next_id() - 1, sim.structures.removed.size(), destroyed_props, opened, client.prediction.max_correction,
])
func test_a_new_match_or_a_whole_state_starts_on_a_clean_world() -> void:
var worlds: Array[Simulation] = []
client = ClientGame.new()
client.make_world = func(match_seed: int) -> Simulation:
worlds.append(Simulation.new(match_seed, SimGround.flat()))
return worlds[worlds.size() - 1]
var piece: Array = [3, StructureSet.FLOOR, Materials.STONE, 0, Vector4i(5, 0, 5, StructureSet.SLOT_FLOOR), 1, 10, 0, 4]
var full: PackedByteArray = NetWorld.encode_world({"flags": NetWorld.FLAG_FULL, "seq": 4, "tick": 14, "pieces": [piece]})
# A WORLD before any MATCH has no world to go on.
client.receive(NetProtocol.CHANNEL_CONTROL, full)
assert_eq(client.bad_packets, 1)
client.receive(NetProtocol.CHANNEL_CONTROL, NetSnapshot.encode_match(Match.PLAY, 0, 11))
client.receive(NetProtocol.CHANNEL_CONTROL, full)
assert_eq(worlds.size(), 1)
assert_eq(client.world.structures.count(), 1)
assert_eq(client.replica.seq, 4)
assert_true(client.replica.dirty)
# Changes go on the same world.
client.receive(NetProtocol.CHANNEL_CONTROL, NetWorld.encode_world({"seq": 5, "tick": 20, "removed": PackedInt32Array([3])}))
assert_eq(worlds.size(), 1)
assert_eq(client.world.structures.count(), 0)
# The whole state again: a fresh world, not the old one patched.
client.receive(NetProtocol.CHANNEL_CONTROL, full)
assert_eq(worlds.size(), 2)
assert_eq(client.world, worlds[1])
assert_eq(client.world.structures.count(), 1)
# The next match, on the same seed as it happens: a fresh world again.
client.receive(NetProtocol.CHANNEL_CONTROL, NetSnapshot.encode_match(Match.LOBBY, 1, 11))
assert_eq(worlds.size(), 3)
assert_eq(client.world.structures.count(), 0)
assert_false(client.replica.dirty)
assert_eq(client.replica.seq, -1)
# A phase change within a match leaves the world alone.
client.receive(NetProtocol.CHANNEL_CONTROL, NetSnapshot.encode_match(Match.COUNTDOWN, 1, 11))
assert_eq(worlds.size(), 3)
# Rubbish is counted and changes nothing.
client.receive(NetProtocol.CHANNEL_CONTROL, PackedByteArray([NetWorld.MSG_WORLD, 0, 1]))
client.receive(NetProtocol.CHANNEL_CONTROL, PackedByteArray([NetWorld.MSG_OWN, 0, 1]))
assert_eq(client.bad_packets, 3)