Files
tidewall/test/sim/test_results.gd
T
claudeandClaude Opus 5.5 2167900e45 M7: Duos and revive
Two-player teams, enforced by the simulation:
- Match puts every player on a team (SimEntity.team); Weapons.damage_player
  refuses damage between teammates from every weapon, the boathook and blasts.
- A player whose health runs out with a teammate standing goes down instead of
  out: 60 health to bleed (one point every half second), crawling at 1 m/s, no
  firing, building, looting or items. Hits still take it; drowning too.
- A standing teammate within 2 m holding interact for 6 s revives them with 30
  health. Letting go or moving away starts it over.
- Downed players are out when their health runs out again or when no teammate
  is left standing, credited to whoever downed them. A team falls together and
  shares its place; the tie-break puts standing ahead of downed.
- Downs and revives go through Match events and the kill feed ("X knocked Y
  down"); the HUD says what to do while down.

Wire: FLAG_DOWNED in the player record and the own block (flags now u16),
so prediction crawls too. Protocol version 5.

Bots: never target a teammate, land with their teammate, regroup when they
stray past 30 m, crawl toward a standing teammate when down, go to revive a
downed teammate within 60 m when not in a fight, and turn from a downed target
to its standing teammate when it's in view.

Options: --team-size=2 on the server, --duos offline, and Solo/Duos under
Crew in the Practice menu. The figure has a downed crawl pose.

Tests: test_duos (downing, crawl, revive, interrupted revive, bleed-out,
finishing, team out, falling together, no friendly damage including kegs,
drowning while down, hash, match placement and tie-break), bots as teammates,
the downed flag on the wire, the feed, server and menu options. make
duo-matches plays 10 bot duos matches.

Closes #30

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 03:01:09 -05:00

333 lines
12 KiB
GDScript

extends TestCase
## Eliminations, spectating and results from issue M3: shared places for players who
## fall together, the kill feed and its causes, spectators who follow on when their
## target falls, and the match summary.
const SEED: int = 4242
## Flat ground well above any early tide, so nobody drowns by accident.
const FLOOR: float = 20.0
func _rules(max_players: int = 4, team_size: int = 1) -> MatchRules:
var rules: MatchRules = MatchRules.new()
rules.max_players = max_players
rules.min_players = 1
rules.lobby_ticks = 1
rules.countdown_ticks = 1
rules.results_ticks = 2
rules.team_size = team_size
return rules
## A match on flat ground with one human (handle 1) and bots, already in play with
## everyone standing in a row 4 m apart, facing +z.
func _match(max_players: int = 4, team_size: int = 1) -> Match:
var m: Match = Match.new(SEED, _rules(max_players, team_size))
m.sim = Simulation.new(SEED, SimGround.flat(FLOOR))
m.join(1)
for _index: int in 10:
if m.phase == Match.DROP:
break
m.step()
assert_eq(m.phase, Match.DROP)
var index: int = 0
for handle: int in m.participants:
var player: SimEntity = _player(m, handle)
player.drop_state = Drop.NONE
player.position = Vector3(100.0 + index * 4.0, FLOOR, 100.0)
player.velocity = Vector3.ZERO
player.on_ground = true
index += 1
m.sim.drop.finished = true
m.step()
assert_eq(m.phase, Match.PLAY)
return m
func _player(m: Match, handle: int) -> SimEntity:
return m.sim.entities.find(m.entity_of[handle])
## Knocks `handle` out as if `by` (a handle, or 0) had landed the last hit.
func _eliminate(m: Match, handle: int, by: int = 0) -> void:
var player: SimEntity = _player(m, handle)
player.health = 0
if by != 0:
player.last_attacker = m.entity_of[by]
player.last_cause = SimEntity.CAUSE_WEAPON
func _record(m: Match, handle: int) -> Dictionary:
for record: Dictionary in m.placements:
if record["handle"] == handle:
return record
fail("no placement for %d" % handle)
return {}
func _row(m: Match, handle: int) -> Dictionary:
for row: Dictionary in m.summary():
if row["handle"] == handle:
return row
fail("no summary row for %d" % handle)
return {}
func test_players_falling_on_the_same_tick_share_the_better_place() -> void:
var m: Match = _match(6)
var hs: Array[int] = m.participants.duplicate()
_eliminate(m, hs[5])
m.step()
assert_eq(_record(m, hs[5])["place"], 6)
assert_false(_record(m, hs[5])["tied"])
_eliminate(m, hs[3])
_eliminate(m, hs[4])
m.step()
assert_eq(_record(m, hs[3])["place"], 4, "two fell with five standing: both 4th")
assert_eq(_record(m, hs[4])["place"], 4)
assert_true(_record(m, hs[3])["tied"] and _record(m, hs[4])["tied"])
_eliminate(m, hs[2])
m.step()
assert_eq(_record(m, hs[2])["place"], 3, "the next to fall is 3rd, after a shared 4th")
_eliminate(m, hs[1])
m.step()
assert_eq(m.phase, Match.RESULTS)
assert_eq(_record(m, hs[1])["place"], 2)
assert_eq(m.winners, [hs[0]] as Array[int])
func test_the_last_players_falling_together_leave_one_winner_and_a_shared_second() -> void:
var m: Match = _match(4)
var hs: Array[int] = m.participants.duplicate()
_eliminate(m, hs[3])
m.step()
# The other three fall together. The tie-break picks a winner (health is 0 for all,
# so it's height, then join order) and the other two share 2nd.
_player(m, hs[2]).position.y += 0.5
for handle: int in [hs[0], hs[1], hs[2]]:
_eliminate(m, handle)
m.step()
assert_eq(m.phase, Match.RESULTS)
assert_eq(m.winners, [hs[2]] as Array[int], "the highest of the three wins the tie")
assert_eq(_record(m, hs[2])["place"], 1)
assert_eq(_record(m, hs[0])["place"], 2)
assert_eq(_record(m, hs[1])["place"], 2)
assert_true(_record(m, hs[0])["tied"])
assert_eq(_record(m, hs[3])["place"], 4, "the earlier faller keeps 4th")
assert_eq(m.placements.size(), 4, "one record each")
func test_two_last_players_falling_together_place_first_and_second() -> void:
var m: Match = _match(2)
var hs: Array[int] = m.participants.duplicate()
_eliminate(m, hs[0])
_eliminate(m, hs[1])
m.step()
assert_eq(m.winners, [hs[0]] as Array[int], "equal in everything: the first to join wins")
assert_eq(_record(m, hs[1])["place"], 2)
assert_false(_record(m, hs[1])["tied"], "a lone second isn't a tie")
func test_a_trade_credits_both_eliminations_and_feeds_both() -> void:
var m: Match = _match(4)
var hs: Array[int] = m.participants.duplicate()
_eliminate(m, hs[1], hs[2])
_eliminate(m, hs[2], hs[1])
m.step()
assert_eq(m.phase, Match.PLAY)
assert_eq(_row(m, hs[1])["eliminations"], 1)
assert_eq(_row(m, hs[2])["eliminations"], 1)
assert_eq(m.kill_feed.size(), 2)
for entry: Dictionary in m.kill_feed:
assert_eq(entry["cause"], "weapon")
assert_eq(entry["place"], 3)
assert_true(entry["tied"])
assert_eq(_record(m, hs[1])["by"], hs[2])
func test_teammates_are_not_credited_for_each_other() -> void:
var m: Match = _match(4, 2)
var hs: Array[int] = m.participants.duplicate()
assert_eq(m.team_of[hs[0]], m.team_of[hs[1]])
_eliminate(m, hs[1], hs[0])
m.step()
assert_eq(_row(m, hs[0])["eliminations"], 0)
func test_the_kill_feed_names_the_weapon_and_damage_counts_between_opponents() -> void:
var m: Match = _match(4)
var hs: Array[int] = m.participants.duplicate()
var shooter: SimEntity = _player(m, 1)
var target_handle: int = hs[1]
var target: SimEntity = _player(m, target_handle)
# Stand the target 10 m in front of the shooter, with a revolver in hand.
target.position = shooter.position + Vector3(0.0, 0.0, 10.0)
var revolver: int = ItemCatalog.code_of("signal_revolver")
Inventory.give(shooter, revolver, 1)
shooter.selected = 1
var eye: Vector3 = Harvest.eye(shooter)
var aim: Vector3 = target.position + Vector3(0.0, 0.9, 0.0) - eye
var pitch: float = atan2(aim.y, Vector2(aim.x, aim.z).length())
var buttons: int = PlayerCommand.BUTTON_FIRE | PlayerCommand.BUTTON_AIM
for _index: int in 10:
m.submit_command(1, PlayerCommand.from_input(m.sim.tick, Vector2.ZERO, 0.0, pitch, buttons, 1))
m.step()
var dealt: int = Tuning.PLAYER_MAX_HEALTH - target.health
assert_true(dealt > 0, "the revolver hit")
assert_eq(_row(m, 1)["damage_dealt"], dealt)
assert_eq(_row(m, target_handle)["damage_taken"], dealt)
# Finish them off: the feed credits the shooter with the revolver.
target.health = 1
for _index: int in 40:
if target.eliminated:
break
m.submit_command(1, PlayerCommand.from_input(m.sim.tick, Vector2.ZERO, 0.0, pitch, buttons, 1))
m.step()
assert_true(target.eliminated, "the second shot landed")
var entry: Dictionary = m.kill_feed[m.kill_feed.size() - 1]
assert_eq(entry["handle"], target_handle)
assert_eq(entry["by"], 1)
assert_eq(entry["cause"], "weapon")
assert_eq(entry["item"], revolver)
assert_eq(_row(m, 1)["eliminations"], 1)
func test_the_simulation_names_the_cause_of_each_elimination() -> void:
# A long fall onto dry ground.
var dry: Simulation = Simulation.new(SEED, SimGround.flat(10.0))
var faller: SimEntity = dry.entities.find(dry.add_player())
faller.position = Vector3(50.0, 80.0, 50.0)
faller.on_ground = false
faller.health = 1
assert_eq(_cause_of_end(dry, faller), "fall")
# An exhausted swimmer on a sea floor 10 m down, out of breath.
var wet: Simulation = Simulation.new(SEED, SimGround.flat(-10.0))
var swimmer: SimEntity = wet.entities.find(wet.add_player())
swimmer.position = Vector3(80.0, -10.0, 80.0)
swimmer.on_ground = true
swimmer.stamina_ticks = 0
swimmer.breath_ticks = 0
swimmer.health = 1
wet.drown_dps = 5
assert_eq(_cause_of_end(wet, swimmer), "drown")
## Steps until `player` is eliminated and returns the cause the simulation gave.
func _cause_of_end(sim: Simulation, player: SimEntity) -> String:
for _index: int in Tuning.TICK_RATE_HZ * 15:
sim.step()
for event: Dictionary in sim.events:
if event["type"] == "eliminated" and event["player"] == player.id:
return event["cause"]
fail("player %d was never eliminated" % player.id)
return ""
func test_spectators_follow_their_eliminator_then_move_on_when_the_target_falls() -> void:
var m: Match = _match(4)
var hs: Array[int] = m.participants.duplicate()
_eliminate(m, 1, hs[2])
m.step()
assert_eq(m.spectate_target(1), hs[2], "watching whoever knocked them out")
assert_true(m.events.any(func(e: Dictionary) -> bool: return e["type"] == "spectating"))
# hs[2] falls to hs[3]: the view follows hs[3].
_eliminate(m, hs[2], hs[3])
m.step()
assert_eq(m.spectate_target(1), hs[3])
assert_eq(m.spectate_target(hs[2]), hs[3])
# hs[3] falls to the tide: no eliminator standing, so the next living player.
_eliminate(m, hs[3])
m.step()
assert_eq(m.phase, Match.RESULTS)
assert_eq(m.spectate_target(1), hs[1], "the winner")
assert_eq(m.spectate_target(hs[3]), hs[1])
assert_eq(m.spectate_target(hs[1]), 0, "the winner isn't spectating")
func test_spectators_move_on_when_their_target_leaves() -> void:
var m: Match = _match(4)
var hs: Array[int] = m.participants.duplicate()
_eliminate(m, hs[3], hs[1])
m.step()
assert_eq(m.spectate_target(hs[3]), hs[1])
m.leave(hs[1])
var target: int = m.spectate_target(hs[3])
assert_true(target != hs[1] and m.alive().has(target), "watching someone still standing")
func test_spectators_cycle_through_living_players() -> void:
var m: Match = _match(4)
var hs: Array[int] = m.participants.duplicate()
_eliminate(m, hs[0])
m.step()
var first: int = m.spectate_target(hs[0])
assert_true(m.alive().has(first))
var seen: Dictionary = {first: true}
for _index: int in 2:
seen[m.cycle_spectate(hs[0])] = true
assert_eq(seen.size(), 3, "cycling visits every living player")
assert_eq(m.cycle_spectate(hs[0]), first, "and wraps around")
var back: int = m.cycle_spectate(hs[0], -1)
assert_ne(back, first)
assert_eq(m.cycle_spectate(hs[1]), 0, "a living player can't spectate")
func test_teammates_spectate_their_living_team() -> void:
var m: Match = _match(4, 2)
var hs: Array[int] = m.participants.duplicate()
_eliminate(m, hs[0])
m.step()
assert_true(_player(m, hs[0]).downed, "duos: down first (M7)")
assert_eq(m.spectate_target(hs[0]), 0, "a downed player isn't spectating")
_eliminate(m, hs[0])
m.step()
assert_true(_player(m, hs[0]).eliminated, "finished off")
assert_eq(m.spectate_target(hs[0]), hs[1], "with no eliminator, the teammate")
func test_the_summary_has_place_eliminations_damage_and_survival() -> void:
var m: Match = _match(4)
var hs: Array[int] = m.participants.duplicate()
for _index: int in Tuning.TICK_RATE_HZ:
m.step()
_eliminate(m, hs[3], hs[0])
m.step()
var fell_at: int = m.sim.tick
for _index: int in Tuning.TICK_RATE_HZ:
m.step()
_eliminate(m, hs[2], hs[0])
_eliminate(m, hs[1], hs[0])
m.step()
assert_eq(m.phase, Match.RESULTS)
var rows: Array[Dictionary] = m.summary()
assert_eq(rows.size(), 4)
assert_eq(rows[0]["handle"], 1, "best place first")
assert_eq(rows[0]["place"], 1)
assert_eq(rows[0]["eliminations"], 3)
assert_false(rows[0]["bot"])
assert_true(rows[3]["bot"])
assert_eq(rows[3]["handle"], hs[3])
assert_eq(rows[3]["place"], 4)
assert_eq(rows[3]["survival_ticks"], fell_at)
assert_near(rows[3]["survival_seconds"], float(fell_at) / Tuning.TICK_RATE_HZ, 0.001)
assert_true(rows[0]["survival_ticks"] > rows[3]["survival_ticks"])
for row: Dictionary in rows:
for key: String in ["handle", "bot", "team", "place", "tied", "eliminations", "damage_dealt", "damage_taken", "survival_ticks", "survival_seconds", "by", "cause", "left"]:
assert_true(row.has(key), "summary has %s" % key)
func test_a_new_match_starts_with_clean_results() -> void:
var m: Match = _match(2)
var hs: Array[int] = m.participants.duplicate()
_eliminate(m, hs[1], 1)
m.step()
assert_eq(m.phase, Match.RESULTS)
for _index: int in 10:
if m.phase == Match.LOBBY:
break
m.step()
assert_eq(m.phase, Match.LOBBY)
assert_true(m.kill_feed.is_empty() and m.stats.is_empty() and m.spectating.is_empty())
assert_true(m.summary().is_empty())