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>
202 lines
11 KiB
GDScript
202 lines
11 KiB
GDScript
extends TestCase
|
|
|
|
## Issue N2: the wire format of snapshots, input packets and the match notice.
|
|
|
|
|
|
func _player(sim: Simulation, at: Vector3) -> SimEntity:
|
|
var player: SimEntity = sim.entities.find(sim.add_player())
|
|
player.position = at
|
|
return player
|
|
|
|
|
|
func test_a_record_keeps_position_to_a_sixty_fourth_of_a_metre() -> void:
|
|
var sim: Simulation = Simulation.new(3, SimGround.flat())
|
|
var player: SimEntity = _player(sim, Vector3(511.37, -20.21, 1003.99))
|
|
player.yaw = 40000
|
|
player.pitch = -PlayerCommand.PITCH_MAX
|
|
player.health = 73
|
|
player.crouching = true
|
|
var record: PackedInt32Array = NetSnapshot.record_of(player)
|
|
assert_true(NetSnapshot.position_of(record).distance_to(player.position) < 0.014)
|
|
assert_near(NetSnapshot.yaw_radians_of(record), float(40000) / 65536.0 * TAU, 0.0001)
|
|
assert_near(NetSnapshot.pitch_radians_of(record), -PI * 0.5, 0.0001)
|
|
assert_eq(record[NetSnapshot.R_HEALTH], 73)
|
|
assert_true(record[NetSnapshot.R_FLAGS] & NetSnapshot.FLAG_CROUCHING != 0)
|
|
assert_eq(record[NetSnapshot.R_HELD], 0, "the boathook")
|
|
|
|
|
|
func test_positions_outside_the_world_are_clamped_not_wrapped() -> void:
|
|
var sim: Simulation = Simulation.new(3, SimGround.flat())
|
|
var player: SimEntity = _player(sim, Vector3(-50.0, 5000.0, 2000.0))
|
|
var where: Vector3 = NetSnapshot.position_of(NetSnapshot.record_of(player))
|
|
assert_near(where.x, 0.0, 0.001)
|
|
assert_near(where.z, 65535.0 / 64.0, 0.001)
|
|
assert_near(where.y, 65535.0 / 64.0 - NetSnapshot.Y_OFFSET_METRES, 0.001)
|
|
|
|
|
|
func test_a_snapshot_round_trips_every_archetype_and_partial_masks() -> void:
|
|
var sim: Simulation = Simulation.new(3, SimGround.flat())
|
|
var player: SimEntity = _player(sim, Vector3(100.0, 0.0, 100.0))
|
|
var pickup: SimEntity = sim.entities.find(Inventory.spawn_pickup(sim, Vector3(101.0, 0.0, 100.0), 1, 7, -1, 2))
|
|
var shot: SimEntity = sim.entities.create(SimEntity.ARCHETYPE_PROJECTILE)
|
|
shot.position = Vector3(120.0, 9.0, 80.0)
|
|
shot.item = 4
|
|
shot.owner_id = player.id
|
|
var before: PackedInt32Array = NetSnapshot.record_of(player)
|
|
player.position.x += 3.0
|
|
player.health = 12
|
|
var after: PackedInt32Array = NetSnapshot.record_of(player)
|
|
var mask: int = NetSnapshot.diff_mask(before, after)
|
|
assert_eq(mask, 0b101, "position and vitals changed, nothing else")
|
|
var header: Dictionary = {
|
|
"tick": 900, "baseline": 897, "sim_tick": 300, "command_tick": 298, "own_id": player.id,
|
|
"match_phase": Match.PLAY, "tide_phase": 2, "sea_cm": -150,
|
|
}
|
|
var records: Array = [
|
|
[player.id, mask, after],
|
|
[pickup.id, NetSnapshot.full_mask(SimEntity.ARCHETYPE_PICKUP), NetSnapshot.record_of(pickup)],
|
|
[shot.id, NetSnapshot.full_mask(SimEntity.ARCHETYPE_PROJECTILE), NetSnapshot.record_of(shot)],
|
|
]
|
|
var bytes: PackedByteArray = NetSnapshot.encode_snapshot(header, PackedInt32Array([70000, 5]), records)
|
|
# The header, the watched entity, phases and sea, the own-block flag, two removals, the count.
|
|
var expected: int = NetSnapshot.HEADER_BYTES + 1 + 4 + 1 + 1 + 4 + 2
|
|
for entry: Array in records:
|
|
expected += NetSnapshot.record_bytes(entry[0], entry[2][0], entry[1])
|
|
assert_eq(bytes.size(), expected, "record_bytes() predicts the encoded size")
|
|
var back: Dictionary = NetSnapshot.decode_snapshot(bytes)
|
|
for key: String in header:
|
|
assert_eq(back[key], header[key], key)
|
|
assert_eq(back["removed"], PackedInt32Array([70000, 5]))
|
|
assert_eq((back["records"] as Array).size(), 3)
|
|
var merged: PackedInt32Array = NetSnapshot.merge_record(before, SimEntity.ARCHETYPE_PLAYER, back["records"][0][2], back["records"][0][3])
|
|
assert_eq(merged, after)
|
|
assert_eq(NetSnapshot.merge_record(PackedInt32Array(), SimEntity.ARCHETYPE_PICKUP, back["records"][1][2], back["records"][1][3]), NetSnapshot.record_of(pickup))
|
|
assert_eq(NetSnapshot.merge_record(PackedInt32Array(), SimEntity.ARCHETYPE_PROJECTILE, back["records"][2][2], back["records"][2][3]), NetSnapshot.record_of(shot))
|
|
|
|
|
|
func test_a_partial_record_for_an_unknown_entity_is_refused() -> void:
|
|
assert_eq(NetSnapshot.merge_record(PackedInt32Array(), SimEntity.ARCHETYPE_PLAYER, 0b1, PackedInt32Array([1, 2, 3])), PackedInt32Array())
|
|
var pickup: PackedInt32Array = PackedInt32Array([SimEntity.ARCHETYPE_PICKUP, 1, 2, 3, 4, 5, 6])
|
|
assert_eq(NetSnapshot.merge_record(pickup, SimEntity.ARCHETYPE_PLAYER, 0b1, PackedInt32Array([1, 2, 3])), PackedInt32Array(), "an ID can't change archetype")
|
|
|
|
|
|
func test_truncated_and_corrupt_snapshots_decode_to_nothing_without_errors() -> void:
|
|
var sim: Simulation = Simulation.new(3, SimGround.flat())
|
|
var records: Array = []
|
|
for index: int in 5:
|
|
var player: SimEntity = _player(sim, Vector3(100.0 + index, 0.0, 100.0))
|
|
records.append([player.id, NetSnapshot.full_mask(SimEntity.ARCHETYPE_PLAYER), NetSnapshot.record_of(player)])
|
|
var bytes: PackedByteArray = NetSnapshot.encode_snapshot({"tick": 5, "own_id": 1}, PackedInt32Array([9]), records)
|
|
assert_false(NetSnapshot.decode_snapshot(bytes).is_empty())
|
|
for length: int in bytes.size():
|
|
assert_true(NetSnapshot.decode_snapshot(bytes.slice(0, length)).is_empty(), "cut to %d bytes" % length)
|
|
var longer: PackedByteArray = bytes.duplicate()
|
|
longer.append(0)
|
|
assert_true(NetSnapshot.decode_snapshot(longer).is_empty(), "trailing bytes")
|
|
# Every single-byte corruption either decodes to something or to nothing; none may
|
|
# raise an engine error, which would fail this test.
|
|
var rng: RandomNumberGenerator = RandomNumberGenerator.new()
|
|
rng.seed = 77
|
|
for _round: int in 400:
|
|
var broken: PackedByteArray = bytes.duplicate()
|
|
broken[rng.randi_range(0, broken.size() - 1)] = rng.randi_range(0, 255)
|
|
NetSnapshot.decode_snapshot(broken)
|
|
for _round: int in 200:
|
|
var noise: PackedByteArray = PackedByteArray()
|
|
noise.resize(rng.randi_range(0, 80))
|
|
for index: int in noise.size():
|
|
noise[index] = rng.randi_range(0, 255)
|
|
if noise.size() > 0:
|
|
noise[0] = NetSnapshot.MSG_SNAPSHOT
|
|
NetSnapshot.decode_snapshot(noise)
|
|
NetSnapshot.decode_input(noise)
|
|
NetSnapshot.decode_match(noise)
|
|
|
|
|
|
func test_input_round_trips_and_keeps_the_newest_commands() -> void:
|
|
var commands: Array[PlayerCommand] = []
|
|
for tick: int in range(50, 62):
|
|
commands.append(PlayerCommand.from_input(tick, Vector2(0.5, -1.0), 1.0, 0.2, PlayerCommand.BUTTON_JUMP, 2, 1))
|
|
var bytes: PackedByteArray = NetSnapshot.encode_input(4321, commands)
|
|
var back: Dictionary = NetSnapshot.decode_input(bytes)
|
|
assert_eq(back["ack"], 4321)
|
|
var got: Array[PlayerCommand] = back["commands"]
|
|
assert_eq(got.size(), NetSnapshot.MAX_INPUT_COMMANDS)
|
|
assert_eq(got[0].tick, 62 - NetSnapshot.MAX_INPUT_COMMANDS)
|
|
assert_eq(got[got.size() - 1].tick, 61)
|
|
assert_eq(got[0].encode(), commands[commands.size() - NetSnapshot.MAX_INPUT_COMMANDS].encode())
|
|
assert_true(NetSnapshot.decode_input(bytes.slice(0, bytes.size() - 1)).is_empty())
|
|
var lying: PackedByteArray = bytes.duplicate()
|
|
lying[5] = 200
|
|
assert_true(NetSnapshot.decode_input(lying).is_empty(), "a count the packet doesn't hold")
|
|
assert_eq((NetSnapshot.decode_input(NetSnapshot.encode_input(0, []))["commands"] as Array).size(), 0)
|
|
|
|
|
|
func test_match_notice_round_trips_a_63_bit_seed() -> void:
|
|
var seed_value: int = 0x7FFFFFFFFFFFFFF1
|
|
var back: Dictionary = NetSnapshot.decode_match(NetSnapshot.encode_match(Match.DROP, 7, seed_value))
|
|
assert_eq(back, {"phase": Match.DROP, "index": 7, "seed": seed_value})
|
|
assert_true(NetSnapshot.decode_match(NetSnapshot.encode_match(99, 7, 1)).is_empty(), "an unknown phase")
|
|
|
|
|
|
func test_the_own_block_round_trips_exactly() -> void:
|
|
var sim: Simulation = Simulation.new(3, SimGround.flat())
|
|
var player: SimEntity = _player(sim, Vector3(100.123456, 7.654321, 900.000123))
|
|
player.velocity = Vector3(-3.3333333, 0.1, 6.5)
|
|
player.stamina_ticks = 1234
|
|
player.swimming = true
|
|
player.on_ground = false
|
|
player.drop_state = Drop.GLIDING
|
|
var own: Dictionary = NetSnapshot.self_of(player, 2.71828, 0b101010101)
|
|
var record: PackedInt32Array = NetSnapshot.record_of(player)
|
|
var header: Dictionary = {"tick": 9, "sim_tick": 8, "command_tick": 11, "own_id": player.id, "self": own}
|
|
var bytes: PackedByteArray = NetSnapshot.encode_snapshot(header, PackedInt32Array(), [[player.id, NetSnapshot.full_mask(SimEntity.ARCHETYPE_PLAYER), record]])
|
|
var plain: PackedByteArray = NetSnapshot.encode_snapshot({"tick": 9, "sim_tick": 8, "own_id": player.id}, PackedInt32Array(), [[player.id, NetSnapshot.full_mask(SimEntity.ARCHETYPE_PLAYER), record]])
|
|
assert_eq(bytes.size() - plain.size(), NetSnapshot.SELF_BYTES)
|
|
var back: Dictionary = NetSnapshot.decode_snapshot(bytes)
|
|
assert_eq(back["command_tick"], 11)
|
|
assert_eq(NetSnapshot.decode_snapshot(plain)["command_tick"], -1, "no command received yet")
|
|
assert_true((NetSnapshot.decode_snapshot(plain)["self"] as Dictionary).is_empty())
|
|
# Not near: the same, to the bit, which is what lets a prediction match the server.
|
|
var copy: SimEntity = SimEntity.new(1, SimEntity.ARCHETYPE_PLAYER)
|
|
NetSnapshot.apply_self(copy, back["self"])
|
|
assert_eq(copy.position, player.position)
|
|
assert_eq(copy.velocity, player.velocity)
|
|
assert_eq(copy.stamina_ticks, 1234)
|
|
assert_true(copy.swimming and not copy.on_ground)
|
|
assert_eq(copy.drop_state, Drop.GLIDING)
|
|
assert_false(copy.downed)
|
|
assert_eq(back["self"]["water"], own["water"])
|
|
assert_eq(back["self"]["water_mask"], 0b101010101)
|
|
for length: int in bytes.size():
|
|
assert_true(NetSnapshot.decode_snapshot(bytes.slice(0, length)).is_empty(), "cut to %d bytes" % length)
|
|
# A position that isn't a number is refused rather than handed to the movement code.
|
|
var poisoned: PackedByteArray = bytes.duplicate()
|
|
var at: int = NetSnapshot.HEADER_BYTES + NetSnapshot.varint_bytes(player.id) + 5
|
|
poisoned.encode_float(at, NAN)
|
|
assert_true(NetSnapshot.decode_snapshot(poisoned).is_empty(), "a NaN position")
|
|
poisoned.encode_float(at, INF)
|
|
assert_true(NetSnapshot.decode_snapshot(poisoned).is_empty(), "an infinite position")
|
|
|
|
|
|
func test_downed_travels_in_the_record_and_the_own_block() -> void:
|
|
var sim: Simulation = Simulation.new(3, SimGround.flat())
|
|
var player: SimEntity = _player(sim, Vector3(100.0, 0.0, 100.0))
|
|
player.downed = true
|
|
player.crouching = true
|
|
player.reload_ticks = 3
|
|
var record: PackedInt32Array = NetSnapshot.record_of(player)
|
|
assert_true(record[NetSnapshot.R_FLAGS] & NetSnapshot.FLAG_DOWNED != 0)
|
|
var own: Dictionary = NetSnapshot.self_of(player, 0.0, 0)
|
|
var bytes: PackedByteArray = NetSnapshot.encode_snapshot({"tick": 2, "sim_tick": 2, "own_id": player.id, "self": own}, PackedInt32Array(), [[player.id, NetSnapshot.full_mask(SimEntity.ARCHETYPE_PLAYER), record]])
|
|
var back: Dictionary = NetSnapshot.decode_snapshot(bytes)
|
|
assert_false(back.is_empty())
|
|
var merged: PackedInt32Array = NetSnapshot.merge_record(PackedInt32Array(), SimEntity.ARCHETYPE_PLAYER, back["records"][0][2], back["records"][0][3])
|
|
assert_eq(merged, record)
|
|
var flags: int = merged[NetSnapshot.R_FLAGS]
|
|
assert_true(flags & NetSnapshot.FLAG_DOWNED != 0, "in the record")
|
|
assert_true(flags & NetSnapshot.FLAG_RELOADING != 0, "the low byte is still there")
|
|
var copy: SimEntity = SimEntity.new(1, SimEntity.ARCHETYPE_PLAYER)
|
|
NetSnapshot.apply_self(copy, back["self"])
|
|
assert_true(copy.downed, "in the own block, so prediction crawls too")
|