Files
tidewall/test/server/test_server_loop.gd
T
claudeandClaude Opus 5.5 c6f3c19004 M1: Match state machine
Match (src/sim/match.gd) runs a server's matches back to back: lobby,
countdown, drop, play and results, then a fresh island and the lobby again.
It is stepped once per server tick and has no scene-tree or clock dependency.

- MatchRules holds max and min players, team size, the lobby, countdown and
  results timers (defaults in Tuning.MATCH_*) and whether bots fill empty
  places.
- Participants are server-chosen handles. Joining during a match waits for
  the next; leaving during the drop or play places the leaver as eliminated.
- Placements, winners (last team standing) and events for phase changes,
  joins, leaves, places, match start and end.
- Match 0 uses the server's seed; later matches derive their seed from it and
  their index. The next match's Simulation is built when the lobby opens.
- ServerLoop now drives a Match (immediate rules by default, so the smoke
  match is unchanged: same state hash), rebuilds bots each match, and counts
  server ticks across matches. The headless server logs match events.

Tests: test_match (13) covers every transition, leaving in each phase, an
empty lobby, an empty match, teams, late joiners, and ten consecutive matches
that each start identical to a freshly built simulation. A ServerLoop test
checks the server goes back to the lobby and starts the next match.

Closes #24

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 20:24:00 -05:00

92 lines
3.5 KiB
GDScript

extends TestCase
func _run(match_seed: int, players: int, bots: int, ticks: int) -> ServerLoop:
var loop: ServerLoop = ServerLoop.new(match_seed, players, bots)
for _index: int in ticks:
loop.run_tick()
return loop
func test_creates_players_then_bots() -> void:
var loop: ServerLoop = ServerLoop.new(1, 2, 3)
var players: int = 0
for entity: SimEntity in loop.sim.entities.entities():
if entity.archetype == SimEntity.ARCHETYPE_PLAYER:
players += 1
assert_eq(players, 5)
assert_true(loop.sim.pickups.size() > 0, "the match's floor loot was placed")
assert_eq(loop.player_ids, [1, 2, 3, 4, 5] as Array[int])
assert_eq(loop.bots.size(), 3)
assert_eq(loop.bots[0].player_id, 3)
func test_records_one_timing_sample_per_tick() -> void:
var loop: ServerLoop = _run(7, 0, 4, 120)
assert_eq(loop.sim.tick, 120)
var stats: Dictionary = loop.timing_stats()
assert_eq(stats["ticks"], 120)
assert_true(stats["min_us"] <= stats["p50_us"])
assert_true(stats["p50_us"] <= stats["p95_us"])
assert_true(stats["p95_us"] <= stats["p99_us"])
assert_true(stats["p99_us"] <= stats["max_us"])
assert_eq(stats["budget_us"], ServerLoop.TICK_BUDGET_USEC)
func test_empty_stats() -> void:
assert_eq(ServerLoop.new(1, 0, 0).timing_stats(), {"ticks": 0})
func test_percentile_uses_nearest_rank() -> void:
var values: PackedInt64Array = PackedInt64Array(range(1, 101))
assert_eq(ServerLoop._percentile(values, 0.5), 50)
assert_eq(ServerLoop._percentile(values, 0.95), 95)
assert_eq(ServerLoop._percentile(values, 1.0), 100)
assert_eq(ServerLoop._percentile(PackedInt64Array([9]), 0.99), 9)
func test_bots_leap_and_humans_without_commands_stay_aboard() -> void:
# Every match starts on the drop carrier. A human who sends nothing rides it; the bot
# leaps at its own fixed moment and falls away.
var loop: ServerLoop = ServerLoop.new(99, 1, 1)
var human: SimEntity = loop.sim.entities.find(1)
var bot: SimEntity = loop.sim.entities.find(2)
assert_eq(human.drop_state, Drop.ABOARD)
assert_eq(bot.drop_state, Drop.ABOARD)
for _index: int in Tuning.TICK_RATE_HZ * 24:
loop.run_tick()
assert_eq(human.drop_state, Drop.ABOARD)
assert_true(human.position.distance_to(loop.sim.drop.barge_position(loop.sim.tick)) < 0.001)
assert_ne(bot.drop_state, Drop.ABOARD, "the bot should have leapt")
assert_true(bot.position.y < Tuning.BARGE_ALTITUDE - 20.0, "the bot should be falling, at %s" % bot.position)
func test_same_seed_gives_the_same_match() -> void:
var first: String = _run(2026, 2, 22, 300).sim.state_hash()
var second: String = _run(2026, 2, 22, 300).sim.state_hash()
assert_eq(first, second)
assert_ne(first, _run(2027, 2, 22, 300).sim.state_hash())
func test_server_returns_to_the_lobby_and_starts_the_next_match() -> void:
var rules: MatchRules = MatchRules.immediate()
rules.max_players = 3
rules.min_players = 0
rules.results_ticks = 3
var loop: ServerLoop = ServerLoop.new(5, 0, 3, rules)
assert_eq(loop.match_flow.phase, Match.DROP)
assert_eq(loop.bots.size(), 3)
var first_seed: int = loop.match_flow.current_seed()
for bot: WanderBot in loop.bots.slice(1):
loop.sim.entities.find(bot.player_id).health = 0
loop.run_tick()
assert_eq(loop.match_flow.phase, Match.RESULTS)
for _index: int in 4:
loop.run_tick()
assert_eq(loop.match_flow.phase, Match.DROP, "lobby and countdown pass at once")
assert_eq(loop.match_flow.matches_started, 2)
assert_ne(loop.match_flow.current_seed(), first_seed)
assert_eq(loop.bots.size(), 3, "bots are rebuilt for the new match")
assert_eq(loop.player_ids, [1, 2, 3] as Array[int])
assert_eq(loop.ticks, 5)