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>
217 lines
9.2 KiB
GDScript
217 lines
9.2 KiB
GDScript
extends TestCase
|
|
|
|
## Issue A9: the in-game HUD, the FEED message that tells it who is standing and who
|
|
## fell, and HudState, which works out what it shows.
|
|
|
|
const FRAME: float = 1.0 / 60.0
|
|
|
|
|
|
func _rules() -> MatchRules:
|
|
var rules: MatchRules = MatchRules.new()
|
|
rules.max_players = 4
|
|
rules.min_players = 1
|
|
rules.lobby_ticks = 6
|
|
rules.countdown_ticks = 6
|
|
rules.results_ticks = 6
|
|
return rules
|
|
|
|
|
|
func test_feed_round_trips() -> void:
|
|
var entries: Array[Dictionary] = [
|
|
{"victim": -3, "by": 1, "cause": "weapon", "item": 2, "place": 4, "tied": false, "victim_name": "Thole", "by_name": "Ada"},
|
|
{"victim": 1, "by": 0, "cause": "tide", "item": -1, "place": 3, "tied": true, "victim_name": "Ada", "by_name": ""},
|
|
]
|
|
var told: Dictionary = NetFeed.decode(NetFeed.encode(3, 24, entries))
|
|
assert_eq(told["standing"], 3)
|
|
assert_eq(told["total"], 24)
|
|
assert_eq(told["entries"].size(), 2)
|
|
for index: int in 2:
|
|
for key: String in entries[index]:
|
|
assert_eq(told["entries"][index][key], entries[index][key], "%s of entry %d" % [key, index])
|
|
|
|
|
|
func test_feed_keeps_only_the_newest_entries_and_cuts_long_names_on_characters() -> void:
|
|
var entries: Array[Dictionary] = []
|
|
for index: int in NetFeed.MAX_ENTRIES + 5:
|
|
entries.append({"victim": -index - 1, "cause": "drown", "place": 24 - index, "victim_name": "ÆØÅ".repeat(20)})
|
|
var told: Dictionary = NetFeed.decode(NetFeed.encode(1, 24, entries))
|
|
assert_eq(told["entries"].size(), NetFeed.MAX_ENTRIES)
|
|
assert_eq(told["entries"][NetFeed.MAX_ENTRIES - 1]["victim"], -(NetFeed.MAX_ENTRIES + 5), "the newest is last")
|
|
var name: String = told["entries"][0]["victim_name"]
|
|
assert_true(name.to_utf8_buffer().size() <= NetFeed.MAX_NAME_BYTES)
|
|
assert_true(name.begins_with("ÆØÅ") and name.length() == NetFeed.MAX_NAME_BYTES / 2, "cut between characters: %s" % name)
|
|
|
|
|
|
func test_malformed_feed_is_refused() -> void:
|
|
var good: PackedByteArray = NetFeed.encode(2, 4, [{"victim": -1, "cause": "fall", "victim_name": "Kelp"}] as Array[Dictionary])
|
|
assert_false(NetFeed.decode(good).is_empty())
|
|
for cut: int in good.size():
|
|
assert_true(NetFeed.decode(good.slice(0, cut)).is_empty(), "cut at %d" % cut)
|
|
var longer: PackedByteArray = good.duplicate()
|
|
longer.append(0)
|
|
assert_true(NetFeed.decode(longer).is_empty(), "trailing bytes")
|
|
var bad_cause: PackedByteArray = good.duplicate()
|
|
bad_cause[NetFeed.HEADER_BYTES + 8] = NetFeed.CAUSES.size()
|
|
assert_true(NetFeed.decode(bad_cause).is_empty(), "unknown cause")
|
|
var many: PackedByteArray = good.duplicate()
|
|
many[3] = NetFeed.MAX_ENTRIES + 1
|
|
assert_true(NetFeed.decode(many).is_empty(), "too many entries")
|
|
|
|
|
|
func test_feed_lines_are_words_and_name_you() -> void:
|
|
var flint: int = ItemCatalog.code_of(String(Tuning.WEAPONS.keys()[1]))
|
|
var entries: Array[Dictionary] = [
|
|
{"victim": -2, "by": 1, "cause": "weapon", "item": flint, "victim_name": "Skerry", "by_name": "Ada"},
|
|
{"victim": 1, "by": -4, "cause": "weapon", "item": -1, "victim_name": "Ada", "by_name": "Scupper"},
|
|
{"victim": -5, "by": 0, "cause": "drown", "victim_name": "Cockle"},
|
|
{"victim": -6, "by": 0, "cause": "tide", "victim_name": "Fathom"},
|
|
{"victim": -7, "by": 0, "cause": "left", "victim_name": "Lugworm"},
|
|
{"victim": -8, "by": 0, "cause": "fall", "victim_name": "Pollack"},
|
|
]
|
|
var lines: Array[Dictionary] = HudState.feed_lines(entries, 1)
|
|
assert_eq(lines.size(), HudState.FEED_LINES, "only the newest")
|
|
assert_eq(lines[0]["text"], "Scupper took you")
|
|
assert_true(lines[0]["you"])
|
|
assert_eq(lines[1]["text"], "Cockle drowned")
|
|
assert_eq(lines[2]["text"], "The tide took Fathom")
|
|
assert_eq(lines[3]["text"], "Lugworm left")
|
|
assert_eq(lines[4]["text"], "Pollack fell")
|
|
assert_false(lines[4]["you"])
|
|
var first: Array[Dictionary] = HudState.feed_lines(entries.slice(0, 1), 1)
|
|
assert_eq(first[0]["text"], "You took Skerry with %s" % HudState.item_name(ItemCatalog.get_def(flint).id).to_lower())
|
|
|
|
|
|
func test_crew_names_are_stable_and_distinct() -> void:
|
|
assert_eq(CrewNames.for_bot(-1), CrewNames.NAMES[0])
|
|
var seen: Dictionary = {}
|
|
for handle: int in range(-1, -49, -1):
|
|
var name: String = CrewNames.for_bot(handle)
|
|
assert_false(seen.has(name), "%s used twice" % name)
|
|
seen[name] = true
|
|
|
|
|
|
func test_offline_client_is_told_who_stands_and_who_fell() -> void:
|
|
var game: ClientGame = ClientGame.new()
|
|
var local: LocalServer = LocalServer.new(5, 3, _rules())
|
|
for _tick: int in 200:
|
|
local.tick(game)
|
|
if game.playing():
|
|
break
|
|
assert_true(game.playing(), "the match began")
|
|
assert_eq(game.match_size, 4)
|
|
assert_eq(game.standing, 4)
|
|
var flow: Match = local.loop.match_flow
|
|
var bot: int = flow.bot_handles.keys()[0]
|
|
var bot_player: SimEntity = flow.sim.entities.find(flow.entity_of[bot])
|
|
bot_player.health = 0
|
|
bot_player.last_cause = SimEntity.CAUSE_DROWN
|
|
local.tick(game)
|
|
assert_eq(game.standing, 3, "told at once")
|
|
assert_eq(game.feed.size(), 1)
|
|
assert_eq(game.feed[0]["victim"], bot)
|
|
assert_eq(game.feed[0]["victim_name"], CrewNames.for_bot(bot))
|
|
assert_eq(game.feed[0]["cause"], "drown")
|
|
assert_eq(game.bad_packets, 0)
|
|
var state: HudState = HudState.from_client(game, ClientInput.new(), LocalServer.HANDLE)
|
|
assert_eq(state.feed[0]["text"], "%s drowned" % CrewNames.for_bot(bot))
|
|
assert_true(state.playing)
|
|
assert_eq(state.health, Tuning.PLAYER_MAX_HEALTH)
|
|
assert_eq(state.slots.size(), Tuning.INVENTORY_SLOTS + 1, "the boathook and the slots")
|
|
assert_true(state.slots[0]["selected"], "the boathook is held at first")
|
|
assert_false(state.tide.is_empty())
|
|
assert_eq(state.tide["phase"], 1)
|
|
assert_true(state.tide["next"] >= state.tide["sea"])
|
|
|
|
|
|
func test_from_match_reads_the_server_player_and_build_mode() -> void:
|
|
var loop: ServerLoop = ServerLoop.new(5, 1, 3, _rules())
|
|
loop.play_humans_by_script()
|
|
while not loop.match_flow.in_match():
|
|
loop.run_tick()
|
|
for _tick: int in 30:
|
|
loop.run_tick()
|
|
var flow: Match = loop.match_flow
|
|
var handle: int = flow.participants.filter(func(h: int) -> bool: return h > 0)[0]
|
|
var me: SimEntity = flow.sim.entities.find(flow.entity_of[handle])
|
|
me.materials[Materials.STONE] = 5
|
|
var state: HudState = HudState.from_match(flow, handle, true, StructureSet.WALL, Materials.STONE)
|
|
assert_true(state.playing)
|
|
assert_eq(state.build["kind"], "wall")
|
|
assert_eq(state.build["material"], "stone")
|
|
assert_false(state.build["affordable"], "5 stone isn't a wall")
|
|
me.materials[Materials.STONE] = 50
|
|
assert_true(HudState.from_match(flow, handle, true, StructureSet.WALL, Materials.STONE).build["affordable"])
|
|
assert_true(HudState.from_match(flow, handle).build.is_empty(), "not building")
|
|
assert_eq(state.standing, 4)
|
|
assert_false(is_nan(float(state.tide["feet"])))
|
|
|
|
|
|
func test_hud_shows_only_what_the_state_holds() -> void:
|
|
var hud: Hud = Hud.new()
|
|
var empty: HudState = HudState.new()
|
|
hud.show_state(empty)
|
|
assert_eq(_texts(hud), [] as Array[String], "nothing to show before a match")
|
|
var state: HudState = HudState.new()
|
|
state.playing = true
|
|
state.health = 20
|
|
state.armor = 50
|
|
state.standing = 7
|
|
state.total = 24
|
|
state.tide = {"phase": 2, "phases": 6, "stage": Tide.HOLD, "sea": 3.0, "next": 6.5, "rise_in": 42.0, "feet": 4.0}
|
|
state.slots = [{"selected": true, "empty": false, "name": "Boathook", "count": 1, "rounds": -1, "reserve": -1, "tier": -1}] as Array[Dictionary]
|
|
state.feed = [{"text": "Kelp drowned", "you": false}] as Array[Dictionary]
|
|
hud.show_state(state)
|
|
var texts: Array[String] = _texts(hud)
|
|
assert_true(texts.has("7 of 24 standing"), "%s" % [texts])
|
|
assert_true(texts.has("Kelp drowned"))
|
|
assert_true(texts.has("Driftwood 0"))
|
|
hud.show_state(empty)
|
|
texts = _texts(hud)
|
|
assert_false(texts.has("Kelp drowned"), "an empty feed clears the lines")
|
|
hud.free()
|
|
|
|
|
|
func test_session_shows_a_hud_while_playing_offline() -> void:
|
|
var session: ClientSession = ClientSession.new()
|
|
session.input.autoplay = true
|
|
session._ready()
|
|
session.play_offline(2, 3, _rules())
|
|
for _frame: int in 60 * 20:
|
|
session.pump(FRAME)
|
|
if session.game.playing():
|
|
break
|
|
assert_true(session.game.playing())
|
|
var state: HudState = session.hud_state()
|
|
assert_true(state.playing)
|
|
assert_eq(state.total, 4)
|
|
session.hud.show_state(state)
|
|
assert_true(_texts(session.hud).has("4 of 4 standing"))
|
|
session.free()
|
|
|
|
|
|
## The text of every label shown: visible itself and in every parent up to the HUD.
|
|
func _texts(node: Node) -> Array[String]:
|
|
var found: Array[String] = []
|
|
var item: CanvasItem = node as CanvasItem
|
|
if item != null and not item.visible:
|
|
return found
|
|
var label: Label = node as Label
|
|
if label != null:
|
|
found.append(label.text)
|
|
for child: Node in node.get_children():
|
|
found.append_array(_texts(child))
|
|
return found
|
|
|
|
|
|
func test_a_down_in_duos_travels_in_the_feed_and_reads_as_a_down() -> void:
|
|
var entries: Array[Dictionary] = [
|
|
{"victim": -3, "by": 1, "cause": "weapon", "item": -1, "place": 0, "tied": false, "downed": true, "victim_name": "Thole", "by_name": "Ada"},
|
|
{"victim": -4, "by": 0, "cause": "fall", "item": -1, "place": 0, "tied": false, "downed": true, "victim_name": "Brine", "by_name": ""},
|
|
]
|
|
var told: Dictionary = NetFeed.decode(NetFeed.encode(3, 24, entries))
|
|
assert_true(told["entries"][0]["downed"])
|
|
var lines: Array[Dictionary] = HudState.feed_lines(told["entries"], 1)
|
|
assert_eq(lines[0]["text"], "You knocked Thole down")
|
|
assert_eq(lines[1]["text"], "Brine is down")
|
|
assert_eq(HudState.feed_lines(told["entries"], -3)[0]["text"], "Ada knocked you down")
|