woofmeow/straywild
woofmeow/straywild
3
5
Fork 2
Code Issues 36 Projects 1 Releases 43 Packages Wiki Activity Actions

Harden multiplayer validation for portable homes

Browse source
This commit is contained in:
Alexander Sellite 2026-08-30 23:52:25 -04:00
parent d2dce7f900
commit b48cb73f3a
5 changed files with 381 additions and 49 deletions
Download patch file Download diff file Expand all files Collapse all files

1
scripts/run_validations.sh
View file

@ -87,6 +87,7 @@ readonly -a NETWORK_TESTS=(
"tests/fish_showcase_multiplayer_validation.gd"
"tests/friend_multiplayer_validation.gd"
"tests/fishing_multiplayer_validation.gd"
"tests/home_spawn_multiplayer_validation.gd"
"tests/job_multiplayer_validation.gd"
"tests/movement_multiplayer_validation.gd"
"tests/operator_multiplayer_validation.gd"

172
tests/fishing_multiplayer_validation.gd
View file

@ -63,12 +63,38 @@ func _run_host() -> void:
var spawn_service := main.get_node(
"%PlayerSpawnService"
) as PlayerSpawnService
var network_home := main.get_node(
"%NetworkHomeService"
) as NetworkHomeService
var home_world := main.get_node("%HomeWorldService") as HomeWorldService
var remote_avatar: Player = spawn_service.get_avatar(remote_peer_id)
assert(remote_avatar != null)
assert(remote_avatar.bag.get_quantity(&"worms") == 0)
remote_avatar.global_position = Vector3(-0.5, 3.95, 2.1)
var remote_visuals := remote_avatar.get_node("Visuals") as Node3D
remote_visuals.rotation.y = PI * 0.5
var remote_record := session.get_peer_record(remote_peer_id)
assert(remote_record != null)
assert(await _wait_for_home(
network_home, remote_record.identity_fingerprint
))
var exterior_spawn: Transform3D = home_world.get_exterior_spawn_transform(
remote_record.identity_fingerprint
)
var exterior_deadline: int = Time.get_ticks_msec() + 5000
while (
Time.get_ticks_msec() < exterior_deadline
and remote_avatar.global_position.distance_to(exterior_spawn.origin) > 0.25
):
await physics_frame
assert(remote_avatar.global_position.distance_to(exterior_spawn.origin) <= 0.25)
# Give the client enough local frames to observe the initial RV-door spawn
# before this test publishes its separate fishing-position teleport.
for _frame: int in 30:
await physics_frame
var cast_setup: Dictionary = await _find_clear_fishing_setup(
main, remote_avatar
)
assert(not cast_setup.is_empty(), "no clear fishing setup was found")
var expected_position: Vector3 = cast_setup["position"]
var expected_direction: Vector3 = cast_setup["direction"]
session.publish_authoritative_teleport(remote_peer_id)
var aiming_deadline: int = Time.get_ticks_msec() + 15000
while (
@ -82,7 +108,7 @@ func _run_host() -> void:
== Player.FishingVisualPhase.CASTING
)
var remote_position_error := (
remote_avatar.global_position - Vector3(-0.5, 3.95, 2.1)
remote_avatar.global_position - expected_position
)
remote_position_error.y = 0.0
assert(
@ -90,7 +116,7 @@ func _run_host() -> void:
"remote casting position drifted: %s" % remote_avatar.global_position
)
assert(
remote_avatar.get_facing_direction().dot(Vector3.LEFT) > 0.99,
remote_avatar.get_facing_direction().dot(expected_direction) > 0.99,
"remote casting facing drifted: %s"
% remote_avatar.get_facing_direction()
)
@ -196,6 +222,23 @@ func _run_client() -> void:
joined = true
break
assert(joined)
var network_home := main.get_node(
"%NetworkHomeService"
) as NetworkHomeService
var home_world := main.get_node("%HomeWorldService") as HomeWorldService
var local_fingerprint: String = session.get_local_identity_fingerprint()
assert(await _wait_for_home(network_home, local_fingerprint))
var player := main.get("_player") as Player
var exterior_spawn: Transform3D = (
home_world.get_exterior_spawn_transform(local_fingerprint)
)
var home_spawn_deadline: int = Time.get_ticks_msec() + 5000
while (
Time.get_ticks_msec() < home_spawn_deadline
and player.global_position.distance_to(exterior_spawn.origin) > 0.25
):
await physics_frame
assert(player.global_position.distance_to(exterior_spawn.origin) <= 0.25)
var service := main.get_node(
"%NetworkFishingService"
@ -206,7 +249,6 @@ func _run_client() -> void:
cast_rejections.append(message)
)
var fishing_spot := main.get_node("%FishingSpot") as FishingSpotType
var player := main.get("_player") as Player
var item_catalog := main.get("item_catalog") as ItemCatalog
var worms: ItemData = item_catalog.get_item_by_id(&"worms")
if player.bag.get_quantity(&"worms") == 0:
@ -217,15 +259,20 @@ func _run_client() -> void:
"Visuals/CharacterRig/AnimationPlayer"
) as AnimationPlayer
assert(character_animation_player.has_animation(&"retract_sit"))
var placement_deadline: int = Time.get_ticks_msec() + 5000
# The host chooses and publishes a clear target after both RV manifests have
# settled. Waiting for that authoritative teleport also coordinates the
# animation-observation window between these two independent processes.
var placement_deadline: int = Time.get_ticks_msec() + 10000
while (
Time.get_ticks_msec() < placement_deadline
and player.global_position.distance_to(Vector3(-0.5, 3.95, 2.1))
> 0.25
and player.global_position.distance_to(exterior_spawn.origin) <= 1.0
):
await physics_frame
assert(player.global_position.distance_to(Vector3(-0.5, 3.95, 2.1)) <= 0.25)
assert(player.get_facing_direction().dot(Vector3.LEFT) > 0.99)
assert(player.global_position.distance_to(exterior_spawn.origin) > 1.0)
for _frame: int in 2:
await physics_frame
var expected_position: Vector3 = player.global_position
var expected_direction: Vector3 = player.get_facing_direction()
player.set_casting_visual()
assert(
@ -241,7 +288,10 @@ func _run_client() -> void:
assert(player.is_sitting())
for _frame: int in 15:
await physics_frame
assert(fishing_spot.state == FishingSpotType.FishingState.READY)
assert(fishing_spot.get("_active_player") == null)
fishing_spot.call("_begin_aiming", player)
assert(fishing_spot.state == FishingSpotType.FishingState.AIMING_CAST)
assert(player.is_movement_enabled())
assert(
int(player.get("_fishing_visual_phase"))
@ -250,6 +300,7 @@ func _run_client() -> void:
var cast_charge: float = 0.0
var target: Vector3 = Vector3.ZERO
var cast_origin: Vector3 = fishing_spot.get("_cast_origin_position")
var target_diagnostics: Array[String] = []
for charge_step: int in range(1, 21):
var candidate_charge := float(charge_step) / 20.0
fishing_spot.set("_cast_charge", candidate_charge)
@ -258,14 +309,33 @@ func _run_client() -> void:
var candidate_surface := fishing_spot.get(
"_aim_surface_sample"
) as FishingSurfaceSample
target_diagnostics.append(
"charge=%.2f surface=%s path=%s target=%s" % [
candidate_charge,
candidate_surface.is_fishable(),
fishing_spot.get("_cast_path_is_clear"),
candidate_target,
]
)
if (
candidate_surface.is_fishable()
and fishing_spot.is_cast_path_clear(cast_origin, candidate_target)
and bool(fishing_spot.get("_cast_path_is_clear"))
):
cast_charge = candidate_charge
target = candidate_target
break
assert(cast_charge > 0.0, "no clear fishable test target was found")
assert(
cast_charge > 0.0,
(
"no clear fishable test target was found; position=%s facing=%s "
+ "expected=%s diagnostics=%s"
) % [
player.global_position,
player.get_facing_direction(),
expected_direction,
target_diagnostics,
],
)
var evidence: Dictionary = fishing_spot.call("_build_network_evidence")
fishing_spot.set("state", FishingSpotType.FishingState.CASTING)
player.set_movement_enabled(false)
@ -388,3 +458,79 @@ func _create_initialized_main() -> Node:
await process_frame
assert(bool(main.get("_application_initialized")))
return main
func _wait_for_home(
network_home: NetworkHomeService,
fingerprint: String,
) -> bool:
var deadline: int = Time.get_ticks_msec() + 10000
while Time.get_ticks_msec() < deadline:
await process_frame
var manifests: Dictionary = network_home.get(
"_manifests_by_fingerprint"
)
if manifests.has(fingerprint):
return true
return false
func _find_clear_fishing_setup(main: Node, player: Player) -> Dictionary:
var world := main.get_node("TestWorld") as TestWorld
var fishing_spot := main.get_node("%FishingSpot") as FishingSpotType
var regions: Array[FishableWaterRegion] = world.get_fishable_water_regions()
for region: FishableWaterRegion in regions:
var body := region.get_parent() as WaterBodyAuthoring
if body == null or body.surface_size.x <= 0.0 or body.surface_size.y <= 0.0:
continue
var center: Vector3 = region.global_position
var half_size: Vector2 = body.surface_size * 0.5
var candidate_offsets: Array[Vector3] = [
Vector3(half_size.x + 0.8, 0.0, 0.0),
Vector3(-half_size.x - 0.8, 0.0, 0.0),
Vector3(0.0, 0.0, half_size.y + 0.8),
Vector3(0.0, 0.0, -half_size.y - 0.8),
]
for offset: Vector3 in candidate_offsets:
var position := Vector3(
center.x + offset.x,
region.get_surface_height() + 1.44,
center.z + offset.z,
)
var direction: Vector3 = center - position
direction.y = 0.0
direction = direction.normalized()
player.global_position = position
var visuals := player.get_node("Visuals") as Node3D
visuals.global_rotation.y = atan2(-direction.x, -direction.z)
for _frame: int in 2:
await physics_frame
var cast_origin: Vector3 = player.get_cast_origin_position()
var launch_position: Vector3 = player.get_fishing_rod_tip().global_position
for charge_step: int in range(1, 21):
var cast_charge := float(charge_step) / 20.0
var cast_distance := lerpf(
fishing_spot.minimum_cast_distance,
fishing_spot.maximum_cast_distance,
cast_charge,
)
var query_position := cast_origin + direction * cast_distance
var sample: FishingSurfaceSample = (
fishing_spot.resolve_fishing_surface(
query_position, cast_origin.y
)
)
var target: Vector3 = sample.get_bobber_position(
fishing_spot.solid_bobber_clearance
)
if (
sample.is_fishable()
and fishing_spot.is_cast_path_clear(
launch_position, target
)
):
return {
"position": player.global_position,
"direction": direction,
}
return {}

34
tests/late_join_multiplayer_validation.gd
View file

@ -90,11 +90,12 @@ func _run_first_client() -> void:
player.toggle_sitting()
assert(player.is_sitting())
assert(player.bag.add_item(&"crab_net"))
assert(player.hotbar.assign_item(0, &"crab_net"))
assert(player.hotbar.select_slot(0))
for _frame: int in 2:
await process_frame
assert(bool(player.get("_active_item_is_net")))
# Slot zero begins selected with the starter rod. Replacing that slot does
# not emit a selection change, so use the next slot to exercise the same
# equipped-item path a player uses in normal gameplay.
assert(player.hotbar.assign_item(1, &"crab_net"))
assert(player.hotbar.select_slot(1))
assert(await _wait_for_local_net(main, player))
assert(player.begin_animation_action(ACTIVE_ACTION))
await create_timer(0.5).timeout
assert(StringName(str(player.get("_animation_action_id"))) == ACTIVE_ACTION)
@ -185,6 +186,29 @@ func _wait_for_registry_size(session: NetworkSession, expected: int) -> bool:
return false
func _wait_for_local_net(main: Node, player: Player) -> bool:
var deadline: int = Time.get_ticks_msec() + 10000
while Time.get_ticks_msec() < deadline:
# A joined client can finish its world transition one frame after the
# hotbar selection signal. Refresh through the production path until the
# ready fishing state accepts the equipped item.
main.call("_refresh_active_hotbar_item")
await process_frame
if bool(player.get("_active_item_is_net")):
return true
var fishing_spot: Node = main.get_node("%FishingSpot")
print(
"net equip wait timed out: ",
{
"fishing_state": int(fishing_spot.get("state")),
"selected_slot": player.hotbar.get_selected_slot(),
"selected_item": String(player.hotbar.get_selected_item_id()),
"owns_net": player.bag.owns_item(&"crab_net"),
},
)
return false
func _history_contains(service: NetworkChatService, body: String) -> bool:
return service.get_history().any(
func(message: Dictionary) -> bool:

149
tests/movement_multiplayer_validation.gd
View file

@ -593,15 +593,22 @@ func _run_host() -> void:
var main: Node = await _create_initialized_main()
var session := main.get_node("%NetworkSession") as NetworkSession
var save_manager := main.get("_save_manager") as PlayerSaveManager
assert(session.set_host_world(
assert(bool(main.call(
"_apply_world",
WorldLayout.STARTER_ISLAND,
NetworkProtocol.DEFAULT_WORLD_SEED,
))
assert(session.start_private_host(TEST_PORT))
true,
)))
assert(bool(main.call(
"_prepare_host_world",
WorldLayout.STARTER_ISLAND,
NetworkProtocol.DEFAULT_WORLD_SEED,
)))
assert(save_manager.initialize_new_game(
NetworkProtocol.DEFAULT_WORLD_SEED,
WorldLayout.STARTER_ISLAND,
))
assert(session.start_private_host(TEST_PORT))
main.call("_enter_gameplay")
for _frame: int in 4:
await physics_frame
@ -613,31 +620,40 @@ func _run_host() -> void:
# to settle before emitting the one-shot locomotion/action sequence.
await create_timer(3.0).timeout
var player := main.get("_player") as Player
var world := main.get_node("TestWorld") as TestWorld
player.configure_network_remote(true)
player.apply_authoritative_network_input(_movement_input(1, true))
await create_timer(2.5).timeout
player.apply_authoritative_network_input(_movement_input(2, false))
await create_timer(2.5).timeout
player.apply_authoritative_network_input(
_movement_input(3, false, true, true)
await _reset_locomotion_test_position(player, session, world)
var input_sequence: int = 1
input_sequence = await _sustain_locomotion_input(
player, input_sequence, 1.5, true
)
await create_timer(2.0).timeout
player.apply_authoritative_network_input(
_movement_input(4, false, false, true)
await _reset_locomotion_test_position(player, session, world)
input_sequence = await _sustain_locomotion_input(
player, input_sequence, 1.5, false
)
await create_timer(2.0).timeout
player.apply_authoritative_network_input(
_movement_input(5, false, false, true, &"draw", 1)
await _reset_locomotion_test_position(player, session, world)
input_sequence = await _sustain_locomotion_input(
player, input_sequence, 1.5, false, true, true
)
input_sequence = await _sustain_locomotion_input(
player, input_sequence, 1.5, false, false, true
)
player.apply_authoritative_network_input(
_movement_input(input_sequence, false, false, true, &"draw", 1)
)
input_sequence += 1
await create_timer(1.0).timeout
player.apply_authoritative_network_input(
_movement_input(6, false, false, true, &"strike", 2, true)
_movement_input(
input_sequence, false, false, true, &"strike", 2, true
)
)
input_sequence += 1
await create_timer(2.0).timeout
player.apply_authoritative_network_input(
_movement_input(7, false, false, false, &"", 3)
_movement_input(input_sequence, false, false, false, &"", 3)
)
var disconnect_deadline: int = Time.get_ticks_msec() + 8000
var disconnect_deadline: int = Time.get_ticks_msec() + 15000
while (
Time.get_ticks_msec() < disconnect_deadline
and session.is_authenticated_peer(remote_peer_id)
@ -686,12 +702,27 @@ func _run_client() -> void:
var saw_net_strike_paused: bool = false
var saw_animation_advance: bool = false
var saw_dust: bool = false
var observed_animations: Dictionary = {}
var observed_locomotion_states: Dictionary = {}
var maximum_sneak_speed: float = 0.0
var previous_animation: StringName = &""
var previous_animation_position: float = -1.0
var observation_deadline: int = Time.get_ticks_msec() + 18000
var observation_deadline: int = Time.get_ticks_msec() + 22000
while Time.get_ticks_msec() < observation_deadline:
await process_frame
var current_animation: StringName = animation_player.current_animation
observed_animations[current_animation] = true
var target_locomotion_state: int = int(host_avatar.get(
"_network_target_locomotion_state"
))
observed_locomotion_states[target_locomotion_state] = true
if target_locomotion_state == Player.LocomotionState.SNEAKING:
maximum_sneak_speed = maxf(
maximum_sneak_speed,
Vector2(
host_avatar.velocity.x, host_avatar.velocity.z
).length(),
)
saw_running = saw_running or current_animation.begins_with("running")
saw_walking = saw_walking or current_animation.begins_with("walking")
saw_sneaking = saw_sneaking or current_animation == &"sneaking"
@ -732,15 +763,44 @@ func _run_client() -> void:
and saw_dust
):
break
assert(saw_running)
assert(saw_walking)
assert(saw_sneaking)
assert(saw_idle_sneak)
assert(saw_net_draw)
assert(saw_net_strike)
assert(saw_net_strike_paused)
assert(saw_animation_advance)
assert(saw_dust)
var missing_observations: Array[String] = []
if not saw_running:
missing_observations.append("running")
if not saw_walking:
missing_observations.append("walking")
if not saw_sneaking:
missing_observations.append("sneaking")
if not saw_idle_sneak:
missing_observations.append("idle_sneak")
if not saw_net_draw:
missing_observations.append("net_draw")
if not saw_net_strike:
missing_observations.append("net_strike")
if not saw_net_strike_paused:
missing_observations.append("net_strike_paused")
if not saw_animation_advance:
missing_observations.append("animation_advance")
if not saw_dust:
missing_observations.append("sprint_dust")
if not missing_observations.is_empty():
push_error(
(
"Missing movement observations %s; observed animations: %s; "
+ "locomotion states: %s; maximum sneak speed: %.3f"
) % [
missing_observations,
observed_animations.keys(),
observed_locomotion_states.keys(),
maximum_sneak_speed,
]
)
session.disconnect_session("")
main.queue_free()
for _frame: int in 4:
await process_frame
await create_timer(0.1).timeout
quit(1)
return
print("Movement multiplayer client validation: PASS")
session.disconnect_session("")
main.queue_free()
@ -778,6 +838,39 @@ func _movement_input(
}
func _sustain_locomotion_input(
player: Player,
starting_sequence: int,
duration_seconds: float,
sprinting: bool,
moving: bool = true,
sneaking: bool = false,
) -> int:
var sequence: int = starting_sequence
var deadline: int = (
Time.get_ticks_msec() + roundi(duration_seconds * 1000.0)
)
while Time.get_ticks_msec() < deadline:
player.apply_authoritative_network_input(
_movement_input(sequence, sprinting, moving, sneaking)
)
sequence += 1
await create_timer(0.1).timeout
return sequence
func _reset_locomotion_test_position(
player: Player,
session: NetworkSession,
world: TestWorld,
) -> void:
player.velocity = Vector3.ZERO
player.global_transform = world.get_player_spawn_transform()
session.publish_authoritative_teleport(1)
for _frame: int in 4:
await physics_frame
func _create_initialized_main() -> Node:
root.size = Vector2i(1280, 720)
var main: Node = MainScene.instantiate()

74
tests/surface_drawing_multiplayer_validation.gd
View file

@ -27,10 +27,12 @@ func _run_host() -> void:
assert(bool(main.call(
"_apply_world", WorldLayout.STARTER_ISLAND, 1, true
)))
assert(session.set_host_world(WorldLayout.STARTER_ISLAND, 1))
assert(session.start_private_host(TEST_PORT))
assert(bool(main.call(
"_prepare_host_world", WorldLayout.STARTER_ISLAND, 1
)))
var save_manager := main.get("_save_manager") as PlayerSaveManager
assert(save_manager.initialize_new_game())
assert(save_manager.initialize_new_game(1, WorldLayout.STARTER_ISLAND))
assert(session.start_private_host(TEST_PORT))
main.call("_enter_gameplay")
await physics_frame
await physics_frame
@ -62,6 +64,40 @@ func _run_host() -> void:
remote_peer_id
)
assert(remote_record != null)
var network_home := main.get_node(
"%NetworkHomeService"
) as NetworkHomeService
var home_world := main.get_node("%HomeWorldService") as HomeWorldService
var spawn_service := main.get_node(
"%PlayerSpawnService"
) as PlayerSpawnService
assert(await _wait_for_home(
network_home, remote_record.identity_fingerprint
))
var remote_avatar: Player = spawn_service.get_avatar(remote_peer_id)
assert(remote_avatar != null)
var exterior_spawn: Transform3D = home_world.get_exterior_spawn_transform(
remote_record.identity_fingerprint
)
var exterior_deadline: int = Time.get_ticks_msec() + 5000
while (
Time.get_ticks_msec() < exterior_deadline
and remote_avatar.global_position.distance_to(exterior_spawn.origin) > 0.25
):
await physics_frame
assert(remote_avatar.global_position.distance_to(exterior_spawn.origin) <= 0.25)
var canvas_state: Dictionary = service.get_canvas_state(canvas_id)
var canvas_origin: Vector3 = SurfaceDrawingProtocol.array_to_vector(
canvas_state["origin"]
)
remote_avatar.global_position = Vector3(
canvas_origin.x + 1.0,
player.global_position.y,
canvas_origin.z,
)
session.publish_authoritative_teleport(remote_peer_id)
for _frame: int in 4:
await physics_frame
assert(session.peer_supports_capability(
remote_peer_id, SurfaceDrawingProtocol.CAPABILITY
))
@ -152,6 +188,9 @@ func _run_host() -> void:
):
await process_frame
assert(service.get_canvas_ids().size() == 1)
# Keep the second stamp observable on the client before the ban removes all
# artwork carrying that participant fingerprint.
await create_timer(1.0).timeout
var player_list := main.get_node(
"%NetworkPlayerListService"
) as NetworkPlayerListService
@ -221,6 +260,20 @@ func _run_client() -> void:
var canvas_id: String = service.get_canvas_ids()[0]
var snapshot: Dictionary = service.get_canvas_state(canvas_id)
assert(str(_find_cell(snapshot, 7, 7).get("color_id", "")) == "coral")
var canvas_origin: Vector3 = SurfaceDrawingProtocol.array_to_vector(
snapshot["origin"]
)
var placement_deadline: int = Time.get_ticks_msec() + 10000
while (
Time.get_ticks_msec() < placement_deadline
and player.global_position.distance_to(canvas_origin)
> NetworkSurfaceDrawingService.MAX_DRAW_DISTANCE + 2.0
):
await physics_frame
assert(
player.global_position.distance_to(canvas_origin)
<= NetworkSurfaceDrawingService.MAX_DRAW_DISTANCE + 2.0
)
assert(service.request_cell_edits(canvas_id, [{
"x": 7,
"y": 7,
@ -381,3 +434,18 @@ func _create_initialized_main() -> Node:
await process_frame
assert(bool(main.get("_application_initialized")))
return main
func _wait_for_home(
network_home: NetworkHomeService,
fingerprint: String,
) -> bool:
var deadline: int = Time.get_ticks_msec() + 10000
while Time.get_ticks_msec() < deadline:
await process_frame
var manifests: Dictionary = network_home.get(
"_manifests_by_fingerprint"
)
if manifests.has(fingerprint):
return true
return false