Files
tidewall/test/server/test_hostile_client.gd
claudeandClaude Opus 5.5 aa797580a7 #72: The packet ship, the lifeline mortar and the gull-kite
Eric chose option B on #72. The drop is now the GDD's launch:

- A packet ship sails a seeded straight line past the island, offshore,
  as close in as it can while keeping 45 m of open water from any land
  (eight-way probes; up to 32 headings, then the four world sides).
- Jump fires the lifeline mortar along the look heading. How high the
  player aims sets the charge (-10 to 45 degrees: 16 to 110 m/s over
  the ground; every shot climbs at 75 m/s). The climb can't be steered
  and the kite can't open until the arc tops out. Riders still aboard at
  the end are fired towards the middle of the island.
- Drop.reach() mirrors the fall for both ways down (kite at the top, or
  a fall with the kite opening by itself); bots, the soak and autoplay
  clients and the tutorial pilot aim with Drop.aim_charge().
- Bots fire at their landing spot once abeam of it, when in easy reach
  at their own staggered moment, or just before the route ends, and open
  the kite early only when the spot is beyond the rest of a fall.
- Art: VesselModels.ship() (two-masted packet, tanned square sails, a
  salt-white boot-top, a bowsprit and the mortar on its bed, mirrored to
  face the island), the figure's gull-kite (figure.py), and a lifeline
  cord from the muzzle to each player still climbing.
- Renamed barge to ship and wing-sail to gull-kite throughout code,
  tests, captures, docs and the tutorial text. make match now defaults to
  seed 2, where the scripted player still harvests and builds.

Closes #72

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 12:49:21 -05:00

260 lines
12 KiB
GDScript

extends TestCase
## Issue N9: a hostile client tries the usual cheats and every one fails. Its packets
## are crafted byte by byte, outside anything the real client would send, and go in
## through NetGame.take_input(), the same door a network packet uses, into a real
## match on a real island. The server trusts nothing in them but intent.
const HOSTILE: int = 1
const VICTIM: int = 2
var loop: ServerLoop
var game: NetGame
var rng: RandomNumberGenerator
func before_each() -> void:
var rules: MatchRules = MatchRules.immediate()
rules.max_players = 2
rules.min_players = 1
rules.fill_with_bots = false
loop = ServerLoop.new(77, 2, 0, rules)
game = NetGame.new(loop, NetServer.new())
game.adopt(HOSTILE)
game.adopt(VICTIM)
assert_true(loop.match_flow.in_match())
rng = RandomNumberGenerator.new()
rng.seed = 1999
# Both off the ship and standing on level dry ground, as if they had landed.
var spot: Vector3 = _level_spot()
_stand(HOSTILE, spot)
_stand(VICTIM, spot + Vector3(0.0, 0.0, 6.0))
func _player(handle: int) -> SimEntity:
return loop.sim.entities.find(int(loop.match_flow.entity_of[handle]))
func _stand(handle: int, at: Vector3) -> void:
var player: SimEntity = _player(handle)
player.drop_state = Drop.NONE
player.position = at
player.velocity = Vector3.ZERO
player.on_ground = true
## A dry, level point well inland.
func _level_spot() -> Vector3:
var ground: SimGround = loop.sim.ground
var centre: float = Tuning.WORLD_SIZE_METRES * 0.5
for ring: int in range(0, 400, 8):
for step: int in 16:
var angle: float = TAU * step / 16.0
var x: float = centre + cos(angle) * ring
var z: float = centre + sin(angle) * ring
var height: float = ground.terrain_height(x, z)
if height < Tuning.ISLAND_BEACH_TOP + 6.0:
continue
var flat: bool = true
for offset: Vector2 in [Vector2(8, 0), Vector2(-8, 0), Vector2(0, 8), Vector2(0, -8), Vector2(0, 14)]:
if absf(ground.terrain_height(x + offset.x, z + offset.y) - height) > 0.6:
flat = false
if flat:
return Vector3(x, height, z)
fail("no level ground on this island")
return Vector3.ZERO
## A command's 15 bytes with any value in any field, past what PlayerCommand.encode()
## would ever produce.
func _raw_command(tick: int, move_x: int, move_y: int, yaw: int, pitch: int, buttons: int, selection: int, material: int, view_lag: int) -> PackedByteArray:
var bytes: PackedByteArray = PackedByteArray()
bytes.resize(PlayerCommand.ENCODED_SIZE)
bytes.encode_u32(0, tick & 0xFFFFFFFF)
bytes.encode_s8(4, move_x)
bytes.encode_s8(5, move_y)
bytes.encode_u16(6, yaw & 0xFFFF)
bytes.encode_s16(8, pitch)
bytes.encode_u16(10, buttons & 0xFFFF)
bytes.encode_u8(12, selection & 0xFF)
bytes.encode_u8(13, material & 0xFF)
bytes.encode_u8(14, view_lag & 0xFF)
return bytes
func _packet(commands: Array[PackedByteArray]) -> PackedByteArray:
var bytes: PackedByteArray = PackedByteArray([NetSnapshot.MSG_INPUT, 0, 0, 0, 0, commands.size()])
for command: PackedByteArray in commands:
bytes.append_array(command)
return bytes
## Sends the hostile packet for this tick, then runs it.
func _tick(commands: Array[PackedByteArray]) -> void:
game.take_input(HOSTILE, _packet(commands))
loop.run_tick()
game.after_tick()
func _horizontal(a: Vector3, b: Vector3) -> float:
return Vector2(a.x - b.x, a.z - b.z).length()
func test_speed_and_teleport_cheats_move_no_faster_than_sprinting() -> void:
var player: SimEntity = _player(HOSTILE)
var limit: float = Tuning.SPRINT_SPEED / Tuning.TICK_RATE_HZ + 0.001
var start: Vector3 = player.position
var fastest: float = 0.0
var ticks: int = 150
for _index: int in ticks:
var now: int = loop.sim.tick
var commands: Array[PackedByteArray] = []
# The most extreme axes the bytes allow, sprint and jump, the same tick sent
# several times with different contents, and every tick of the lead window
# filled at once, as if the client could play ahead of the server.
for copy: int in 3:
commands.append(_raw_command(now + 1, -128, -128, 8192, 0, PlayerCommand.BUTTON_SPRINT | PlayerCommand.BUTTON_JUMP | 0xFE00, 0, 0, 255))
for ahead: int in range(2, NetSnapshot.MAX_INPUT_COMMANDS - 4):
commands.append(_raw_command(now + ahead, -128 if ahead % 2 == 0 else 127, -128, 8192 * ahead, 0, 0xFFFF, 255, 255, 255))
# Ticks the server can never take: long past, far future, and the largest.
commands.append(_raw_command(now - 500, 127, 127, 0, 0, 0xFFFF, 0, 0, 0))
commands.append(_raw_command(now + 10000, 127, 127, 0, 0, 0xFFFF, 0, 0, 0))
commands.append(_raw_command(0xFFFFFFFF, 127, 127, 0, 0, 0xFFFF, 0, 0, 0))
assert_eq(commands.size(), NetSnapshot.MAX_INPUT_COMMANDS)
var before: Vector3 = player.position
_tick(commands)
fastest = maxf(fastest, _horizontal(player.position, before))
assert_true(fastest <= limit, "fastest step %.4f m against a limit of %.4f m" % [fastest, limit])
assert_true(_horizontal(player.position, start) <= limit * ticks)
assert_true(_horizontal(player.position, start) > 1.0, "the cheater still moves: commands weren't simply refused")
func test_a_packet_with_too_many_commands_is_refused_whole() -> void:
var commands: Array[PackedByteArray] = []
for ahead: int in NetSnapshot.MAX_INPUT_COMMANDS + 1:
commands.append(_raw_command(loop.sim.tick + 1 + ahead, 127, 127, 0, 0, 0, 0, 0, 0))
var bad: int = game.bad_inputs
_tick(commands)
assert_eq(game.bad_inputs, bad + 1)
func test_a_far_future_command_does_not_lock_out_the_real_ones() -> void:
var player: SimEntity = _player(HOSTILE)
var start: Vector3 = player.position
_tick([_raw_command(0xFFFFFFFF, 0, 0, 0, 0, 0, 0, 0, 0)] as Array[PackedByteArray])
for _index: int in 30:
_tick([_raw_command(loop.sim.tick + 1, 0, 127, 0, 0, 0, 0, 0, 0)] as Array[PackedByteArray])
assert_true(_horizontal(player.position, start) > 1.0, "commands after a bogus far-future one are still taken")
func test_rapid_fire_is_held_to_the_weapons_rate() -> void:
var player: SimEntity = _player(HOSTILE)
var code: int = ItemCatalog.code_of("dock_carbine")
Inventory.give(player, code, 1)
Inventory.give(player, ItemCatalog.get_def(code).ammo_code, 999)
var interval: int = ItemCatalog.get_def(code).fire_interval_ticks()
var shots: int = 0
var ticks: int = 240
for index: int in ticks:
var now: int = loop.sim.tick
# Fire pressed, released and pressed again within one tick's packet, fire on
# every tick of the lead window, and a slot change every tick to try to skip
# the cooldown.
var commands: Array[PackedByteArray] = []
for ahead: int in range(1, mini(12, NetSnapshot.MAX_INPUT_COMMANDS + 1)):
var buttons: int = PlayerCommand.BUTTON_FIRE if (index + ahead) % 2 == 0 else PlayerCommand.BUTTON_FIRE | PlayerCommand.BUTTON_AIM
commands.append(_raw_command(now + ahead, 0, 0, 0, 0, buttons, 1 + (index % 2), 0, 255))
_tick(commands)
for event: Dictionary in loop.sim.events:
if event["type"] == "shot" and event["player"] == player.id:
shots += 1
var most: int = ceili(float(ticks) / interval) + 1
assert_true(shots <= most, "%d shots in %d ticks; the weapon allows %d" % [shots, ticks, most])
func test_building_out_of_range_or_without_materials_fails() -> void:
var player: SimEntity = _player(HOSTILE)
for code: int in Materials.NAMES.size():
player.materials[code] = 0
var kinds: Array[int] = [StructureSet.WALL, StructureSet.FLOOR, StructureSet.RAMP, StructureSet.ROOF, StructureSet.BREAKWATER]
# Without materials, nothing at all, whatever is claimed.
for index: int in 60:
_tick([_raw_command(loop.sim.tick + 1, 0, 0, rng.randi() & 0xFFFF, rng.randi_range(-32768, 32767), PlayerCommand.BUTTON_BUILD | PlayerCommand.BUTTON_FIRE, kinds[index % kinds.size()], rng.randi_range(0, 255), 255)] as Array[PackedByteArray])
assert_eq(loop.sim.structures.count(), 0, "nothing is built on credit")
# With materials, every piece placed is within reach, whatever the aim, the kind
# and material bytes, and the claimed lag.
for code: int in Materials.NAMES.size():
player.materials[code] = 999
var placed: int = 0
var farthest: float = 0.0
for index: int in 300:
var eye: Vector3 = Harvest.eye(player)
# Half the time a real kind and material, so pieces do get placed.
var honest: bool = index % 2 == 0
var kind: int = kinds[rng.randi_range(0, kinds.size() - 1)] if honest else rng.randi_range(0, 255)
var material: int = rng.randi_range(0, Materials.NAMES.size() - 1) if honest else rng.randi_range(0, 255)
_tick([_raw_command(loop.sim.tick + 1, rng.randi_range(-128, 127), rng.randi_range(-128, 127), rng.randi() & 0xFFFF,
rng.randi_range(-32768, 32767), PlayerCommand.BUTTON_BUILD | PlayerCommand.BUTTON_FIRE, kind, material, 255)] as Array[PackedByteArray])
for event: Dictionary in loop.sim.events:
if event["type"] != "piece_placed":
continue
placed += 1
assert_true(int(event["material"]) < Materials.NAMES.size())
var piece: StructureSet.Piece = loop.sim.structures.find(int(event["piece"]))
var nearest: float = INF
for box: AABB in piece.boxes:
var closest: Vector3 = eye.clamp(box.position, box.end)
nearest = minf(nearest, closest.distance_to(eye))
farthest = maxf(farthest, nearest)
assert_true(placed > 0, "honest-looking build commands among the noise still build")
assert_true(farthest <= Tuning.BUILD_RANGE + 0.01, "a piece %.2f m away; reach is %.2f m" % [farthest, Tuning.BUILD_RANGE])
## Everything of every kind, carried and on the ground. Rounds in magazines aren't
## counted; nothing here fires or reloads.
func _all_items() -> Dictionary:
var totals: Dictionary = {}
var sim: Simulation = loop.sim
for handle: int in [HOSTILE, VICTIM]:
var player: SimEntity = _player(handle)
for slot: int in Inventory.slot_count():
if player.slot_items[slot] != Inventory.EMPTY:
totals[player.slot_items[slot]] = int(totals.get(player.slot_items[slot], 0)) + player.slot_counts[slot]
for index: int in player.ammo.size():
var ammo_code: int = Inventory.ammo_code(index)
totals[ammo_code] = int(totals.get(ammo_code, 0)) + player.ammo[index]
for pickup_id: int in sim.pickups:
var pickup: SimEntity = sim.entities.find(pickup_id)
totals[pickup.item] = int(totals.get(pickup.item, 0)) + pickup.item_count
for code: int in totals.keys():
if totals[code] == 0:
totals.erase(code)
return totals
func test_item_duplication_tricks_create_nothing() -> void:
var player: SimEntity = _player(HOSTILE)
# A few things to juggle, at the cheater's feet and in hand.
for id: String in ["dock_carbine", "signal_revolver"]:
Inventory.spawn_pickup(loop.sim, player.position, ItemCatalog.code_of(id), 1)
Inventory.give(player, ItemCatalog.code_of("dock_carbine"), 1)
var before: Dictionary = _all_items()
var tricks: Array[int] = [
PlayerCommand.BUTTON_INTERACT, PlayerCommand.BUTTON_DROP, PlayerCommand.BUTTON_INTERACT | PlayerCommand.BUTTON_DROP,
PlayerCommand.BUTTON_DROP | PlayerCommand.BUTTON_BUILD, PlayerCommand.BUTTON_INTERACT | PlayerCommand.BUTTON_CROUCH, 0,
]
for index: int in 600:
var now: int = loop.sim.tick
var commands: Array[PackedByteArray] = []
# The same tick claimed over and over with different buttons and slots, and
# selections outside the inventory.
for copy: int in rng.randi_range(1, 6):
var buttons: int = tricks[rng.randi_range(0, tricks.size() - 1)]
var ahead: int = 1 if copy < 3 else rng.randi_range(1, 4)
commands.append(_raw_command(now + ahead, rng.randi_range(-4, 4), rng.randi_range(-4, 4), rng.randi() & 0xFFFF, 0, buttons, rng.randi_range(0, 255), 0, rng.randi_range(0, 255)))
_tick(commands)
# Lying in the same place keeps things in reach.
if _horizontal(player.position, _player(VICTIM).position) > 20.0:
player.position = _player(VICTIM).position - Vector3(0.0, 0.0, 6.0)
assert_eq(_all_items(), before, "items were neither made nor lost")