The soak's drops under loss came from stalls: the server's island (#79) and each client process making islands on its main thread fed ENet second-long round-trip samples, its retransmission timer grew, and two losses of one reliable message in the busy drop that followed reached the 15 s timeout. - ClientGame.build_in_background makes a new match's island on a WorkerThreadPool task and holds the packets that arrive meanwhile, then takes them in order. The networked client and the soak's clients use it; the soak's own one-island-a-frame holding is gone. - NetServer.close(grace_msec) sends the shutdown notice reliably and services the socket while clients acknowledge it. The headless server waits up to 2 s. A notice sent once was lost under 2% loss, and that client timed out instead of hearing the server stop. - Tests: background island holding and ordering, freeing mid-build, a graceful shutdown reaching four clients behind 50% loss (it fails with the old one-shot notice), and the scripted UDP match and client capture wait for the client's island the way a real 20 s lobby would. The soak at 2% loss and +/-20 ms now keeps all 24 clients for both matches, with 0 of 3,758 world hashes differing and every client told of the stop. It still fails on client memory growth between matches in two of three processes (17 and 20 MB), which is not yet explained, so #39 stays open. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
248 lines
11 KiB
GDScript
248 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()
|
|
if session.game.building_world():
|
|
# The island is made in the background. A real lobby lasts 20 s, far
|
|
# longer than that takes; this one is 10 ticks, so the server waits.
|
|
session.pump(DT)
|
|
OS.delay_msec(5)
|
|
continue
|
|
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())
|