- LAN discovery: a listening server answers QUERY packets on its game port plus one (ServerBeacon, off with --no-lan). ServerBrowser scans eight game ports from 24650 by broadcast. - A self-hostable list server: --list-server [--port=N] (ListServer, default UDP 24660). Game servers register with --list=HOST[:PORT] and --name=NAME; they are listed under their source address only after echoing a CHALLENGE token. Entries expire after 45 s, 8 per address, 256 in all; every source is rate-limited (SourceLimiter). - NetDiscovery messages: every QUERY is padded to 512 bytes and no answer is bigger, so neither service amplifies spoofed requests. - tidewall --browse [--list=...] [--lan-target=IP] [--lan-port=N] prints the servers found as JSON until menus (A10) show them. - People who connect mid-match or during results watch a living player (Match.watch) and take places ahead of bots in the next lobby, instead of being told the server is full. Bots fill only the places left when the match starts. - Tests: codec round trips, size limits and a 40,000-message fuzz; list server with fake servers (challenge, stolen and wrong tokens, renewal, expiry, caps, flood); LAN scan over loopback; watchers over UDP; lobby backfill. make discovery-check runs it all as real processes. Closes #37 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
242 lines
11 KiB
GDScript
242 lines
11 KiB
GDScript
extends TestCase
|
|
|
|
## Issue N10: the client program's session. Offline it plays against a server in the
|
|
## same process; on the network, against a real server over loopback UDP. Both go
|
|
## through the same ClientGame, and the same MatchView draws the client's own copy of
|
|
## the world.
|
|
|
|
const HOST: String = "127.0.0.1"
|
|
const DT: float = 1.0 / Tuning.TICK_RATE_HZ
|
|
const FRAME: float = 1.0 / 60.0
|
|
|
|
var session: ClientSession
|
|
var net: NetServer
|
|
|
|
|
|
func before_each() -> void:
|
|
session = ClientSession.new()
|
|
session.input.autoplay = true
|
|
net = null
|
|
|
|
|
|
func after_each() -> void:
|
|
session.leave()
|
|
session.free()
|
|
if net != null:
|
|
net.close()
|
|
|
|
|
|
func _own() -> SimEntity:
|
|
return session.game.prediction.player
|
|
|
|
|
|
func _agrees(sim: Simulation, message: String) -> void:
|
|
session.game.replica.sync(sim.tick)
|
|
assert_eq(NetWorld.world_hash(session.game.world), NetWorld.world_hash(sim), message)
|
|
|
|
|
|
func test_offline_play_goes_through_the_same_client_against_a_local_server() -> void:
|
|
session.play_offline(2, 3)
|
|
assert_null(session.link)
|
|
assert_null(session.game.net, "no socket: the packets are handed across")
|
|
var server: ServerLoop = session.local.loop
|
|
var seen_barge: bool = false
|
|
var most_figures: int = 0
|
|
var landed_frame: int = -1
|
|
for frame: int in 60 * 150:
|
|
session.pump(FRAME)
|
|
if session.view != null:
|
|
most_figures = maxi(most_figures, session.view.entities.figure_count())
|
|
if session.view.entities.barge().visible and session.mirror.own_id != 0:
|
|
if not seen_barge:
|
|
seen_barge = true
|
|
var figure: Node3D = session.view.entities.figure_of(session.mirror.own_id)
|
|
assert_not_null(figure, "the client's own player is drawn")
|
|
assert_true(figure.position.distance_to(session.view.entities.barge().position) < 6.0, "on the barge's deck")
|
|
assert_true(session.view.camera.position.distance_to(figure.position) < 9.0, "the camera is on its shoulder")
|
|
if landed_frame < 0 and session.game.playing() and _own().drop_state == Drop.NONE:
|
|
landed_frame = frame
|
|
if landed_frame >= 0 and frame > landed_frame + 60 * 8:
|
|
break
|
|
assert_true(seen_barge)
|
|
assert_true(landed_frame > 0, "the scripted player leapt and came down")
|
|
assert_eq(session.phases[0], Match.DROP)
|
|
assert_eq(most_figures, 4, "all four players were drawn at once")
|
|
assert_true(session.frames_playing > 60 * 20)
|
|
var flow: Match = server.match_flow
|
|
var mine: SimEntity = server.sim.entities.find(flow.entity_of[LocalServer.HANDLE])
|
|
assert_false(mine.eliminated)
|
|
assert_eq(session.mirror.own_id, mine.id)
|
|
assert_eq(session.status_text(), "", "nothing to say while playing")
|
|
var figure: Node3D = session.view.entities.figure_of(mine.id)
|
|
assert_true(figure.position.distance_to(mine.position) < 1.5, "drawn %.2f m from where the server has it" % figure.position.distance_to(mine.position))
|
|
var came_down: Vector3 = mine.position
|
|
assert_true(session.view.camera.position.distance_to(figure.position) < 9.0)
|
|
assert_eq(session.view.sim, session.game.world, "the view draws the client's own copy of the world")
|
|
assert_ne(session.game.world, server.sim)
|
|
assert_eq(session.view.entities.get_node("Chests").multimesh.instance_count, server.sim.loot.chest_positions.size())
|
|
assert_near(session.game.world.sea_level, server.sim.sea_level, 0.05)
|
|
_agrees(server.sim, "on the ground")
|
|
assert_eq(session.game.bad_packets, 0)
|
|
assert_eq(session.local.game.bad_inputs, 0)
|
|
assert_true(session.game.prediction.max_correction < 1.0, "largest correction %.2f m" % session.game.prediction.max_correction)
|
|
# On seed 2 a bot finds the scripted player soon after. From then on the client
|
|
# watches whoever it is given to watch.
|
|
for frame: int in 60 * 60:
|
|
session.pump(FRAME)
|
|
if mine.eliminated and session.mirror.watched_id != 0 and session.mirror.watched_id != mine.id:
|
|
break
|
|
assert_true(came_down.distance_to(mine.position) > 3.0, "it walked: the server took its commands")
|
|
assert_true(mine.eliminated, "the scripted player fell")
|
|
assert_false(session.game.playing())
|
|
assert_eq(session.mirror.own_id, 0)
|
|
assert_eq(session.status_text(), "Watching")
|
|
var watched: Node3D = session.view.entities.figure_of(session.mirror.watched_id)
|
|
assert_not_null(watched)
|
|
assert_true(session.view.camera.position.distance_to(watched.position) < 9.0, "the camera moved to the player being watched")
|
|
_agrees(server.sim, "while watching")
|
|
|
|
|
|
func test_a_scripted_client_plays_a_whole_match_on_a_real_server() -> void:
|
|
var rules: MatchRules = MatchRules.new()
|
|
rules.max_players = 4
|
|
rules.min_players = 1
|
|
rules.lobby_ticks = 10
|
|
rules.countdown_ticks = 10
|
|
rules.results_ticks = 90
|
|
var loop: ServerLoop = ServerLoop.new(41, 0, 3, rules)
|
|
net = NetServer.new()
|
|
assert_eq(net.listen(0, HOST), OK)
|
|
var game: NetGame = NetGame.new(loop, net)
|
|
assert_eq(session.connect_to(HOST, net.port(), "Mara"), OK)
|
|
assert_true(session.status_text().length() > 0, "it says it is connecting")
|
|
var flow: Match = loop.match_flow
|
|
var started: int = Time.get_ticks_msec()
|
|
var spectated: int = 0
|
|
var checked: int = 0
|
|
# A server tick and a client frame of the same length each round, so the clocks
|
|
# agree however fast this machine is.
|
|
while Time.get_ticks_msec() - started < 240000 and not session.phases.has(Match.RESULTS):
|
|
game.poll()
|
|
loop.run_tick()
|
|
game.after_tick()
|
|
session.pump(DT)
|
|
if flow.in_match() and not session.game.playing() and session.mirror.watched_id != 0:
|
|
spectated += 1
|
|
if flow.in_match() and loop.ticks % 300 == 0 and session.game.replica.seq == game.world.seq:
|
|
checked += 1
|
|
_agrees(loop.sim, "at tick %d" % loop.sim.tick)
|
|
assert_eq(session.phases, [Match.LOBBY, Match.COUNTDOWN, Match.DROP, Match.PLAY, Match.RESULTS] as Array[int], "lobby to results")
|
|
assert_eq(flow.phase, Match.RESULTS)
|
|
assert_eq(session.link.state, NetClient.JOINED)
|
|
assert_eq(session.game.match_index, 0)
|
|
assert_true(session.frames_playing > 300, "it played for %d ticks" % session.frames_playing)
|
|
assert_true(checked > 0, "the worlds were compared %d times" % checked)
|
|
assert_not_null(session.view)
|
|
assert_eq(session.view.sim.island.heightmap_hash(), loop.sim.island.heightmap_hash())
|
|
# Results: the camera is on whoever is left, or the client itself if it won.
|
|
assert_true(session.mirror.watched_id != 0, "someone to watch at the end")
|
|
assert_not_null(session.view.entities.figure_of(session.mirror.watched_id))
|
|
var summary: Array[Dictionary] = flow.summary()
|
|
assert_eq(summary.size(), 4)
|
|
assert_eq(session.game.bad_packets, 0)
|
|
assert_eq(game.bad_inputs, 0)
|
|
assert_eq(session.game.replica.gaps, 0)
|
|
print("N10 match over UDP: %d server ticks, client played %d and watched %d, %d world checks, %d corrections (largest %.2f m), %d WORLD messages" % [
|
|
loop.ticks, session.frames_playing, spectated, checked, session.game.prediction.mispredictions,
|
|
session.game.prediction.max_correction, session.game.replica.applied,
|
|
])
|
|
|
|
|
|
func test_keys_and_mouse_become_commands() -> void:
|
|
var input: ClientInput = ClientInput.new()
|
|
input.move = Vector2(1.0, -1.0)
|
|
input.buttons = PlayerCommand.BUTTON_FIRE | PlayerCommand.BUTTON_SPRINT
|
|
input.press(KEY_3)
|
|
var command: PlayerCommand = input.command(77)
|
|
assert_eq(command.tick, 77)
|
|
assert_eq(command.move_x, PlayerCommand.AXIS_MAX)
|
|
assert_eq(command.move_y, -PlayerCommand.AXIS_MAX)
|
|
assert_eq(command.selection, 2, "3 is the second slot: 1 is the boathook")
|
|
assert_true(command.is_pressed(PlayerCommand.BUTTON_FIRE) and command.is_pressed(PlayerCommand.BUTTON_SPRINT))
|
|
assert_false(command.is_pressed(PlayerCommand.BUTTON_BUILD))
|
|
input.press(KEY_1)
|
|
assert_eq(input.command(78).selection, Simulation.BOATHOOK_SLOT)
|
|
input.press(KEY_9)
|
|
assert_eq(input.slot, 0, "there is no eighth slot")
|
|
# Build mode: the number row picks the piece, Tab the material, fire places.
|
|
input.press(KEY_TAB)
|
|
assert_eq(input.material, Materials.DRIFTWOOD, "Tab does nothing outside build mode")
|
|
input.press(KEY_B)
|
|
input.press(KEY_5)
|
|
input.press(KEY_TAB)
|
|
command = input.command(79)
|
|
assert_true(command.is_pressed(PlayerCommand.BUTTON_BUILD))
|
|
assert_eq(command.selection, StructureSet.BREAKWATER)
|
|
assert_eq(command.material, Materials.STONE)
|
|
input.press(KEY_7)
|
|
assert_eq(input.build_kind, StructureSet.BREAKWATER, "there is no seventh piece")
|
|
input.press(KEY_B)
|
|
assert_eq(input.command(80).selection, 0, "back to what was held")
|
|
# The mouse turns the look: right is clockwise seen from above, up looks up.
|
|
input.turn(Vector2(100.0, -40.0))
|
|
assert_true(input.yaw > PI, "turned right from north: %.2f" % input.yaw)
|
|
assert_true(input.pitch > 0.0)
|
|
command = input.command(81)
|
|
assert_eq(command.yaw, PlayerCommand.from_input(0, Vector2.ZERO, input.yaw, input.pitch).yaw)
|
|
# Aiming slows the look, and build mode doesn't aim.
|
|
input.buttons = PlayerCommand.BUTTON_AIM
|
|
assert_true(input.aiming())
|
|
input.press(KEY_B)
|
|
assert_false(input.aiming())
|
|
|
|
|
|
func test_the_command_line_picks_the_mode() -> void:
|
|
var offline: ClientConfig = ClientConfig.parse(PackedStringArray([]))
|
|
assert_true(offline.is_valid())
|
|
assert_false(offline.asked)
|
|
assert_eq(offline.host, "")
|
|
assert_eq(offline.bots, Tuning.SOLO_PLAYERS - 1)
|
|
var join: ClientConfig = ClientConfig.parse(PackedStringArray(["--connect=play.example:7000", "--name=Mara", "--autoplay", "--client-seconds=2.5"]))
|
|
assert_true(join.is_valid(), str(join.errors))
|
|
assert_true(join.asked)
|
|
assert_eq(join.host, "play.example")
|
|
assert_eq(join.port, 7000)
|
|
assert_eq(join.player_name, "Mara")
|
|
assert_true(join.autoplay)
|
|
assert_near(join.seconds, 2.5, 0.001)
|
|
assert_eq(ClientConfig.parse(PackedStringArray(["--connect=192.0.2.7"])).port, ServerConfig.DEFAULT_PORT)
|
|
var seeded: ClientConfig = ClientConfig.parse(PackedStringArray(["--offline", "--seed=9", "--bots=5"]))
|
|
assert_true(seeded.asked and seeded.has_seed)
|
|
assert_eq(seeded.match_seed, 9)
|
|
assert_eq(seeded.bots, 5)
|
|
for bad: String in ["--connect=", "--connect=host:0", "--connect=host:port", "--seed=x", "--bots=99", "--client-seconds=0", "--nonsense"]:
|
|
assert_false(ClientConfig.parse(PackedStringArray([bad])).is_valid(), bad)
|
|
|
|
|
|
func test_restored_entities_keep_their_ids_and_their_order() -> void:
|
|
var registry: EntityRegistry = EntityRegistry.new()
|
|
registry.restore(7, SimEntity.ARCHETYPE_PLAYER)
|
|
registry.restore(3, SimEntity.ARCHETYPE_PICKUP)
|
|
registry.restore(12, SimEntity.ARCHETYPE_PLAYER)
|
|
registry.restore(5, SimEntity.ARCHETYPE_PROJECTILE)
|
|
var ids: Array[int] = []
|
|
for entity: SimEntity in registry.entities():
|
|
ids.append(entity.id)
|
|
assert_eq(ids, [3, 5, 7, 12] as Array[int])
|
|
assert_eq(registry.find(3).archetype, SimEntity.ARCHETYPE_PICKUP)
|
|
assert_eq(registry.create(SimEntity.ARCHETYPE_PLAYER).id, 13, "new IDs carry on past the highest")
|
|
|
|
|
|
func test_browse_options() -> void:
|
|
var browse: ClientConfig = ClientConfig.parse(PackedStringArray(["--browse", "--list=192.0.2.4", "--lan-target=127.0.0.1", "--lan-port=30000", "--client-seconds=1"]))
|
|
assert_true(browse.is_valid(), str(browse.errors))
|
|
assert_true(browse.browse)
|
|
assert_true(browse.asked)
|
|
assert_eq(browse.lists, [{"host": "192.0.2.4", "port": NetDiscovery.DEFAULT_LIST_PORT}] as Array[Dictionary])
|
|
assert_eq(browse.lan_targets, ["127.0.0.1"] as Array[String])
|
|
assert_eq(browse.lan_port, 30000)
|
|
assert_eq(ClientConfig.parse(PackedStringArray(["--browse"])).lan_port, ServerConfig.DEFAULT_PORT)
|
|
assert_false(ClientConfig.parse(PackedStringArray(["--browse", "--lan-target=somewhere"])).is_valid())
|
|
assert_false(ClientConfig.parse(PackedStringArray(["--browse", "--connect=192.0.2.7"])).is_valid())
|