diff --git a/docs/GDD.md b/docs/GDD.md index 1768974..2e024ed 100644 --- a/docs/GDD.md +++ b/docs/GDD.md @@ -40,6 +40,23 @@ name, so it can't drift from the game. To change a number, edit that file. | Solo | 24 players | `SOLO_PLAYERS` | | Duos | 12 teams of 2 | `DUO_TEAMS`, `DUO_TEAM_SIZE` | +### Match flow + +The server runs matches back to back, in [`src/sim/match.gd`](../src/sim/match.gd): + +1. **Lobby.** Players join. Once `MATCH_MIN_PLAYERS` are in, it waits + `MATCH_LOBBY_SECONDS` for more, or counts down at once when full. +2. **Countdown.** `MATCH_COUNTDOWN_SECONDS`. If too many leave, it goes back to the lobby. +3. **Drop.** Bots fill the empty places, everyone boards the barge and loot is placed. +4. **Play.** Ends when at most one team has anyone standing. +5. **Results.** Finishing places and the winners stay up for `MATCH_RESULTS_SECONDS`, + then bots leave and the server goes back to the lobby with a new island. + +Leaving during the drop or play counts as being eliminated where you stood. Joining +during a match waits in the lobby for the next one. Every timer can be changed per +server through `MatchRules`. Match 0 uses the server's seed; later matches derive theirs +from it, so a whole session can be replayed from one seed. + Bots fill empty slots. Offline play is a local server filled with bots, the same game code as online play. A downed duo partner can be revived, within `REVIVE_SECONDS`. diff --git a/src/server/headless_server.gd b/src/server/headless_server.gd index 31a6eec..4cdb7a0 100644 --- a/src/server/headless_server.gd +++ b/src/server/headless_server.gd @@ -44,6 +44,7 @@ func _ready() -> void: started["engine"] = Engine.get_version_info()["string"] started["tick_rate_hz"] = Tuning.TICK_RATE_HZ started["world_hash"] = loop.sim.island.heightmap_hash() + started["match_phase"] = loop.match_flow.phase_name() started["listening"] = false started["note"] = "networking arrives in v0.5; players join as idle slots until then" _log("start", started) @@ -61,10 +62,10 @@ func _process(delta: float) -> void: # Too far behind to catch up: drop the backlog rather than spiral. _accumulator = minf(_accumulator, 1.0 / Tuning.TICK_RATE_HZ) for _index: int in due: - if config.ticks > 0 and loop.sim.tick >= config.ticks: + if config.ticks > 0 and loop.ticks >= config.ticks: break _tick() - if config.ticks > 0 and loop.sim.tick >= config.ticks: + if config.ticks > 0 and loop.ticks >= config.ticks: _finish(0) @@ -75,12 +76,15 @@ func _exit_tree() -> void: func _tick() -> void: - if config.fault == "script-error" and loop.sim.tick == FAULT_TICK: + if config.fault == "script-error" and loop.ticks == FAULT_TICK: _deliberate_script_error() loop.run_tick() - if config.log_every > 0 and loop.sim.tick % config.log_every == 0: + for event: Dictionary in loop.match_flow.events: + if event["type"] in ["phase", "match_started", "match_ended"]: + _log("match", event) + if config.log_every > 0 and loop.ticks % config.log_every == 0: var stats: Dictionary = loop.timing_stats() - _log("progress", {"tick": loop.sim.tick, "p95_us": stats["p95_us"], "max_us": stats["max_us"]}) + _log("progress", {"tick": loop.ticks, "p95_us": stats["p95_us"], "max_us": stats["max_us"]}) func _finish(requested_code: int) -> void: @@ -113,7 +117,7 @@ func _log(event: String, fields: Dictionary) -> void: "seed": config.match_seed, } if loop != null: - record["tick"] = loop.sim.tick + record["tick"] = loop.ticks record.merge(fields, false) print(JSON.stringify(record)) diff --git a/src/server/server_loop.gd b/src/server/server_loop.gd index 0d231dc..e0f8e89 100644 --- a/src/server/server_loop.gd +++ b/src/server/server_loop.gd @@ -1,5 +1,5 @@ -## Drives one match's simulation for a server: adds players and bots, gathers their -## commands each tick, steps the simulation and times every tick. +## Drives a server's matches: joins players, fills each match with bots, gathers their +## commands each tick, steps the match flow and times every tick. ## It has no scene-tree dependency, so tests can run it directly. class_name ServerLoop extends RefCounted @@ -7,35 +7,69 @@ extends RefCounted ## The server-tick budget from docs/ARCHITECTURE.md, in microseconds. const TICK_BUDGET_USEC: int = 12_000 -var sim: Simulation +## The match flow. Its `sim` is the current match's simulation. +var match_flow: Match +var sim: Simulation: + get: + return match_flow.sim +## Entity IDs of everyone in the current match, humans first. var player_ids: Array[int] = [] var bots: Array[WanderBot] = [] ## Wall-clock duration of every tick run, in microseconds. var tick_usec: PackedInt64Array = PackedInt64Array() +## Server ticks run, across every match. +var ticks: int = 0 -func _init(match_seed: int, human_players: int, bot_count: int) -> void: - sim = Simulation.new(match_seed) - for _index: int in human_players: - player_ids.append(sim.add_player()) - for _index: int in bot_count: - var id: int = sim.add_player() - player_ids.append(id) - bots.append(WanderBot.new(id)) - # Every match starts on the sky barge. - sim.start_drop() - sim.place_loot() +## `human_players` join as idle participants with handles 1 and up; `bot_count` bots +## fill the rest of every match. With `rules` null the match starts at once, and the +## server goes back to the lobby after each match's results and starts another. +func _init(match_seed: int, human_players: int, bot_count: int, rules: MatchRules = null) -> void: + if rules == null: + rules = MatchRules.immediate() + rules.max_players = maxi(human_players + bot_count, 1) + rules.fill_with_bots = bot_count > 0 + # With only bots there's nobody to wait for, so the lobby starts with no one in it. + rules.min_players = 0 if human_players == 0 and bot_count > 0 else 1 + match_flow = Match.new(match_seed, rules) + for handle: int in range(1, human_players + 1): + match_flow.join(handle) + if rules.lobby_ticks == 0 and rules.countdown_ticks == 0: + # Every match starts on the sky barge, on the first tick. + _advance() ## Runs one tick and records how long it took. func run_tick() -> void: var started: int = Time.get_ticks_usec() - for bot: WanderBot in bots: - sim.submit_command(bot.player_id, bot.think(sim)) - sim.step() + if match_flow.in_match(): + for bot: WanderBot in bots: + sim.submit_command(bot.player_id, bot.think(sim)) + _advance() + ticks += 1 tick_usec.append(Time.get_ticks_usec() - started) +func _advance() -> void: + match_flow.step() + for event: Dictionary in match_flow.events: + if event["type"] == "match_started": + _track_players() + elif event["type"] == "phase" and event["to"] == "lobby": + player_ids.clear() + bots.clear() + + +func _track_players() -> void: + player_ids.clear() + bots.clear() + for handle: int in match_flow.participants: + var entity_id: int = match_flow.entity_of[handle] + player_ids.append(entity_id) + if match_flow.bot_handles.has(handle): + bots.append(WanderBot.new(entity_id)) + + ## Timing statistics over every tick run so far, in microseconds. func timing_stats() -> Dictionary: var count: int = tick_usec.size() diff --git a/src/sim/match.gd b/src/sim/match.gd new file mode 100644 index 0000000..f6c949e --- /dev/null +++ b/src/sim/match.gd @@ -0,0 +1,246 @@ +## A server's match flow: lobby, countdown, drop, play and results, then back to the +## lobby for a new match on a new island. Everything is driven by step(), one call per +## server tick, so it is deterministic and has no scene-tree or clock dependency. +## +## Participants are identified by handles the server chooses (a connection, a local +## player or a bot). Joining and leaving can happen in any phase: a join during a match +## waits in the lobby for the next one, and leaving during a match counts as being +## eliminated where they stood. Each match gets a fresh Simulation, built while the +## lobby waits, so nothing carries over from the last one. +class_name Match +extends RefCounted + +const LOBBY: int = 0 +const COUNTDOWN: int = 1 +const DROP: int = 2 +const PLAY: int = 3 +const RESULTS: int = 4 +const PHASE_NAMES: Array[String] = ["lobby", "countdown", "drop", "play", "results"] +## Bots added to fill a match get handles counting down from here, so they never clash +## with a server's own handles, which are positive. +const FIRST_BOT_HANDLE: int = -1 + +var rules: MatchRules +## The seed the server was started with. Match 0 uses it as is; later matches derive +## their own from it and their index. +var session_seed: int = 0 +## How many matches have started. The current or next match's index is this, or this +## minus one once it has started. +var matches_started: int = 0 +var phase: int = LOBBY +## Ticks spent in the current phase. +var phase_ticks: int = 0 +## The current match's simulation during the drop, play and results. In the lobby and +## countdown, the next match's simulation, generated and waiting for players. +var sim: Simulation +## Participant handles in join order, and which of them are bots. +var participants: Array[int] = [] +var bot_handles: Dictionary = {} +## Handles playing in the current match, and their entity IDs both ways. +var entity_of: Dictionary = {} +var handle_of: Dictionary = {} +## Handle -> team index, for the current match. +var team_of: Dictionary = {} +## Finishing order of the current match, last place first: {"handle", "place", "by", +## "left"}. "by" is the eliminating handle, or 0. +var placements: Array[Dictionary] = [] +## The winning handles, empty for no winner (everyone left, or no one played). +var winners: Array[int] = [] +## What happened during the last step(): phase changes, joins, leaves, placements. +var events: Array[Dictionary] = [] + +var _next_bot_handle: int = FIRST_BOT_HANDLE +## How many started the current match. +var _match_size: int = 0 + + +func _init(seed_value: int, match_rules: MatchRules = null) -> void: + session_seed = seed_value + rules = match_rules if match_rules != null else MatchRules.new() + sim = Simulation.new(match_seed(0)) + + +## The seed of match `index`: the session seed for the first, then a hash of it and the +## index, kept non-negative. +func match_seed(index: int) -> int: + if index == 0: + return session_seed + return (session_seed ^ SimRng._hash_name("match:%d" % index)) & 0x7FFFFFFFFFFFFFFF + + +## The current or next match's seed. +func current_seed() -> int: + return sim.rng.match_seed + + +func phase_name() -> String: + return PHASE_NAMES[phase] + + +func in_match() -> bool: + return phase == DROP or phase == PLAY + + +## Adds a participant. Returns false if the handle is already here or the lobby is +## full. During a match they wait for the next one. +func join(handle: int, bot: bool = false) -> bool: + if participants.has(handle) or participants.size() >= rules.max_players: + return false + participants.append(handle) + if bot: + bot_handles[handle] = true + events.append({"type": "joined", "handle": handle, "bot": bot}) + return true + + +## Removes a participant. In a match, they're placed as if eliminated and their player +## leaves the simulation. Returns false if the handle isn't here. +func leave(handle: int) -> bool: + if not participants.has(handle): + return false + participants.erase(handle) + bot_handles.erase(handle) + events.append({"type": "left", "handle": handle}) + if entity_of.has(handle): + var entity_id: int = entity_of[handle] + var player: SimEntity = sim.entities.find(entity_id) + if in_match() and player != null and not player.eliminated: + _place(handle, 0, true) + sim.remove_player(entity_id) + handle_of.erase(entity_id) + entity_of.erase(handle) + return true + + +## Passes a participant's command to the simulation. Returns false outside a match, for +## a handle that isn't playing, or if the simulation rejected it. +func submit_command(handle: int, command: PlayerCommand) -> bool: + if not in_match() or not entity_of.has(handle): + return false + return sim.submit_command(entity_of[handle], command) + + +## Handles still in the match and not eliminated, in join order. +func alive() -> Array[int]: + var living: Array[int] = [] + if not in_match() and phase != RESULTS: + return living + for handle: int in entity_of: + var player: SimEntity = sim.entities.find(entity_of[handle]) + if player != null and not player.eliminated: + living.append(handle) + return living + + +## Advances one server tick. +func step() -> void: + events.clear() + phase_ticks += 1 + match phase: + LOBBY: + if participants.size() < rules.min_players: + phase_ticks = 0 + elif participants.size() >= rules.max_players or phase_ticks >= rules.lobby_ticks: + _enter(COUNTDOWN) + if rules.countdown_ticks <= 0: + _start() + COUNTDOWN: + if participants.size() < rules.min_players: + _enter(LOBBY) + elif phase_ticks >= rules.countdown_ticks: + _start() + DROP, PLAY: + sim.step() + _collect_eliminations() + if phase == DROP and sim.drop.finished: + _enter(PLAY) + _check_finished() + RESULTS: + if phase_ticks >= rules.results_ticks: + _reset() + + +func _enter(next: int) -> void: + events.append({"type": "phase", "from": PHASE_NAMES[phase], "to": PHASE_NAMES[next], "match": current_seed()}) + phase = next + phase_ticks = 0 + + +## Fills empty places with bots, puts every participant on the barge and places loot. +func _start() -> void: + if rules.fill_with_bots: + while participants.size() < rules.max_players: + var handle: int = _next_bot_handle + _next_bot_handle -= 1 + join(handle, true) + var size: int = maxi(rules.team_size, 1) + for index: int in participants.size(): + var handle: int = participants[index] + var entity_id: int = sim.add_player() + entity_of[handle] = entity_id + handle_of[entity_id] = handle + team_of[handle] = index / size + _match_size = participants.size() + sim.start_drop() + sim.place_loot() + matches_started += 1 + _enter(DROP) + events.append({"type": "match_started", "match": current_seed(), "index": matches_started - 1, "players": participants.size()}) + _check_finished() + + +func _collect_eliminations() -> void: + for event: Dictionary in sim.events: + if event["type"] != "eliminated" or not handle_of.has(event["player"]): + continue + var by: int = int(handle_of.get(event["by"], 0)) + _place(handle_of[event["player"]], by, false) + + +## Records a participant's finishing place: one more than the players left after them. +func _place(handle: int, by: int, left: bool) -> void: + for placed: Dictionary in placements: + if placed["handle"] == handle: + return + var place: int = _match_size - placements.size() + var record: Dictionary = {"handle": handle, "place": place, "by": by, "left": left} + placements.append(record) + var event: Dictionary = record.duplicate() + event["type"] = "placed" + events.append(event) + + +## Ends the match when at most one team has anyone standing. +func _check_finished() -> void: + if not in_match(): + return + var teams: Dictionary = {} + for handle: int in alive(): + teams[team_of[handle]] = true + if teams.size() > 1: + return + winners.clear() + for handle: int in alive(): + winners.append(handle) + # Winners take first place, after everyone eliminated. + for handle: int in winners: + placements.append({"handle": handle, "place": 1, "by": 0, "left": false}) + _enter(RESULTS) + events.append({"type": "match_ended", "match": current_seed(), "winners": winners.duplicate()}) + + +## Back to the lobby: bots leave, the match's bookkeeping is cleared, and the next +## match's island is generated. +func _reset() -> void: + for handle: int in bot_handles.keys(): + participants.erase(handle) + bot_handles.clear() + entity_of.clear() + handle_of.clear() + team_of.clear() + placements.clear() + winners.clear() + _next_bot_handle = FIRST_BOT_HANDLE + _match_size = 0 + sim = Simulation.new(match_seed(matches_started)) + _enter(LOBBY) diff --git a/src/sim/match.gd.uid b/src/sim/match.gd.uid new file mode 100644 index 0000000..2c9e846 --- /dev/null +++ b/src/sim/match.gd.uid @@ -0,0 +1 @@ +uid://dgeu4ua1a0qgm diff --git a/src/sim/match_rules.gd b/src/sim/match_rules.gd new file mode 100644 index 0000000..f153b1d --- /dev/null +++ b/src/sim/match_rules.gd @@ -0,0 +1,26 @@ +## How a server runs its matches: lobby size, timers and team size. Defaults come from +## Tuning; a server or test changes them per instance. +class_name MatchRules +extends RefCounted + +## The most participants in one match, bots included. +var max_players: int = Tuning.SOLO_PLAYERS +## The lobby counts down once this many participants have joined. +var min_players: int = Tuning.MATCH_MIN_PLAYERS +## Players on a team. 1 is solo. +var team_size: int = 1 +## With enough players, the lobby waits this long for more before counting down. A +## full lobby counts down at once. +var lobby_ticks: int = roundi(Tuning.MATCH_LOBBY_SECONDS * Tuning.TICK_RATE_HZ) +var countdown_ticks: int = roundi(Tuning.MATCH_COUNTDOWN_SECONDS * Tuning.TICK_RATE_HZ) +var results_ticks: int = roundi(Tuning.MATCH_RESULTS_SECONDS * Tuning.TICK_RATE_HZ) +## Fill empty places with bots when the match starts. +var fill_with_bots: bool = true + + +## Rules for a server that skips the lobby: the match starts on the first tick. +static func immediate() -> MatchRules: + var rules: MatchRules = MatchRules.new() + rules.lobby_ticks = 0 + rules.countdown_ticks = 0 + return rules diff --git a/src/sim/match_rules.gd.uid b/src/sim/match_rules.gd.uid new file mode 100644 index 0000000..a2d1ac6 --- /dev/null +++ b/src/sim/match_rules.gd.uid @@ -0,0 +1 @@ +uid://c8liu74vanogc diff --git a/src/sim/tuning.gd b/src/sim/tuning.gd index 08a477e..2178e4b 100644 --- a/src/sim/tuning.gd +++ b/src/sim/tuning.gd @@ -16,6 +16,15 @@ const DUO_TEAMS: int = 12 const DUO_TEAM_SIZE: int = 2 const REVIVE_SECONDS: float = 6.0 +# Match flow, in seconds. See Match and MatchRules, which can override each one. +## The lobby counts down once this many participants have joined. +const MATCH_MIN_PLAYERS: int = 1 +## With enough players, the lobby waits this long for more before counting down. +const MATCH_LOBBY_SECONDS: float = 20.0 +const MATCH_COUNTDOWN_SECONDS: float = 10.0 +## Results stay up this long before the server returns to the lobby. +const MATCH_RESULTS_SECONDS: float = 15.0 + # Player const PLAYER_MAX_HEALTH: int = 100 const PLAYER_MAX_ARMOR: int = 100 diff --git a/test/server/test_server_loop.gd b/test/server/test_server_loop.gd index 91ba83f..8db90d7 100644 --- a/test/server/test_server_loop.gd +++ b/test/server/test_server_loop.gd @@ -66,3 +66,26 @@ func test_same_seed_gives_the_same_match() -> void: 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) diff --git a/test/sim/test_match.gd b/test/sim/test_match.gd new file mode 100644 index 0000000..a3a00a4 --- /dev/null +++ b/test/sim/test_match.gd @@ -0,0 +1,264 @@ +extends TestCase + +## The match state machine from issue M1: lobby, countdown, drop, play and results, +## players leaving at every stage, empty matches, and ten matches in a row with no state +## carried between them. + +const SEED: int = 4242 + + +## Short timers so tests run quickly: lobby 3 ticks, countdown 2, results 2. +func _rules(max_players: int = 4, bots: bool = true) -> MatchRules: + var rules: MatchRules = MatchRules.new() + rules.max_players = max_players + rules.min_players = 1 + rules.lobby_ticks = 3 + rules.countdown_ticks = 2 + rules.results_ticks = 2 + rules.fill_with_bots = bots + return rules + + +func _steps(m: Match, count: int) -> void: + for _index: int in count: + m.step() + + +## Steps until the phase changes to `wanted`, or fails after `limit` ticks. +func _until(m: Match, wanted: int, limit: int = 5000) -> void: + for _index: int in limit: + if m.phase == wanted: + return + m.step() + fail("never reached %s; stuck in %s" % [Match.PHASE_NAMES[wanted], m.phase_name()]) + + +## Knocks a participant out as a weapon would: health to 0, noticed on the next step. +func _eliminate(m: Match, handle: int) -> void: + m.sim.entities.find(m.entity_of[handle]).health = 0 + + +func _saw(m: Match, type: String) -> bool: + for event: Dictionary in m.events: + if event["type"] == type: + return true + return false + + +## The state a fresh simulation for match `index` should have just after it starts. +func _reference_hash(m: Match, index: int, players: int) -> String: + var sim: Simulation = Simulation.new(m.match_seed(index)) + for _index: int in players: + sim.add_player() + sim.start_drop() + sim.place_loot() + return sim.state_hash() + + +func test_an_empty_lobby_waits_forever() -> void: + var m: Match = Match.new(SEED, _rules()) + _steps(m, 50) + assert_eq(m.phase, Match.LOBBY) + assert_eq(m.matches_started, 0) + assert_eq(m.sim.entities.count(), 0, "nothing is spawned in the lobby") + + +func test_lobby_counts_down_after_waiting_then_starts_a_full_match() -> void: + var m: Match = Match.new(SEED, _rules()) + assert_true(m.join(10)) + _steps(m, 2) + assert_eq(m.phase, Match.LOBBY, "waiting for more players") + m.step() + assert_eq(m.phase, Match.COUNTDOWN) + assert_true(_saw(m, "phase")) + m.step() + assert_eq(m.phase, Match.COUNTDOWN) + m.step() + assert_eq(m.phase, Match.DROP) + assert_true(_saw(m, "match_started")) + assert_eq(m.participants.size(), 4, "bots filled the empty places") + assert_eq(m.bot_handles.size(), 3) + assert_eq(m.participants[0], 10, "the human keeps the first place in the roster") + for handle: int in m.participants: + var player: SimEntity = m.sim.entities.find(m.entity_of[handle]) + assert_eq(player.drop_state, Drop.ABOARD, "everyone starts on the barge") + assert_true(m.sim.pickups.size() > 0, "loot was placed") + assert_eq(m.sim.tick, 0) + + +func test_a_full_lobby_counts_down_at_once() -> void: + var m: Match = Match.new(SEED, _rules(2)) + m.join(1) + m.join(2) + assert_false(m.join(3), "the lobby is full") + assert_false(m.join(1), "already joined") + m.step() + assert_eq(m.phase, Match.COUNTDOWN) + + +func test_leaving_in_the_lobby_and_countdown_returns_to_waiting() -> void: + var m: Match = Match.new(SEED, _rules()) + m.join(1) + _steps(m, 2) + m.leave(1) + m.step() + assert_eq(m.phase_ticks, 0, "the lobby timer resets with nobody waiting") + m.join(1) + _until(m, Match.COUNTDOWN) + assert_true(m.leave(1)) + assert_false(m.leave(1), "already gone") + m.step() + assert_eq(m.phase, Match.LOBBY, "the countdown stops when too few remain") + assert_eq(m.matches_started, 0) + + +func test_the_drop_becomes_play_when_the_barge_finishes() -> void: + var m: Match = Match.new(SEED, _rules()) + m.join(1) + _until(m, Match.DROP) + _until(m, Match.PLAY) + assert_true(m.sim.drop.finished) + for handle: int in m.participants: + assert_ne(m.sim.entities.find(m.entity_of[handle]).drop_state, Drop.ABOARD) + assert_eq(m.alive().size(), 4) + + +func test_last_one_standing_wins_and_places_are_recorded() -> void: + var m: Match = Match.new(SEED, _rules()) + m.join(1) + _until(m, Match.DROP) + var bots: Array[int] = [] + for handle: int in m.participants: + if handle != 1: + bots.append(handle) + _eliminate(m, bots[0]) + m.step() + assert_true(_saw(m, "placed")) + _eliminate(m, bots[1]) + _eliminate(m, bots[2]) + m.step() + assert_eq(m.phase, Match.RESULTS) + assert_true(_saw(m, "match_ended")) + assert_eq(m.winners, [1] as Array[int]) + var places: Dictionary = {} + for record: Dictionary in m.placements: + places[record["handle"]] = record["place"] + assert_eq(places[bots[0]], 4) + assert_eq(places[1], 1) + assert_eq(places.size(), 4, "everyone has a place") + assert_true(places[bots[1]] in [2, 3] and places[bots[2]] in [2, 3]) + + +func test_leaving_during_the_drop_and_play_counts_as_elimination() -> void: + var m: Match = Match.new(SEED, _rules()) + m.join(1) + m.join(2) + _until(m, Match.DROP) + var entity: int = m.entity_of[2] + assert_true(m.leave(2)) + assert_null(m.sim.entities.find(entity), "the leaver's player is gone") + assert_eq(m.placements[0]["handle"], 2) + assert_eq(m.placements[0]["place"], 4) + assert_true(m.placements[0]["left"]) + _until(m, Match.PLAY) + m.leave(1) + assert_eq(m.placements[1]["place"], 3) + m.step() + assert_eq(m.phase, Match.PLAY, "two bots still fight") + assert_false(m.submit_command(1, PlayerCommand.new()), "a leaver can't send commands") + + +func test_everyone_leaving_ends_the_match_with_no_winner() -> void: + var m: Match = Match.new(SEED, _rules(2, false)) + m.join(1) + m.join(2) + _until(m, Match.DROP) + m.leave(1) + m.leave(2) + m.step() + assert_eq(m.phase, Match.RESULTS) + assert_eq(m.winners.size(), 0) + _until(m, Match.LOBBY) + assert_eq(m.participants.size(), 0) + + +func test_an_empty_match_ends_at_once_and_returns_to_the_lobby() -> void: + var rules: MatchRules = _rules(4, false) + rules.min_players = 0 + var m: Match = Match.new(SEED, rules) + _until(m, Match.RESULTS, 20) + assert_eq(m.matches_started, 1) + assert_eq(m.winners.size(), 0) + assert_eq(m.placements.size(), 0) + _until(m, Match.LOBBY, 10) + + +func test_leaving_during_results_and_joining_during_a_match() -> void: + var m: Match = Match.new(SEED, _rules(3, false)) + m.join(1) + m.join(2) + _until(m, Match.DROP) + assert_true(m.join(3), "a late joiner waits for the next match") + assert_false(m.entity_of.has(3)) + assert_false(m.submit_command(3, PlayerCommand.new())) + _eliminate(m, 2) + m.step() + assert_eq(m.phase, Match.RESULTS) + assert_eq(m.winners, [1] as Array[int], "the late joiner isn't in this match") + m.leave(1) + assert_eq(m.winners, [1] as Array[int], "leaving during results keeps the result") + _until(m, Match.LOBBY) + assert_eq(m.participants, [2, 3] as Array[int]) + _until(m, Match.DROP) + assert_true(m.entity_of.has(3), "the late joiner plays the next match") + + +func test_teams_win_together() -> void: + var rules: MatchRules = _rules(4, false) + rules.team_size = 2 + var m: Match = Match.new(SEED, rules) + for handle: int in [1, 2, 3, 4]: + m.join(handle) + _until(m, Match.DROP) + assert_eq(m.team_of[1], m.team_of[2]) + assert_ne(m.team_of[2], m.team_of[3]) + _eliminate(m, 3) + m.step() + assert_eq(m.phase, Match.DROP, "team 2 still has a player") + _eliminate(m, 1) + _eliminate(m, 4) + m.step() + assert_eq(m.phase, Match.RESULTS) + assert_eq(m.winners, [2] as Array[int]) + + +func test_ten_matches_in_a_row_start_clean() -> void: + var m: Match = Match.new(SEED, _rules()) + m.join(7) + var seeds: Dictionary = {} + for index: int in 10: + _until(m, Match.DROP) + assert_eq(m.matches_started, index + 1) + assert_eq(m.sim.tick, 0, "match %d starts at tick 0" % index) + assert_eq(m.participants.size(), 4) + assert_eq(m.placements.size(), 0, "match %d starts with no placements" % index) + assert_eq(m.winners.size(), 0) + assert_eq(m.sim.entities.count(), 4 + m.sim.pickups.size(), "only this match's players and loot") + assert_eq(m.sim.state_hash(), _reference_hash(m, index, 4), "match %d is identical to a fresh one" % index) + seeds[m.current_seed()] = true + var player_ids: Array = m.handle_of.keys() + player_ids.sort() + assert_eq(player_ids, [1, 2, 3, 4], "entity IDs start again from 1") + # Play a little, then end it. + _steps(m, 5) + for handle: int in m.participants: + if handle != 7: + _eliminate(m, handle) + m.step() + assert_eq(m.phase, Match.RESULTS) + assert_eq(m.winners, [7] as Array[int]) + _until(m, Match.LOBBY) + assert_eq(m.participants, [7] as Array[int], "bots leave after each match") + assert_eq(m.entity_of.size(), 0) + assert_eq(seeds.size(), 10, "every match gets its own island") + assert_eq(m.match_seed(0), SEED, "the first match uses the server's seed") diff --git a/test/sim/test_match.gd.uid b/test/sim/test_match.gd.uid new file mode 100644 index 0000000..65a2da9 --- /dev/null +++ b/test/sim/test_match.gd.uid @@ -0,0 +1 @@ +uid://djnmjalwl32eb