Files
tidewall/test/server/test_world_replication.gd
T
claudeandClaude Opus 5.5 d5c8019d11 H9: Boathook swings damage players; unarmed bots brawl
- Harvest.swing traces the swing as a shot is traced (Weapons.trace, lag
  compensated). A player reached before terrain, a solid, a prop's grown
  box or a built piece takes the boathook's damage through
  Weapons.damage_player, so armor, the kill feed and stats count it. A level
  swing meets the head and takes the headshot multiplier, as a shot does.
- Unarmed bots go for an opponent in view within BOT_BRAWL_METRES (6 m) and
  swing within BOT_SWING_METRES; inside a hut they swing back without
  walking in.
- Tests: harvest +5 (hit, armor first, out of reach, wall between, player in
  front of a tree), bot brain +2 (closes in and lands hits; leaves a distant
  opponent alone).
- test_world_replication: an unarmed bot now meets the scripted player early
  on seed 2, so the test gives it full armor on landing so it lives to build;
  all assertions unchanged.

Closes #73

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 21:10:48 -05:00

208 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)
leap_tick = sim.drop.duration_ticks / 2
for tick: int in range(30, sim.drop.duration_ticks):
var under: Vector3 = sim.drop.barge_position(tick)
if sim.ground.terrain_height(under.x, under.z) > Tuning.ISLAND_BEACH_TOP + 2.0:
leap_tick = tick
break
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)
var shielded: bool = false
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 not shielded and scripted.drop_state == Drop.NONE and scripted.on_ground:
# Since H9 unarmed bots brawl, and on this seed one meets the scripted player
# early. Full armor keeps it alive to harvest and build, which this test needs
# to replicate; the fight itself isn't what's under test.
shielded = true
scripted.armor = Tuning.PLAYER_MAX_ARMOR
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 % 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)