claude
f70de1b825
ci / verify (push) Successful in 45s
The real cause of the ship/bullet separation, which the previous commit only half-addressed. The server dropped inputs past a lead of 12 while the client only re-synced past 16, so a client whose lead drifted into 13-16 had every input silently rejected while believing its timing was fine. The server coasted on held_input and then stopped; the client kept predicting. The two separated permanently and the reconciler fought it every snapshot -- "shoved around". It needed two independent clocks to drift, hence "only after some time", and nothing in the loop could notice, hence "then persists". The listen-server diagnostic could never reproduce it: one process, one physics tick, lead constant by construction. Two defences: INPUT_MAX_LEAD (40) is now far wider than the client's correction band (3..20), asserted by tests/unit/test_input_lead.gd so narrowing it fails a test; and an ack-stall detector re-syncs when last_input_tick stops advancing, which catches the whole class regardless of cause -- lead alone cannot, because a wrong lead looks normal from the client. diag_prediction.gd now injects a +14 tick drift and exits non-zero unless the gap recovers. Also: - No invulnerability frames. Every bullet that touches a player lands; i-frames made dense patterns safer than sparse ones, which inverts the genre. Measured: a stationary player survives ~13.6s of the Warden's opening phase, ~17.5s drifting. spawn_grace remains the only invulnerable state. - Death is exited with a HUD button, disabled for the first 3s. The lockout is enforced in SimWorld, not just by graying the button -- a client that ignores its own UI still waits. The interact key no longer respawns. - Joining a server that is not there no longer drops the player into an empty lobby they cannot act in. Net.join() only creates an ENet object; the game scene now waits for the server to actually place us in an instance, with an 8s timeout, and headless runs exit non-zero instead of idling. Protocol 2 -> 3. 98 tests; check.sh, test.sh and smoke.sh all pass.
115 lines
4.3 KiB
GDScript
115 lines
4.3 KiB
GDScript
extends GutTest
|
|
## The escape button is the player's safety valve, and it is also the one input
|
|
## with a real consequence attached, so its timing is server-owned end to end.
|
|
|
|
var world: SimWorld
|
|
const PEER := 3
|
|
|
|
|
|
func before_each() -> void:
|
|
world = SimWorld.new(1)
|
|
world.add_player(PEER, "tester")
|
|
|
|
|
|
func _hold_escape(ticks: int) -> void:
|
|
for _i in ticks:
|
|
var frames: Array[InputFrame] = [
|
|
InputFrame.make(world.tick + 1, Vector2.ZERO, 0.0, InputFrame.BTN_ESCAPE)]
|
|
world.queue_input(PEER, frames)
|
|
world.step()
|
|
|
|
|
|
func _events_of(type: int) -> Array:
|
|
return world.events.filter(func(e: Dictionary) -> bool: return int(e["t"]) == type)
|
|
|
|
|
|
func test_escape_takes_the_full_channel_time() -> void:
|
|
_hold_escape(SimConfig.ESCAPE_CHANNEL_TICKS - 1)
|
|
assert_eq(_events_of(SimEvent.Type.ESCAPE_COMPLETED).size(), 0,
|
|
"the escape must not complete early")
|
|
_hold_escape(1)
|
|
assert_eq(_events_of(SimEvent.Type.ESCAPE_COMPLETED).size(), 1)
|
|
|
|
|
|
func test_releasing_the_button_cancels_the_channel() -> void:
|
|
# Deliberately short of ESCAPE_CHANNEL_TICKS: hold the full duration and the
|
|
# channel completes instead, which is a different test.
|
|
_hold_escape(SimConfig.ESCAPE_CHANNEL_TICKS / 2)
|
|
assert_gt(world.players[PEER].escape_ticks, 0)
|
|
var frames: Array[InputFrame] = [InputFrame.make(world.tick + 1, Vector2.ZERO, 0.0, 0)]
|
|
world.queue_input(PEER, frames)
|
|
world.step()
|
|
assert_eq(world.players[PEER].escape_ticks, 0)
|
|
assert_eq(_events_of(SimEvent.Type.ESCAPE_CANCELLED).size(), 1)
|
|
|
|
|
|
## The inverse of what this asserted originally. Interrupting on damage makes
|
|
## quitting the process strictly better than using the button, which turns the
|
|
## escape hatch into the exploit -- see SimConfig.ESCAPE_CHANNEL_TICKS.
|
|
func test_taking_damage_does_not_cancel_the_channel() -> void:
|
|
_hold_escape(20)
|
|
var before: int = world.players[PEER].escape_ticks
|
|
world.pool.spawn(world.players[PEER].pos, Vector2.ZERO, 6.0, 60, 10,
|
|
SimConfig.TEAM_ENEMY, SimConfig.KIND_ORB)
|
|
_hold_escape(1)
|
|
assert_lt(world.players[PEER].hp, SimConfig.PLAYER_MAX_HP, "setup: should have been hit")
|
|
assert_eq(world.players[PEER].escape_ticks, before + 1,
|
|
"the channel must keep running while under fire")
|
|
assert_eq(_events_of(SimEvent.Type.ESCAPE_CANCELLED).size(), 0)
|
|
|
|
|
|
## Dying is still an interruption -- it is the one thing the escape cannot beat,
|
|
## which is what keeps the one-second channel a real risk.
|
|
func test_dying_ends_the_channel() -> void:
|
|
_hold_escape(20)
|
|
var p: SimPlayer = world.players[PEER]
|
|
p.hp = 1
|
|
world.pool.spawn(p.pos, Vector2.ZERO, 6.0, 60, 999,
|
|
SimConfig.TEAM_ENEMY, SimConfig.KIND_ORB)
|
|
world.step()
|
|
assert_false(p.alive)
|
|
assert_eq(p.escape_ticks, 0)
|
|
assert_eq(_events_of(SimEvent.Type.ESCAPE_COMPLETED).size(), 0)
|
|
|
|
|
|
## A dropped connection channels out on exactly the same timer, so pulling the
|
|
## plug is never cheaper than pressing the button.
|
|
func test_a_linkdead_player_channels_out_without_input() -> void:
|
|
var p: SimPlayer = world.players[PEER]
|
|
p.linkdead = true
|
|
for _i in SimConfig.ESCAPE_CHANNEL_TICKS - 1:
|
|
world.step()
|
|
assert_eq(_events_of(SimEvent.Type.ESCAPE_COMPLETED).size(), 0,
|
|
"a disconnect must not be an instant exit")
|
|
world.step()
|
|
assert_eq(_events_of(SimEvent.Type.ESCAPE_COMPLETED).size(), 1)
|
|
|
|
|
|
func test_a_linkdead_player_is_still_killable_while_channelling() -> void:
|
|
var p: SimPlayer = world.players[PEER]
|
|
p.linkdead = true
|
|
p.hp = 1
|
|
world.step()
|
|
world.pool.spawn(p.pos, Vector2.ZERO, 6.0, 60, 999,
|
|
SimConfig.TEAM_ENEMY, SimConfig.KIND_ORB)
|
|
world.step()
|
|
assert_false(p.alive, "the whole point: disconnecting does not grant immunity")
|
|
|
|
|
|
func test_a_cancelled_channel_restarts_from_zero() -> void:
|
|
_hold_escape(SimConfig.ESCAPE_CHANNEL_TICKS / 2)
|
|
var frames: Array[InputFrame] = [InputFrame.make(world.tick + 1, Vector2.ZERO, 0.0, 0)]
|
|
world.queue_input(PEER, frames)
|
|
world.step()
|
|
_hold_escape(SimConfig.ESCAPE_CHANNEL_TICKS - 1)
|
|
assert_eq(_events_of(SimEvent.Type.ESCAPE_COMPLETED).size(), 0,
|
|
"progress must not carry over from an interrupted channel")
|
|
|
|
|
|
func test_escape_completion_never_reaches_the_client_directly() -> void:
|
|
_hold_escape(SimConfig.ESCAPE_CHANNEL_TICKS)
|
|
var packet := NetCodec.decode_events(NetCodec.encode_events(world.tick, world.events))
|
|
for ev: Dictionary in packet["events"]:
|
|
assert_ne(int(ev["t"]), SimEvent.Type.ESCAPE_COMPLETED,
|
|
"the transfer is the server's decision; clients only see the outcome")
|