N10: Playable network client

The client program now turns a connection into a match someone can play.

- ClientSession: a ClientGame, the keyboard and mouse as commands
  (ClientInput), and a MatchView of the client's own copy of the world.
- ClientMirror writes what the client is showing into that world every
  frame: other players from the recent past, its own player where it was
  predicted, items, the barge, the clock and the sea. The existing views
  draw it unchanged.
- LocalServer: offline play is the same ServerLoop and NetGame in the same
  process, with packets handed across in memory, so there is one path.
- main.gd: --connect=HOST[:PORT] joins a server, otherwise an offline
  match; --autoplay and --client-seconds=N for scripts and checks.
- The camera aboard the barge follows the player's own place on the deck.

Tests drive a scripted client through a whole match on a real server over
loopback UDP, lobby to results, and through an offline match. `make
client-check` does it with two real processes, and `make client-captures`
renders what the client sees.

Closes #77

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-12 14:50:52 -05:00
co-authored by Claude Opus 5.5
parent 6b21e9d4f1
commit 9a36ae8615
25 changed files with 1089 additions and 13 deletions
+228
View File
@@ -0,0 +1,228 @@
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")
+1
View File
@@ -0,0 +1 @@
uid://etxgijcgqvye