Rebuild multiplayer on the stock spawner and synchronizer
Adding an object to the game no longer requires any networking code. The
MultiplayerSpawner runs in its default mode — no spawn_function, no payload
dictionary — and NetReplication builds each object's SceneReplicationConfig
from a convention, so scenes carry no hand-authored replication at all.
Every replicated node gets two generated synchronizers: NetSync for script
state, always server-owned, and NetXform for position, handed to whoever is
holding the object. That split is what makes grab prediction work — a
synchronizer never applies inbound state on the peer that owns it, so a
player's own hand drives an object with no round trip while is_dirty and
friends keep flowing one way from the server.
Interaction is now two RPCs for the whole game (NetGrab), and client gating is
one rule applied to every object (NetWorld). Deleted: net_pickable.gd, the
replicated net_held_by field and its held-state juggling, the
grant/reject/force-release negotiation, the static-item despawn RPC, and the
per-scene replication configs. Authority is the single source of truth for who
simulates an object.
Two things the convention had to learn, both found by the test suite:
* Addon scripts are excluded. godot-xr-tools' snap zones and pickables expose
a public `enabled`, which is exactly the flag each peer must set for itself
— so replicating it meant the server sent `enabled = true` back over every
client's gate, and stations went on grabbing objects out of the local
player's hands.
* Arrays of nodes are excluded. Array[Node3D] and Array[FoodItem] would
otherwise try to serialise live node references.
table.gd's replicated state loses its underscore prefix, which now marks a
variable as private and unreplicated; two in-place array mutations there were
skipping their setters, and the progress bar could divide by zero on a client.
Suite: 146/146 passing.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
algodoogle
+136
@@ -0,0 +1,136 @@
|
||||
extends Node
|
||||
|
||||
## The whole interaction layer: two RPCs, for every object in the game.
|
||||
##
|
||||
## Registered as the "NetGrab" autoload so its RPCs resolve to the same node path
|
||||
## on every peer.
|
||||
##
|
||||
## A hand picks something up locally the instant the player grabs it — no round
|
||||
## trip, no waiting — and tells the server. The server answers by moving the
|
||||
## object's NetXform to that peer, which is what actually makes the prediction
|
||||
## work: a MultiplayerSynchronizer never applies inbound state on the peer that
|
||||
## owns it, so from that moment the holder's own hand drives the object and the
|
||||
## server's copy follows instead of fighting it. Releasing hands NetXform back,
|
||||
## and the server decides where the object really ends up.
|
||||
##
|
||||
## Note what is NOT here. There is no per-object networking component, no
|
||||
## replicated "who is holding this" field to keep in step with the authority, and
|
||||
## no grant/reject/force-release negotiation. Authority is the single source of
|
||||
## truth for who simulates an object, and NetWorld.apply_physics_role reads it.
|
||||
|
||||
|
||||
## Starts watching a pickable. Called by NetWorld for every replicated object, so
|
||||
## no scene has to include a networking node to take part.
|
||||
func watch(item: XRToolsPickable) -> void:
|
||||
if item.picked_up.is_connected(_on_picked_up):
|
||||
return
|
||||
item.picked_up.connect(_on_picked_up)
|
||||
item.dropped.connect(_on_dropped)
|
||||
|
||||
|
||||
func _on_picked_up(item: Node3D) -> void:
|
||||
if not NetworkManager.is_online():
|
||||
return
|
||||
# A station snap zone grabbing something is the server placing it, not a
|
||||
# player taking it, so it must not move authority anywhere.
|
||||
if not (item.get_picked_up_by() is XRToolsFunctionPickup):
|
||||
return
|
||||
NetworkManager.log_line("%s grabbed by hand, claiming it" % item.name)
|
||||
if NetworkManager.is_server():
|
||||
_claim(item.get_path(), 1)
|
||||
else:
|
||||
# rpc_id() to ourselves is rejected by Godot, which is why the server
|
||||
# branch calls straight through instead.
|
||||
_request_grab.rpc_id(1, item.get_path())
|
||||
|
||||
|
||||
func _on_dropped(item: Node3D) -> void:
|
||||
if not NetworkManager.is_online():
|
||||
return
|
||||
# Only the peer that was actually driving the object reports a release. A drop
|
||||
# caused by losing authority (see NetWorld.apply_physics_role) must not be
|
||||
# echoed back as if the player had let go.
|
||||
var xform := item.get_node_or_null(NetReplication.XFORM_NAME)
|
||||
if not xform or not xform.is_multiplayer_authority():
|
||||
return
|
||||
# Our own final transform travels with the release. We were driving the object
|
||||
# right up to this moment and our position updates ride the synchronizer's
|
||||
# separate, unordered channel, which this reliable message routinely
|
||||
# overtakes — so the server's copy can still be back where the object was
|
||||
# before we carried it away. Deciding the snap from that stale position
|
||||
# teleports the object straight back into the station it was just taken from.
|
||||
if NetworkManager.is_server():
|
||||
_settle(item.get_path(), item.global_transform, item.linear_velocity, item.angular_velocity)
|
||||
else:
|
||||
_request_release.rpc_id(
|
||||
1, item.get_path(), item.global_transform,
|
||||
item.linear_velocity, item.angular_velocity
|
||||
)
|
||||
|
||||
|
||||
# --- server side -----------------------------------------------------------
|
||||
|
||||
@rpc("any_peer", "reliable")
|
||||
func _request_grab(item_path: NodePath) -> void:
|
||||
if not NetworkManager.is_server():
|
||||
return
|
||||
_claim(item_path, multiplayer.get_remote_sender_id())
|
||||
|
||||
|
||||
@rpc("any_peer", "reliable")
|
||||
func _request_release(item_path: NodePath, xform: Transform3D, lin: Vector3, ang: Vector3) -> void:
|
||||
if not NetworkManager.is_server():
|
||||
return
|
||||
_settle(item_path, xform, lin, ang)
|
||||
|
||||
|
||||
func _claim(item_path: NodePath, peer: int) -> void:
|
||||
var item := get_node_or_null(item_path)
|
||||
if not item:
|
||||
return
|
||||
NetworkManager.log_line("grant %s to peer %d" % [item.name, peer])
|
||||
# Order matters: hand the object over first, so the station's zone has already
|
||||
# stopped owning it by the time it is told to let go.
|
||||
_set_xform_authority.rpc(item_path, peer)
|
||||
NetStations.release_from_zones(self, item)
|
||||
|
||||
|
||||
func _settle(item_path: NodePath, xform: Transform3D, lin: Vector3, ang: Vector3) -> void:
|
||||
var item := get_node_or_null(item_path)
|
||||
if not item:
|
||||
return
|
||||
NetworkManager.log_line("release %s" % item.name)
|
||||
if item is Node3D:
|
||||
item.global_transform = xform
|
||||
_set_xform_authority.rpc(item_path, 1)
|
||||
if item is RigidBody3D:
|
||||
item.linear_velocity = lin
|
||||
item.angular_velocity = ang
|
||||
NetStations.try_snap.call_deferred(self, item)
|
||||
|
||||
|
||||
## set_multiplayer_authority is a local call, so every peer has to run it for
|
||||
## them to agree on who is driving the object.
|
||||
@rpc("authority", "call_local", "reliable")
|
||||
func _set_xform_authority(item_path: NodePath, peer: int) -> void:
|
||||
var item := get_node_or_null(item_path)
|
||||
if not item:
|
||||
return
|
||||
var xform := item.get_node_or_null(NetReplication.XFORM_NAME)
|
||||
if not xform:
|
||||
return
|
||||
xform.set_multiplayer_authority(peer)
|
||||
NetworkManager.apply_physics_role(item)
|
||||
|
||||
|
||||
## Hands everything a departing peer was holding back to the server. Without
|
||||
## this, anything still in their hand when they dropped out would be frozen
|
||||
## forever on every remaining peer, waiting on an authority that has gone.
|
||||
func reclaim_from(peer: int) -> void:
|
||||
if not NetworkManager.is_server():
|
||||
return
|
||||
for item in NetworkManager.replicated_objects():
|
||||
var xform := item.get_node_or_null(NetReplication.XFORM_NAME)
|
||||
if xform and xform.get_multiplayer_authority() == peer:
|
||||
NetworkManager.log_line("reclaiming %s from departed peer %d" % [item.name, peer])
|
||||
_settle(item.get_path(), item.global_transform, Vector3.ZERO, Vector3.ZERO)
|
||||
@@ -0,0 +1 @@
|
||||
uid://bv82nioivbmnx
|
||||
@@ -1,209 +0,0 @@
|
||||
extends MultiplayerSynchronizer
|
||||
|
||||
## Networked sync component for a pickable item. Added as a child literally
|
||||
## named "NetPickable" (network_manager.gd's authority RPCs already expect
|
||||
## this) of every net-synced pickable, replicating its transform and held
|
||||
## state. Only the current multiplayer authority (the server while loose, or
|
||||
## whichever peer is holding it) actually simulates physics for the item;
|
||||
## every other peer freezes their local copy and just follows the synced
|
||||
## transform.
|
||||
|
||||
## 0 = loose/server-simulated; otherwise the peer id currently holding it.
|
||||
## Replicated at spawn and on change so a late joiner sees the current holder.
|
||||
var net_held_by: int = 0: set = _set_net_held_by
|
||||
|
||||
var _pickable: XRToolsPickable
|
||||
|
||||
# This item's own baked freeze_mode (e.g. plate.tscn bakes KINEMATIC, not the
|
||||
# RigidBody3D default of STATIC) — captured once so it can be restored when
|
||||
# this peer regains ownership, instead of getting stuck on whatever
|
||||
# apply_held_state() last forced it to while non-authority.
|
||||
var _original_freeze_mode: int
|
||||
|
||||
# Same idea for the pickable's authored `enabled` flag, which the non-authority
|
||||
# branch of apply_held_state() clears while someone else is holding the item.
|
||||
var _original_enabled: bool
|
||||
|
||||
# Whether the "our own hand still holds this" guard has already been logged for
|
||||
# the current grab. apply_held_state() runs every network tick, so without this
|
||||
# the guard message repeats for as long as you hold the item.
|
||||
var _grab_race_logged := false
|
||||
|
||||
|
||||
func _ready() -> void:
|
||||
_pickable = get_parent() as XRToolsPickable
|
||||
if not _pickable:
|
||||
push_error("NetPickable must be a child of an XRToolsPickable")
|
||||
return
|
||||
_original_freeze_mode = _pickable.freeze_mode
|
||||
_original_enabled = _pickable.enabled
|
||||
_pickable.picked_up.connect(_on_picked_up)
|
||||
_pickable.dropped.connect(_on_dropped)
|
||||
# Deferred: the pickable root captures its own original_collision_mask/
|
||||
# original_collision_layer via @onready, which runs AFTER this child's
|
||||
# _ready() but BEFORE the root's _ready() body. Calling apply_held_state
|
||||
# synchronously here would freeze/mask the item before that capture runs,
|
||||
# permanently corrupting the "restore on drop" values.
|
||||
apply_held_state.call_deferred()
|
||||
|
||||
|
||||
func _set_net_held_by(value: int) -> void:
|
||||
var old := net_held_by
|
||||
net_held_by = value
|
||||
if old != value and NetworkManager.is_online():
|
||||
print("%s net_held_by: %d -> %d (local state: %s, authority=%d)" % [
|
||||
_pickable.name, old, value, _holder_desc(), get_multiplayer_authority()
|
||||
])
|
||||
apply_held_state()
|
||||
|
||||
|
||||
## Puts the item in the right physics state for whether this peer currently
|
||||
## owns it. Called locally after net_held_by changes, and directly by
|
||||
## NetworkManager._set_item_authority right after an authority handoff.
|
||||
##
|
||||
## IMPORTANT: this runs on every network tick, not just on a real change.
|
||||
## net_held_by is replicated in ALWAYS mode, so the synchronizer assigns it every
|
||||
## tick on non-authority peers — unchanged value included — and that assignment
|
||||
## lands in _set_net_held_by(), which calls this. So every branch here has to be
|
||||
## idempotent and silent when there is nothing to do: otherwise each item logs a
|
||||
## line and rewrites four physics properties every tick on every peer that
|
||||
## doesn't own it.
|
||||
func apply_held_state() -> void:
|
||||
if not _pickable:
|
||||
return
|
||||
if not NetworkManager.is_online() or is_multiplayer_authority():
|
||||
_grab_race_logged = false
|
||||
# We own this item's simulation (offline, loose+server, or currently
|
||||
# holding it). If it's not actively in our own hand right now, make
|
||||
# sure it isn't still left frozen/collision-less from a previous
|
||||
# non-authority period (e.g. right after regaining authority when a
|
||||
# client released it) — while actually held, XRToolsPickable's own
|
||||
# pick_up()/let_go() already manage these fields, so leave those be.
|
||||
if not _pickable.is_picked_up():
|
||||
var changed := _pickable.freeze_mode != _original_freeze_mode \
|
||||
or _pickable.collision_mask != _pickable.original_collision_mask
|
||||
if changed:
|
||||
if NetworkManager.is_online():
|
||||
print(
|
||||
"%s: reclaiming ownership, restoring freeze_mode %d->%d collision_mask %d->%d" % [
|
||||
_pickable.name, _pickable.freeze_mode, _original_freeze_mode,
|
||||
_pickable.collision_mask, _pickable.original_collision_mask
|
||||
]
|
||||
)
|
||||
_pickable.freeze_mode = _original_freeze_mode
|
||||
_pickable.collision_mask = _pickable.original_collision_mask
|
||||
# Unlike freeze/collision (which XRToolsPickable manages itself while
|
||||
# held), `enabled` is only ever written by the non-authority branch
|
||||
# below, so it must be restored here or it stays false forever: once a
|
||||
# client grabbed this item, every other peer set enabled=false, and
|
||||
# regaining authority left it that way. On the server that silently
|
||||
# broke everything downstream — hands couldn't pick the item up again,
|
||||
# and a station snap zone would "snap" it (emitting has_picked_up, so
|
||||
# e.g. a plate still got marked dirty) while pick_up() bailed out on
|
||||
# the disabled item, leaving the zone holding an item with no grab
|
||||
# driver that then fell out of the station.
|
||||
if _pickable.enabled != _original_enabled:
|
||||
if NetworkManager.is_online():
|
||||
print("%s: reclaiming ownership, restoring enabled %s->%s" % [
|
||||
_pickable.name, _pickable.enabled, _original_enabled
|
||||
])
|
||||
_pickable.enabled = _original_enabled
|
||||
return
|
||||
# A net_held_by/position sync update can race ahead of the
|
||||
# authority-handoff RPC that's about to confirm a grab we just made
|
||||
# optimistically (they travel on different channels with no ordering
|
||||
# guarantee). Don't let a stale sync value yank an item out of our own
|
||||
# hand mid-grab — only an explicit force_release_item rejection, or
|
||||
# actually losing authority for real, should end a grab we initiated.
|
||||
if _pickable.is_picked_up() and _pickable.get_picked_up_by() is XRToolsFunctionPickup:
|
||||
# Log once per grab, not once per tick.
|
||||
if NetworkManager.is_online() and not _grab_race_logged:
|
||||
_grab_race_logged = true
|
||||
print(
|
||||
"%s: ignoring non-authority sync (net_held_by=%d) — still actively held by our own hand (grab-race guard)" % [
|
||||
_pickable.name, net_held_by
|
||||
]
|
||||
)
|
||||
return
|
||||
_grab_race_logged = false
|
||||
# Someone else owns it: stop simulating locally, just follow the sync.
|
||||
if _pickable.is_picked_up():
|
||||
if NetworkManager.is_online():
|
||||
print(
|
||||
"%s: was held by %s on this peer, but authority now says peer %d owns it — force-dropping" % [
|
||||
_pickable.name, _holder_desc(), net_held_by
|
||||
]
|
||||
)
|
||||
_pickable.drop()
|
||||
# Bail out when we're already in the follow-the-sync state. Without this the
|
||||
# writes below (and the line logged with them) repeated every tick for every
|
||||
# item on every non-authority peer — 90% of the log, plus four redundant
|
||||
# physics-property writes per item per tick. The comparison also means we
|
||||
# still re-apply if something else perturbs the state (e.g. let_go()
|
||||
# restoring the collision mask after a force-drop).
|
||||
var want_enabled := (net_held_by == 0)
|
||||
if _pickable.freeze \
|
||||
and _pickable.freeze_mode == RigidBody3D.FREEZE_MODE_KINEMATIC \
|
||||
and _pickable.collision_mask == 0 \
|
||||
and _pickable.enabled == want_enabled:
|
||||
return
|
||||
if NetworkManager.is_online():
|
||||
print("%s: freezing (non-authority, owner=peer %d)" % [_pickable.name, net_held_by])
|
||||
_pickable.freeze = true
|
||||
_pickable.freeze_mode = RigidBody3D.FREEZE_MODE_KINEMATIC
|
||||
_pickable.collision_mask = 0
|
||||
_pickable.enabled = want_enabled
|
||||
|
||||
|
||||
## Local hand grab (not a station snap zone, which is server-only): request
|
||||
## authority immediately so the throw/drop can be reconciled, but let the grab
|
||||
## happen instantly here rather than waiting on the round trip.
|
||||
func _on_picked_up(_p) -> void:
|
||||
var by := _pickable.get_picked_up_by()
|
||||
if not (by is XRToolsFunctionPickup):
|
||||
# e.g. a station snap zone grabbed it (server-side auto-snap, or the
|
||||
# addon's own "grab out of a snap zone" shortcut mid-cascade) — not a
|
||||
# player-initiated hand grab, so no authority request from here.
|
||||
if NetworkManager.is_online():
|
||||
print("%s picked up by %s (not a hand) — no authority request" % [_pickable.name, _holder_desc()])
|
||||
return
|
||||
if NetworkManager.is_online():
|
||||
print("%s grabbed by hand (authority was peer %d), requesting authority" % [_pickable.name, net_held_by])
|
||||
NetworkManager.request_item_authority_from(_pickable.get_path())
|
||||
|
||||
|
||||
func _on_dropped(_p) -> void:
|
||||
# Only forward if we're actually still the authority — a drop caused by
|
||||
# apply_held_state() losing authority (see above) must not re-report.
|
||||
if not is_multiplayer_authority():
|
||||
if NetworkManager.is_online():
|
||||
print("%s dropped locally, but we aren't its authority (peer %d is) — not reporting" % [_pickable.name, net_held_by])
|
||||
return
|
||||
if NetworkManager.is_online():
|
||||
print("%s dropped, reporting release to server (lin=%s ang=%s)" % [
|
||||
_pickable.name, _pickable.linear_velocity, _pickable.angular_velocity
|
||||
])
|
||||
# Send our own final transform too: we were the authority until now, and the
|
||||
# server's copy may not have received our last position sync yet.
|
||||
NetworkManager.release_item_authority_from(
|
||||
_pickable.get_path(), _pickable.linear_velocity, _pickable.angular_velocity,
|
||||
_pickable.global_transform
|
||||
)
|
||||
|
||||
|
||||
## Human-readable description of what's currently holding this item on THIS
|
||||
## peer, for diagnosing desyncs between a hand's own "what am I holding"
|
||||
## bookkeeping and the item's actual grab state (see the snap-zone-grab race
|
||||
## in NetworkManager._try_snap_into_station for a real example).
|
||||
func _holder_desc() -> String:
|
||||
if not _pickable or not _pickable.is_picked_up():
|
||||
return "loose"
|
||||
var by := _pickable.get_picked_up_by()
|
||||
if not by:
|
||||
return "held(no grabber?)"
|
||||
if by is XRToolsFunctionPickup:
|
||||
return "hand(%s)" % by.get_path()
|
||||
if by is XRToolsSnapZone:
|
||||
var station := by.get_parent()
|
||||
return "zone(%s)" % (station.name if station else str(by.get_path()))
|
||||
return "other(%s: %s)" % [by.get_class(), by.get_path()]
|
||||
@@ -1 +0,0 @@
|
||||
uid://bwd0pe2udb5xo
|
||||
@@ -73,6 +73,12 @@ static func _add_sync(node: Node, sync_name: String, config: SceneReplicationCon
|
||||
# Sync every network tick. ON_CHANGE properties are only sent when they
|
||||
# actually change regardless of this interval.
|
||||
sync.replication_interval = 0.0
|
||||
# Inherit the node's authority rather than defaulting to the server. Items are
|
||||
# server-owned and this changes nothing for them, but a player avatar sets its
|
||||
# authority to the peer it belongs to in _enter_tree — which has already run by
|
||||
# the time we get here — and its synchronizer has to agree, or the owning peer
|
||||
# would be receiving its own head and hands back from the server.
|
||||
sync.set_multiplayer_authority(node.get_multiplayer_authority())
|
||||
node.add_child(sync)
|
||||
|
||||
|
||||
@@ -108,6 +114,47 @@ static func _add(config: SceneReplicationConfig, path: String, spawn: bool, mode
|
||||
config.property_set_replication_mode(np, mode)
|
||||
|
||||
|
||||
## Whether a script comes from a third-party addon rather than this game.
|
||||
##
|
||||
## Addon components are local plumbing, and replicating their configuration is
|
||||
## not merely wasteful — it is actively wrong. godot-xr-tools' snap zones and
|
||||
## pickables both expose a public `enabled`, which is precisely the flag each
|
||||
## peer has to set for ITSELF: a client disables its stations' snap zones because
|
||||
## placement is the server's decision, and disables a pickable another player is
|
||||
## holding. Replicating those meant the server helpfully sent `enabled = true`
|
||||
## straight back over every client's gate, so stations on clients went on
|
||||
## grabbing objects out of the local player's hands.
|
||||
##
|
||||
## Their values are authored in the scene file and therefore already identical on
|
||||
## every peer, so nothing is lost by leaving them alone.
|
||||
static func _is_addon(script: Script) -> bool:
|
||||
return script.resource_path.begins_with("res://addons/")
|
||||
|
||||
|
||||
## Whether a typed array holds something that can cross the wire.
|
||||
##
|
||||
## An array of nodes cannot, and this game has several: ItemContainer's
|
||||
## meal_positions/side_positions are Array[Node3D], and contained_items is
|
||||
## Array[FoodItem]. Replicating one would try to serialise live node references.
|
||||
##
|
||||
## GDScript reports the element type three different ways, so all three are
|
||||
## handled here (verified against the real scripts):
|
||||
## Array[String] hint 23, hint_string "4:" -> element type 4
|
||||
## Array[Node3D] hint 23, hint_string "24/34:Node3D" -> element type 24
|
||||
## Array[FoodItem] hint 31, hint_string "FoodItem" -> a class name
|
||||
## An untyped Array reports an empty hint_string and is excluded too: it can hold
|
||||
## anything, including nodes, so there is no safe answer.
|
||||
static func _is_syncable_array(prop: Dictionary) -> bool:
|
||||
var hint_string := str(prop["hint_string"])
|
||||
if hint_string.is_empty():
|
||||
return false
|
||||
var head := hint_string.split(":")[0].split("/")[0]
|
||||
if not head.is_valid_int():
|
||||
# A bare class name, e.g. "FoodItem".
|
||||
return false
|
||||
return SYNCABLE_TYPES.has(head.to_int()) and head.to_int() != TYPE_ARRAY
|
||||
|
||||
|
||||
## Every "<relative path>:<var>" on `node` and its scripted descendants.
|
||||
## Descends through children but stops at anything carrying its own synchronizer
|
||||
## — that subtree replicates itself and must not be replicated twice.
|
||||
@@ -115,6 +162,11 @@ static func _script_var_paths(root: Node, node: Node) -> Array[String]:
|
||||
var paths: Array[String] = []
|
||||
var prefix: String = "." if node == root else str(root.get_path_to(node))
|
||||
var script: Script = node.get_script() as Script
|
||||
# Note the descent below still happens for an addon-scripted node — only its
|
||||
# own properties are skipped. plate.tscn's root is godot-xr-tools' pickable.gd
|
||||
# and its PlateController child is where the game state actually lives.
|
||||
if script and _is_addon(script):
|
||||
script = null
|
||||
if script:
|
||||
for prop in script.get_script_property_list():
|
||||
var prop_name := str(prop["name"])
|
||||
@@ -124,6 +176,8 @@ static func _script_var_paths(root: Node, node: Node) -> Array[String]:
|
||||
continue
|
||||
if not SYNCABLE_TYPES.has(prop["type"]):
|
||||
continue
|
||||
if prop["type"] == TYPE_ARRAY and not _is_syncable_array(prop):
|
||||
continue
|
||||
paths.append("%s:%s" % [prefix, prop_name])
|
||||
for child in node.get_children():
|
||||
if child is MultiplayerSynchronizer or child is MultiplayerSpawner:
|
||||
|
||||
@@ -0,0 +1,64 @@
|
||||
extends Node
|
||||
class_name NetStations
|
||||
|
||||
## Server-side placement rules for stations. Generic over the "station" group —
|
||||
## there is nothing per-station here, and nothing any individual station scene
|
||||
## has to opt into.
|
||||
##
|
||||
## Placement is a server decision for the same reason cooking is: every peer runs
|
||||
## its own copy of a snap zone, so letting each decide independently means the
|
||||
## same object gets grabbed in two places at once.
|
||||
|
||||
|
||||
## Every snap zone belonging to a station. Some stations (Table) have more than
|
||||
## one, so this is not a one-per-station lookup.
|
||||
static func zones(context: Node) -> Array:
|
||||
var found := []
|
||||
for station in context.get_tree().get_nodes_in_group("station"):
|
||||
for child in station.get_children():
|
||||
if child is XRToolsSnapZone:
|
||||
found.append(child)
|
||||
return found
|
||||
|
||||
|
||||
## Frees an object from whatever station is currently holding it, because
|
||||
## someone has just taken it by hand.
|
||||
static func release_from_zones(context: Node, item: Node) -> void:
|
||||
for zone in zones(context):
|
||||
if zone.picked_up_object == item:
|
||||
zone.drop_object()
|
||||
# Make the zone forget it as well. These zones are snap_mode=RANGE, so
|
||||
# every frame they re-grab anything still listed in their grab area — and
|
||||
# Jolt does NOT emit body_exited when let_go() switches the object's
|
||||
# collision layer back out of the zone's mask, so the entry never clears
|
||||
# on its own. The station then snatches the object straight back off the
|
||||
# player who just took it and teleports it home. Bringing it near again
|
||||
# re-adds it properly, and releasing next to a station is handled
|
||||
# explicitly by try_snap below.
|
||||
if zone._object_in_grab_area.has(item):
|
||||
zone._object_in_grab_area.erase(item)
|
||||
|
||||
|
||||
## Snaps a just-released object into the nearest empty station zone in range.
|
||||
##
|
||||
## Call this DEFERRED. XRToolsFunctionPickup's own "grab an object out of a snap
|
||||
## zone" path calls zone.drop_object() before it calls pick_up() on the hand's
|
||||
## behalf, and drop_object() synchronously fires the `dropped` signal that lands
|
||||
## here. Running inline would immediately re-snap the object into the very zone
|
||||
## it is still physically inside, stealing it before the hand's own pick_up()
|
||||
## later in the same call stack ever runs — leaving the hand pointing at an
|
||||
## object whose grab driver belongs to the zone, which crashes on the next
|
||||
## controller press. The is_picked_up() check below is the second guard, for the
|
||||
## case where something grabs it for real before this runs.
|
||||
static func try_snap(context: Node, item: Node) -> void:
|
||||
if not (item is Node3D) or not is_instance_valid(item):
|
||||
return
|
||||
if item.has_method("is_picked_up") and item.is_picked_up():
|
||||
return
|
||||
for zone in zones(context):
|
||||
if is_instance_valid(zone.picked_up_object):
|
||||
continue
|
||||
if zone.global_position.distance_to(item.global_position) <= zone.grab_distance:
|
||||
NetworkManager.log_line("snapped %s into %s" % [item.name, zone.get_parent().name])
|
||||
zone.pick_up_object(item)
|
||||
return
|
||||
@@ -0,0 +1 @@
|
||||
uid://cgp15pxa7ui1r
|
||||
@@ -0,0 +1,251 @@
|
||||
extends Node
|
||||
class_name NetWorld
|
||||
|
||||
## Owns the replicated contents of the world: what exists, where it lives, and
|
||||
## which peer is allowed to simulate it.
|
||||
##
|
||||
## Everything here runs on Godot's stock MultiplayerSpawner in its DEFAULT mode.
|
||||
## There is no spawn_function and no payload dictionary: the server instantiates
|
||||
## a scene, sets it up, and adds it under the spawn path — the spawner replicates
|
||||
## the creation (and later the deletion) to every peer, including late joiners,
|
||||
## and the synchronizers NetReplication attaches carry the state.
|
||||
##
|
||||
## The two hooks that make this generic, rather than something each object opts
|
||||
## into:
|
||||
##
|
||||
## * content_root.child_entered_tree -> NetReplication.attach, on EVERY peer.
|
||||
## The client's copy is built by the spawner straight from the .tscn, so this
|
||||
## is what gives it synchronizers at all. It also runs early enough for them
|
||||
## to pick up the spawn payload.
|
||||
## * the same hook, on clients only -> _gate. One rule decides what a client is
|
||||
## not allowed to simulate, for any object, whatever it happens to be.
|
||||
|
||||
## Directories scanned for spawnable scenes. Anything in them can be spawned
|
||||
## over the network without being registered by hand anywhere.
|
||||
const SPAWNABLE_DIRS := [
|
||||
"res://Items/",
|
||||
"res://Containers/",
|
||||
"res://Stations/",
|
||||
"res://Prefabs/",
|
||||
]
|
||||
|
||||
var _spawner: MultiplayerSpawner
|
||||
var _content_root: Node
|
||||
|
||||
|
||||
## Wires this up to the world scene's spawner and content root. Must run on every
|
||||
## peer BEFORE it connects, so the spawnable list is identical by the time any
|
||||
## spawn packet can arrive.
|
||||
func setup(spawner: MultiplayerSpawner, content_root: Node) -> void:
|
||||
_spawner = spawner
|
||||
_content_root = content_root
|
||||
_register_spawnables()
|
||||
_content_root.child_entered_tree.connect(_on_content_child_entered)
|
||||
|
||||
|
||||
## Registers every scene under SPAWNABLE_DIRS, sorted.
|
||||
##
|
||||
## The sort is not cosmetic. Auto-spawn puts an INDEX into this list on the wire,
|
||||
## not a path, so a peer whose list is ordered differently instantiates the wrong
|
||||
## scene entirely. Directory listing order is not guaranteed to match across
|
||||
## machines, so it is pinned here.
|
||||
func _register_spawnables() -> void:
|
||||
var scenes: Array[String] = []
|
||||
for dir in SPAWNABLE_DIRS:
|
||||
for file in ResourceLoader.list_directory(dir):
|
||||
if file.ends_with(".tscn"):
|
||||
scenes.append(dir + file)
|
||||
scenes.sort()
|
||||
for scene in scenes:
|
||||
_spawner.add_spawnable_scene(scene)
|
||||
NetworkManager.log_line("Registered %d spawnable scenes" % scenes.size())
|
||||
|
||||
|
||||
func _on_content_child_entered(node: Node) -> void:
|
||||
# Our own synchronizers re-enter here as children of the node, not of the
|
||||
# content root, so this only ever sees spawned roots — but the guard is cheap
|
||||
# and makes the intent explicit.
|
||||
if node is MultiplayerSynchronizer:
|
||||
return
|
||||
NetReplication.attach(node)
|
||||
# Grab handling is wired up centrally, so no scene has to carry a networking
|
||||
# component to be pickable over the network.
|
||||
if node is XRToolsPickable:
|
||||
NetGrab.watch(node)
|
||||
if not NetworkManager.owns_world():
|
||||
_gate(node)
|
||||
# Deferred, in this order, because both depend on the node being fully
|
||||
# constructed: XRToolsPickable captures original_collision_mask in an @onready,
|
||||
# which has not run yet at child_entered_tree time. Reading it now would
|
||||
# record 0 as the object's authored collision mask and it would never collide
|
||||
# with anything again.
|
||||
_remember_authored.call_deferred(node)
|
||||
apply_physics_role.call_deferred(node)
|
||||
|
||||
|
||||
# --- spawning --------------------------------------------------------------
|
||||
|
||||
## Creates a networked object. Server-only when online (the spawner replicates
|
||||
## it from there); works directly when offline.
|
||||
##
|
||||
## `props` are applied BEFORE the node enters the tree, so they ride the spawn
|
||||
## packet as the synchronizer's spawn properties and every peer builds the object
|
||||
## already configured. Note that this means their setters run before the node is
|
||||
## in the tree, where @onready references are still null — any setter reachable
|
||||
## this way has to be null-guarded.
|
||||
func spawn(scene_path: String, xform: Transform3D, node_name: String = "", props: Dictionary = {}) -> Node:
|
||||
if not NetworkManager.owns_world():
|
||||
return null
|
||||
var scene: PackedScene = load(scene_path)
|
||||
if not scene:
|
||||
push_error("NetWorld.spawn: could not load scene %s" % scene_path)
|
||||
return null
|
||||
var inst := scene.instantiate()
|
||||
if node_name != "":
|
||||
inst.name = node_name
|
||||
for key in props:
|
||||
inst.set(key, props[key])
|
||||
if inst is Node3D:
|
||||
inst.transform = xform
|
||||
_content_root.add_child(inst)
|
||||
# global_transform can only be honoured once the node has a parent to be
|
||||
# global relative to. Content roots are normally at the origin, but a debug
|
||||
# scene is free to move one.
|
||||
if inst is Node3D:
|
||||
inst.global_transform = xform
|
||||
NetworkManager.log_line("spawn: %s as %s" % [scene_path.get_file(), inst.name])
|
||||
return inst
|
||||
|
||||
|
||||
## Destroys a networked object everywhere. The spawner broadcasts the despawn
|
||||
## when a tracked node leaves the tree on the authority, so freeing it here is
|
||||
## the whole implementation — there is no despawn RPC any more.
|
||||
##
|
||||
## Callers reach this holding all sorts of nodes (a component such as
|
||||
## DespawningItem, or a visual deep inside a plate), so it walks up to the object
|
||||
## the spawner actually knows about. Getting that wrong used to leave a ghost
|
||||
## copy on every client, which then blocked the station it was sitting in.
|
||||
func despawn(node: Node) -> void:
|
||||
if not NetworkManager.owns_world() or not is_instance_valid(node):
|
||||
return
|
||||
var root := _spawned_root(node)
|
||||
if not root:
|
||||
# Not part of the replicated world at all (a cosmetic copy parented under
|
||||
# a plate, say). Freeing it locally is all that was ever meant.
|
||||
node.queue_free()
|
||||
return
|
||||
NetworkManager.log_line("despawn: %s" % root.name)
|
||||
root.queue_free()
|
||||
|
||||
|
||||
# The ancestor that is a direct child of the content root — i.e. the node the
|
||||
# spawner tracks — or null if this node is not part of the replicated world.
|
||||
func _spawned_root(node: Node) -> Node:
|
||||
var current := node
|
||||
while current:
|
||||
if current.get_parent() == _content_root:
|
||||
return current
|
||||
current = current.get_parent()
|
||||
return null
|
||||
|
||||
|
||||
## Every replicated object currently in the world.
|
||||
func objects() -> Array[Node]:
|
||||
var found: Array[Node] = []
|
||||
if _content_root:
|
||||
for child in _content_root.get_children():
|
||||
found.append(child)
|
||||
return found
|
||||
|
||||
|
||||
# --- what a client is not allowed to simulate ------------------------------
|
||||
|
||||
## The one gating rule, applied to every replicated object on peers that do not
|
||||
## own world logic.
|
||||
##
|
||||
## Stations decide things (what has cooked, what is clean, what snaps where) and
|
||||
## those decisions are the server's, so a client neither runs their logic nor
|
||||
## lets their snap zones grab anything. Without this each peer independently
|
||||
## grabs and simulates the same shared object, and the copies drift apart.
|
||||
##
|
||||
## Note what is NOT here: display code. A client still has to show a lit hob and
|
||||
## a dirty plate, so anything visual must be driven from a replicated value's
|
||||
## setter rather than from _process — which is where it belongs anyway, since
|
||||
## that is the only version that also works for a late joiner.
|
||||
func _gate(node: Node) -> void:
|
||||
if node.is_in_group("station"):
|
||||
node.set_process(false)
|
||||
var zones := _snap_zones_of(node)
|
||||
for zone in zones:
|
||||
zone.enabled = false
|
||||
zone.set_process(false)
|
||||
NetworkManager.log_line("gated %s (%d snap zones)" % [node.name, zones.size()])
|
||||
|
||||
|
||||
func _snap_zones_of(node: Node) -> Array:
|
||||
var zones := []
|
||||
for child in node.get_children():
|
||||
if child is XRToolsSnapZone:
|
||||
zones.append(child)
|
||||
return zones
|
||||
|
||||
|
||||
## Puts a body into the right physics state for whether this peer is currently
|
||||
## driving it, which is exactly "do we own its NetXform".
|
||||
##
|
||||
## The authority IS the state here. The old implementation carried a replicated
|
||||
## `net_held_by` peer id alongside the authority and reconciled the two by hand,
|
||||
## which is what made held items get stuck frozen, or disabled forever, when the
|
||||
## two disagreed. There is only one source of truth now.
|
||||
##
|
||||
## Called when an object is created and again whenever its NetXform changes
|
||||
## hands, which is the complete set of moments the answer can change.
|
||||
func apply_physics_role(node: Node) -> void:
|
||||
if not (node is RigidBody3D):
|
||||
return
|
||||
var xform := node.get_node_or_null(NetReplication.XFORM_NAME)
|
||||
if not xform:
|
||||
return
|
||||
var body: RigidBody3D = node
|
||||
if xform.is_multiplayer_authority():
|
||||
# We simulate it: restore whatever the scene authored. XRToolsPickable
|
||||
# manages freeze and collision itself while an object is actually in a
|
||||
# hand, so a held object is left alone.
|
||||
if body is XRToolsPickable and body.is_picked_up():
|
||||
return
|
||||
body.freeze = false
|
||||
body.freeze_mode = body.get_meta("net_freeze_mode", body.freeze_mode)
|
||||
if body is XRToolsPickable:
|
||||
body.collision_mask = body.original_collision_mask
|
||||
# `enabled` has to be restored explicitly. Nothing else ever writes it
|
||||
# back: the non-authority branch below clears it, so once any peer had
|
||||
# held this object every other peer left it disabled forever. On the
|
||||
# server that quietly broke everything downstream — hands could no
|
||||
# longer pick the object up, while a snap zone still reported having
|
||||
# grabbed it.
|
||||
body.enabled = body.get_meta("net_enabled", body.enabled)
|
||||
return
|
||||
# Someone else drives it: stop simulating and just follow the sync. Kinematic
|
||||
# rather than static so the incoming transform can still move it.
|
||||
if body is XRToolsPickable and body.is_picked_up():
|
||||
body.drop()
|
||||
body.freeze = true
|
||||
body.freeze_mode = RigidBody3D.FREEZE_MODE_KINEMATIC
|
||||
body.collision_mask = 0
|
||||
if body is XRToolsPickable:
|
||||
# Still grabbable if the SERVER owns it, because that just means the object
|
||||
# is lying around loose — being able to pick those up is the entire point.
|
||||
# Only an object held by another player is off limits, and that is exactly
|
||||
# when NetXform belongs to a peer other than 1.
|
||||
body.enabled = xform.get_multiplayer_authority() == 1
|
||||
|
||||
|
||||
# Records the state the scene authored, before gating has a chance to overwrite
|
||||
# it, so reclaiming an object restores what it was built with rather than
|
||||
# whatever the frozen-follower state last forced on it.
|
||||
func _remember_authored(node: Node) -> void:
|
||||
if not (node is RigidBody3D) or node.has_meta("net_freeze_mode"):
|
||||
return
|
||||
node.set_meta("net_freeze_mode", node.freeze_mode)
|
||||
if node is XRToolsPickable:
|
||||
node.set_meta("net_enabled", node.enabled)
|
||||
@@ -0,0 +1 @@
|
||||
uid://bgo0xq4uupuhi
|
||||
+78
-373
@@ -1,36 +1,34 @@
|
||||
extends Node
|
||||
|
||||
## Client-server session manager for VRyHungry (listen-server model).
|
||||
## Session manager for VRyHungry (listen-server model: the host is peer 1 and
|
||||
## also plays).
|
||||
##
|
||||
## Registered as the "NetworkManager" autoload. Owns transport (ENet), tracks
|
||||
## the session, and is the single place that reassigns multiplayer authority
|
||||
## (only the server does so). The world scene (main.gd) registers its spawners
|
||||
## here via [method register_world]; higher layers (players, items, stations)
|
||||
## build on top of this in later phases.
|
||||
## Registered as the "NetworkManager" autoload. This owns the transport and the
|
||||
## session lifecycle, and nothing else — what exists in the world and who is
|
||||
## allowed to simulate it belongs to NetWorld, and interaction belongs to
|
||||
## NetGrab. The spawn_item/despawn_item pair below are deliberately thin
|
||||
## forwards, so game code keeps one obvious place to call.
|
||||
|
||||
const DEFAULT_PORT := 24565
|
||||
const MAX_CLIENTS := 7
|
||||
|
||||
## Emitted on every peer (including the server for its own local player) when a
|
||||
## player peer joins. On the server this fires for each remote peer; the server
|
||||
## uses it to spawn that peer's player.
|
||||
## uses it to spawn that peer's avatar.
|
||||
signal player_joined(peer_id: int)
|
||||
signal player_left(peer_id: int)
|
||||
signal session_started(is_server: bool)
|
||||
signal session_ended()
|
||||
signal connection_failed()
|
||||
|
||||
# World hooks, registered by main.gd once the scene tree exists.
|
||||
var _world: Node = null
|
||||
var _players_spawner: MultiplayerSpawner = null
|
||||
var _items_spawner: MultiplayerSpawner = null
|
||||
var _content_root: Node = null
|
||||
var _net_world: NetWorld = null
|
||||
|
||||
var _log_file: FileAccess
|
||||
|
||||
## Reason the session ended, shown by the menu on the next _ready() (see
|
||||
## Reason the session ended, shown by the menu on its next _ready() (see
|
||||
## take_status). Avoids depending on a live signal connection to a panel that
|
||||
## doesn't exist yet at the moment the session actually ends.
|
||||
## does not exist yet at the moment the session actually ends.
|
||||
var last_status := ""
|
||||
|
||||
|
||||
@@ -43,9 +41,9 @@ func _ready() -> void:
|
||||
multiplayer.server_disconnected.connect(_on_server_disconnected)
|
||||
|
||||
|
||||
# --- Public API ------------------------------------------------------------
|
||||
# --- session ---------------------------------------------------------------
|
||||
|
||||
## Start hosting. The host is peer 1 and also plays (listen server).
|
||||
## Start hosting. The host is peer 1 and also plays.
|
||||
func host(port: int = DEFAULT_PORT) -> Error:
|
||||
var peer := ENetMultiplayerPeer.new()
|
||||
var err := peer.create_server(port, MAX_CLIENTS)
|
||||
@@ -55,8 +53,7 @@ func host(port: int = DEFAULT_PORT) -> Error:
|
||||
multiplayer.multiplayer_peer = peer
|
||||
log_line("HOST started on port %d (peer id %d)" % [port, multiplayer.get_unique_id()])
|
||||
session_started.emit(true)
|
||||
# The host's own local player joins immediately.
|
||||
_on_player_present(multiplayer.get_unique_id())
|
||||
player_joined.emit(multiplayer.get_unique_id())
|
||||
return OK
|
||||
|
||||
|
||||
@@ -79,9 +76,9 @@ func leave() -> void:
|
||||
session_ended.emit()
|
||||
|
||||
|
||||
# Restore Godot's default OfflineMultiplayerPeer (rather than leaving the peer
|
||||
# null), so is_multiplayer_authority()/get_unique_id() keep working while we are
|
||||
# back in single-player / menu state.
|
||||
# Restore Godot's default OfflineMultiplayerPeer rather than leaving the peer
|
||||
# null: is_multiplayer_authority() and get_unique_id() both throw on a null peer,
|
||||
# and plenty of code keeps calling them while we are back in menu state.
|
||||
func _go_offline() -> void:
|
||||
if multiplayer.multiplayer_peer:
|
||||
multiplayer.multiplayer_peer.close()
|
||||
@@ -89,297 +86,6 @@ func _go_offline() -> void:
|
||||
unregister_world()
|
||||
|
||||
|
||||
# --- Item spawning ---------------------------------------------------------
|
||||
|
||||
## Spawn a networked item. Server-only when online (replicates to all peers via
|
||||
## the ItemsSpawner, including late joiners); works directly when offline.
|
||||
## node_name gives the spawned node a deterministic, identical name on every
|
||||
## peer (needed for NodePath-based RPCs to resolve it); props are applied to
|
||||
## the instance before it enters the tree, so exported vars land correctly.
|
||||
## Returns the new node on the machine that owns spawning, else null.
|
||||
func spawn_item(scene_path: String, xform: Transform3D, node_name: String = "", props: Dictionary = {}) -> Node:
|
||||
if is_online() and not is_server():
|
||||
return null
|
||||
var data := {"scene": scene_path, "xform": xform, "name": node_name, "props": props}
|
||||
var via := "spawner" if (is_online() and _items_spawner) else "offline"
|
||||
log_line("spawn_item: %s (name=%s, via=%s)" % [scene_path.get_file(), node_name, via])
|
||||
if is_online() and _items_spawner:
|
||||
return _items_spawner.spawn(data)
|
||||
# Offline: instantiate directly under the registered content root, or (for
|
||||
# scenes that never call register_world, e.g. the offline menu/dev scenes)
|
||||
# the current scene, so this keeps working without every offline scene
|
||||
# needing to opt in.
|
||||
var inst := _spawn_item_from_data(data)
|
||||
if inst:
|
||||
var parent: Node = _content_root if _content_root else get_tree().current_scene
|
||||
if parent:
|
||||
parent.add_child(inst)
|
||||
return inst
|
||||
|
||||
|
||||
## Despawn a server-spawned item. MultiplayerSpawner broadcasts a despawn to
|
||||
## every peer when a tracked node exits the tree on the authority, so this is
|
||||
## the single seam for destroying spawned items (works offline too).
|
||||
func despawn_item(node: Node) -> void:
|
||||
if not owns_world() or not is_instance_valid(node):
|
||||
return
|
||||
log_line("despawn_item: %s" % node.name)
|
||||
# Items that came from the ItemsSpawner are despawned on every peer
|
||||
# automatically when they leave the tree here. Items baked into a scene file
|
||||
# are unknown to the spawner, so their removal has to be broadcast
|
||||
# explicitly — otherwise every client keeps a ghost copy of an item the
|
||||
# server has consumed, which then blocks the station it was sitting in and
|
||||
# gets grabbed instead of the real item that replaced it.
|
||||
if is_online() and not _is_spawner_tracked(node):
|
||||
_despawn_static_item.rpc(node.get_path())
|
||||
node.queue_free()
|
||||
|
||||
|
||||
# Items the ItemsSpawner replicates live under its spawn path; anything else was
|
||||
# baked into the scene file and the spawner knows nothing about it.
|
||||
func _is_spawner_tracked(node: Node) -> bool:
|
||||
return _content_root != null and _content_root.is_ancestor_of(node)
|
||||
|
||||
|
||||
@rpc("authority", "call_remote", "reliable")
|
||||
func _despawn_static_item(path: NodePath) -> void:
|
||||
var node := get_node_or_null(path)
|
||||
if node:
|
||||
log_line("despawn_static_item: freeing %s (the server consumed it)" % node.name)
|
||||
node.queue_free()
|
||||
|
||||
|
||||
# MultiplayerSpawner custom spawn function: runs on every peer to build the node
|
||||
# from the replicated payload.
|
||||
func _spawn_item_from_data(data: Variant) -> Node:
|
||||
var scene: PackedScene = load(data["scene"])
|
||||
if not scene:
|
||||
push_error("spawn_item: could not load scene %s" % str(data.get("scene")))
|
||||
return null
|
||||
var inst := scene.instantiate()
|
||||
if inst is Node3D:
|
||||
inst.transform = data["xform"]
|
||||
if data.get("name", "") != "":
|
||||
inst.name = data["name"]
|
||||
for key in data.get("props", {}):
|
||||
inst.set(key, data["props"][key])
|
||||
if not owns_world():
|
||||
_gate_station(inst)
|
||||
return inst
|
||||
|
||||
|
||||
# Stations run their own logic and auto-grab (XRToolsSnapZone with
|
||||
# snap_mode=RANGE) identically on every peer by default, which would let each
|
||||
# peer independently grab/simulate the same shared object. Disable both on
|
||||
# every peer except the one that owns world logic; the server-authoritative
|
||||
# item-authority RPCs are what let clients still grab a server-held item by
|
||||
# hand. Runs before the node enters the tree, so its own _ready() sees the
|
||||
# final (disabled) state.
|
||||
func _gate_station(node: Node) -> void:
|
||||
if not (node is StaticBody3D):
|
||||
return
|
||||
for child in node.get_children():
|
||||
if child is XRToolsSnapZone:
|
||||
child.enabled = false
|
||||
child.set_process(false)
|
||||
node.set_process(false)
|
||||
log_line("gated station (non-owner peer): %s" % node.name)
|
||||
|
||||
|
||||
## Gate every station already sitting in the scene tree, for peers that don't
|
||||
## own world logic. Stations that arrive through spawn_item() are gated as they
|
||||
## are built (see _spawn_item_from_data), but ones baked into a scene file never
|
||||
## pass through there — leaving a client running its own snap zones, which then
|
||||
## grab items straight out of the local hand and fight the server's
|
||||
## authoritative placement. Idempotent, so it's safe on every session start.
|
||||
func gate_existing_stations() -> void:
|
||||
if owns_world():
|
||||
return
|
||||
for station in get_tree().get_nodes_in_group("station"):
|
||||
_gate_station(station)
|
||||
|
||||
|
||||
# --- Item grab-authority transfer -----------------------------------------
|
||||
|
||||
## Called by NetPickable when this peer grabs an item by hand. Godot rejects
|
||||
## rpc_id() targeting your own peer id ("RPC on yourself is not allowed"), so
|
||||
## when we ARE the server this runs the logic directly instead of round-
|
||||
## tripping an RPC to ourselves — otherwise every host-side grab/drop was
|
||||
## silently failing to run its server-side half (no denial checks, and
|
||||
## crucially no auto-snap-into-station on release).
|
||||
func request_item_authority_from(item_path: NodePath) -> void:
|
||||
if is_server():
|
||||
_grant_or_reject_item_authority(item_path, multiplayer.get_unique_id())
|
||||
else:
|
||||
_request_item_authority_rpc.rpc_id(1, item_path)
|
||||
|
||||
|
||||
@rpc("any_peer", "reliable")
|
||||
func _request_item_authority_rpc(item_path: NodePath) -> void:
|
||||
if not is_server():
|
||||
return
|
||||
_grant_or_reject_item_authority(item_path, multiplayer.get_remote_sender_id())
|
||||
|
||||
|
||||
## Runs on the server (called directly if the requester IS the server, or via
|
||||
## the RPC above otherwise). If the item was snapped into a station, the
|
||||
## station releases it so the grabber cleanly takes ownership.
|
||||
func _grant_or_reject_item_authority(item_path: NodePath, sender: int) -> void:
|
||||
var item := get_node_or_null(item_path)
|
||||
if item:
|
||||
var np := item.get_node_or_null("NetPickable")
|
||||
if np and np.net_held_by != 0 and np.net_held_by != sender:
|
||||
# Already legitimately held by a different live peer: reject the
|
||||
# requester's optimistic client-side grab instead of stealing it.
|
||||
log_line("request_item_authority: DENIED %s to peer %d (already held by %d)" % [item.name, sender, np.net_held_by])
|
||||
_force_release_item_to(sender, item_path)
|
||||
return
|
||||
log_line("request_item_authority: granting %s to peer %d" % [str(item.name) if item else str(item_path), sender])
|
||||
# Assign authority + held state first (disables the item on the server so its
|
||||
# snap zone won't re-grab it), then release it from any station.
|
||||
_set_item_authority.rpc(item_path, sender)
|
||||
if item:
|
||||
_release_from_snap_zones(item)
|
||||
|
||||
|
||||
## Called by NetPickable when this peer releases an item, forwarding its throw
|
||||
## velocity so the server can resume simulating it. Same self-RPC issue as
|
||||
## above: runs directly if we're the server.
|
||||
func release_item_authority_from(item_path: NodePath, lin: Vector3, ang: Vector3, xform: Transform3D) -> void:
|
||||
if is_server():
|
||||
_do_release_item_authority(item_path, lin, ang, xform, multiplayer.get_unique_id())
|
||||
else:
|
||||
_release_item_authority_rpc.rpc_id(1, item_path, lin, ang, xform)
|
||||
|
||||
|
||||
@rpc("any_peer", "reliable")
|
||||
func _release_item_authority_rpc(item_path: NodePath, lin: Vector3, ang: Vector3, xform: Transform3D) -> void:
|
||||
if not is_server():
|
||||
return
|
||||
_do_release_item_authority(item_path, lin, ang, xform, multiplayer.get_remote_sender_id())
|
||||
|
||||
|
||||
## Runs on the server. If released next to a station, the server snaps it in
|
||||
## (server-authoritative placement).
|
||||
func _do_release_item_authority(item_path: NodePath, lin: Vector3, ang: Vector3, xform: Transform3D, sender: int) -> void:
|
||||
log_line("release_item_authority: %s released by peer %d" % [str(item_path), sender])
|
||||
_set_item_authority.rpc(item_path, 1)
|
||||
var item := get_node_or_null(item_path)
|
||||
if item is RigidBody3D:
|
||||
# Adopt the releasing peer's own final transform rather than trusting our
|
||||
# copy's. That peer was the item's authority right up to this moment, and
|
||||
# its position updates travel on the synchronizer's separate, unordered
|
||||
# channel — this reliable RPC routinely overtakes them, leaving our copy
|
||||
# still sitting where the item was BEFORE the peer carried it away. The
|
||||
# snap decision below then reads that stale position and teleports the
|
||||
# item straight back into the station it was just picked up from.
|
||||
item.global_transform = xform
|
||||
item.freeze = false
|
||||
item.linear_velocity = lin
|
||||
item.angular_velocity = ang
|
||||
_try_snap_into_station.call_deferred(item)
|
||||
|
||||
|
||||
# All station snap zones in the world (every XRToolsSnapZone child of a node in
|
||||
# the "station" group — some stations, e.g. Table, have more than one).
|
||||
func _station_snap_zones() -> Array:
|
||||
var zones := []
|
||||
for station in get_tree().get_nodes_in_group("station"):
|
||||
for child in station.get_children():
|
||||
if child is XRToolsSnapZone:
|
||||
zones.append(child)
|
||||
return zones
|
||||
|
||||
|
||||
# If the item is snapped into any station, drop it from that station.
|
||||
func _release_from_snap_zones(item: Node) -> void:
|
||||
for zone in _station_snap_zones():
|
||||
if zone.picked_up_object == item:
|
||||
log_line("releasing %s from %s's snap zone (authority just granted elsewhere)" % [item.name, zone.get_parent().name])
|
||||
zone.drop_object()
|
||||
# Make the zone forget the item as well. These zones are snap_mode=RANGE,
|
||||
# so every frame they re-grab anything still listed in their grab area
|
||||
# that can be picked up — and Jolt does not emit body_exited when let_go()
|
||||
# switches the item's collision layer back out of the zone's mask, so the
|
||||
# entry goes stale and never clears. The station then snatches the item
|
||||
# straight back off the player who just took it, teleporting it home.
|
||||
# Bringing it near again re-adds it properly (a held item is on the layer
|
||||
# the zone watches), and releasing next to a station is handled
|
||||
# explicitly by _try_snap_into_station.
|
||||
if zone._object_in_grab_area.has(item):
|
||||
zone._object_in_grab_area.erase(item)
|
||||
|
||||
|
||||
# Snap the item into the nearest empty station snap zone within grab range.
|
||||
#
|
||||
# Called deferred from _do_release_item_authority: XRToolsFunctionPickup's own
|
||||
# "grab an item out of a snap zone" path calls zone.drop_object() BEFORE it
|
||||
# calls pick_up() on the hand's behalf. drop_object()'s let_go() synchronously
|
||||
# fires the pickable's `dropped` signal, which (via NetPickable) lands here —
|
||||
# if this ran synchronously it would immediately re-snap the item into the
|
||||
# very same zone it's still physically inside, stealing it away before the
|
||||
# hand's own pick_up() call (later in the same call stack) ever runs. That
|
||||
# leaves XRToolsFunctionPickup.picked_up_object pointing at an item whose
|
||||
# _grab_driver actually belongs to the zone — a stale reference that crashes
|
||||
# (null _grab_driver) the next time a controller button is pressed. Deferring
|
||||
# lets the hand's pick_up() go first; the is_picked_up() check below is a
|
||||
# second guard in case the item gets grabbed for real before this runs.
|
||||
func _try_snap_into_station(item: Node) -> void:
|
||||
if not (item is Node3D):
|
||||
return
|
||||
if item.has_method("is_picked_up") and item.is_picked_up():
|
||||
var by: Node = null
|
||||
if item.has_method("get_picked_up_by"):
|
||||
by = item.get_picked_up_by()
|
||||
log_line("skipped snapping %s: already held by %s (grab-race guard)" % [item.name, by.get_path() if by else "?"])
|
||||
return
|
||||
for zone in _station_snap_zones():
|
||||
if is_instance_valid(zone.picked_up_object):
|
||||
continue
|
||||
if zone.global_position.distance_to(item.global_position) <= zone.grab_distance:
|
||||
log_line("snapped %s into %s" % [item.name, zone.get_parent().name])
|
||||
zone.pick_up_object(item)
|
||||
return
|
||||
log_line("no station in range to snap %s into (or none empty)" % item.name)
|
||||
|
||||
|
||||
# Server broadcasts an authority assignment so every peer agrees on who owns the
|
||||
# item (set_multiplayer_authority is a local call and must run everywhere).
|
||||
@rpc("authority", "call_local", "reliable")
|
||||
func _set_item_authority(item_path: NodePath, peer: int) -> void:
|
||||
var item := get_node_or_null(item_path)
|
||||
if not item:
|
||||
return
|
||||
log_line("_set_item_authority: %s -> peer %d" % [item.name, peer])
|
||||
item.set_multiplayer_authority(peer) # recursive: item + synchronizer + NetPickable
|
||||
var np := item.get_node_or_null("NetPickable")
|
||||
if np:
|
||||
np.net_held_by = 0 if peer == 1 else peer
|
||||
np.apply_held_state()
|
||||
|
||||
|
||||
## Rejects peer's optimistic grab (the item was already legitimately held by
|
||||
## someone else). Same self-RPC concern: if the rejected peer is the server
|
||||
## itself, apply it directly rather than rpc_id-ing ourselves.
|
||||
func _force_release_item_to(peer: int, item_path: NodePath) -> void:
|
||||
if peer == 1:
|
||||
_do_force_release(item_path)
|
||||
else:
|
||||
force_release_item.rpc_id(peer, item_path)
|
||||
|
||||
|
||||
@rpc("authority", "reliable")
|
||||
func force_release_item(item_path: NodePath) -> void:
|
||||
_do_force_release(item_path)
|
||||
|
||||
|
||||
func _do_force_release(item_path: NodePath) -> void:
|
||||
log_line("force_release_item: dropping %s (server rejected our grab)" % str(item_path))
|
||||
var item := get_node_or_null(item_path)
|
||||
if item and item.has_method("drop"):
|
||||
item.drop()
|
||||
|
||||
|
||||
func is_server() -> bool:
|
||||
return is_online() and multiplayer.is_server()
|
||||
|
||||
@@ -392,71 +98,69 @@ func is_online() -> bool:
|
||||
|
||||
|
||||
## True on the machine that owns authoritative world logic: the server when
|
||||
## online, or the single player when offline. Station logic and spawning should
|
||||
## only run where this is true, so state has one source of truth.
|
||||
## online, or the single player when offline. Station logic and spawning only run
|
||||
## where this is true, so state has one source of truth.
|
||||
func owns_world() -> bool:
|
||||
return not is_online() or is_server()
|
||||
|
||||
|
||||
# --- Station work-progress seam -------------------------------------------
|
||||
# --- world -----------------------------------------------------------------
|
||||
|
||||
## Reusable entry point for a client to contribute work to a station (e.g. a
|
||||
## future chopping/gesture station). The client detects the gesture locally and
|
||||
## calls this; the server validates and accumulates. Timer-driven stations like
|
||||
## the Hob don't need it, but it is the drop-in seam for input-driven ones.
|
||||
@rpc("any_peer", "reliable")
|
||||
func submit_work(station_path: NodePath, amount: float) -> void:
|
||||
if not is_server():
|
||||
return
|
||||
var station := get_node_or_null(station_path)
|
||||
if station and station.has_method("add_work"):
|
||||
log_line("submit_work: peer %d contributed %.2f to %s" % [multiplayer.get_remote_sender_id(), amount, station.name])
|
||||
station.add_work(multiplayer.get_remote_sender_id(), amount)
|
||||
|
||||
|
||||
## Called by the world scene once it's ready, passing its spawners. Must run
|
||||
## before world_ready()/host()/join() on every peer so the custom spawn
|
||||
## function is installed before any spawn packet can arrive.
|
||||
func register_world(world: Node, players_spawner: MultiplayerSpawner, items_spawner: MultiplayerSpawner) -> void:
|
||||
## Called by the world scene once its tree exists. Must run before
|
||||
## world_ready()/host()/join() on every peer, so the spawnable scene list is
|
||||
## registered before any spawn packet can arrive.
|
||||
func register_world(world: Node, net_world: NetWorld) -> void:
|
||||
_world = world
|
||||
_players_spawner = players_spawner
|
||||
_items_spawner = items_spawner
|
||||
_content_root = items_spawner.get_node(items_spawner.spawn_path) if items_spawner else world
|
||||
if _items_spawner:
|
||||
_items_spawner.spawn_function = _spawn_item_from_data
|
||||
log_line("World registered (players_spawner=%s items_spawner=%s)" % [str(players_spawner != null), str(items_spawner != null)])
|
||||
_net_world = net_world
|
||||
log_line("World registered")
|
||||
|
||||
|
||||
## Called when the world scene goes away (disconnect, leaving the session) so
|
||||
## the autoload doesn't hold stale/freed references across a scene reload.
|
||||
## Called when the world scene goes away (disconnect, leaving the session) so the
|
||||
## autoload does not hold freed references across a scene reload.
|
||||
func unregister_world() -> void:
|
||||
_world = null
|
||||
_content_root = null
|
||||
_players_spawner = null
|
||||
_items_spawner = null
|
||||
_net_world = null
|
||||
|
||||
|
||||
## Returns the reason the last session ended (if any) and clears it. The menu
|
||||
## pulls this on its own _ready() rather than depending on a live signal
|
||||
## connection to a panel that doesn't exist yet when the session ends.
|
||||
func take_status() -> String:
|
||||
var s := last_status
|
||||
last_status = ""
|
||||
return s
|
||||
## Creates a networked object. See NetWorld.spawn.
|
||||
func spawn_item(scene_path: String, xform: Transform3D, node_name: String = "", props: Dictionary = {}) -> Node:
|
||||
if not _net_world:
|
||||
push_error("spawn_item called with no world registered: %s" % scene_path)
|
||||
return null
|
||||
return _net_world.spawn(scene_path, xform, node_name, props)
|
||||
|
||||
|
||||
## Called by main.gd after it has registered the world and connected its
|
||||
## player_joined/left listeners. Kicks off any menu- or command-line-driven
|
||||
## session so that session signals never fire before the world is listening.
|
||||
## Destroys a networked object everywhere. See NetWorld.despawn.
|
||||
func despawn_item(node: Node) -> void:
|
||||
if _net_world:
|
||||
_net_world.despawn(node)
|
||||
|
||||
|
||||
## Puts an object into the right physics state for whether this peer drives it.
|
||||
func apply_physics_role(node: Node) -> void:
|
||||
if _net_world:
|
||||
_net_world.apply_physics_role(node)
|
||||
|
||||
|
||||
## Every replicated object currently in the world.
|
||||
func replicated_objects() -> Array[Node]:
|
||||
if not _net_world:
|
||||
return []
|
||||
return _net_world.objects()
|
||||
|
||||
|
||||
## Called by the world scene after it has registered itself and connected its
|
||||
## listeners. Kicks off any menu- or command-line-driven session, so session
|
||||
## signals never fire before the world is listening for them.
|
||||
func world_ready() -> void:
|
||||
consume_pending_session()
|
||||
|
||||
|
||||
# --- Menu-driven session request -------------------------------------------
|
||||
# --- menu-driven session request -------------------------------------------
|
||||
|
||||
# Set by the main menu's Host/Join buttons before switching to the multiplayer
|
||||
# scene; consumed once that scene's world is ready to listen for session
|
||||
# signals (avoids a race between change_scene_to_file and connection callbacks).
|
||||
# scene; consumed once that scene is ready to listen for session signals (avoids
|
||||
# a race between change_scene_to_file and the connection callbacks).
|
||||
var pending_action := ""
|
||||
var pending_ip := ""
|
||||
|
||||
@@ -478,18 +182,29 @@ func consume_pending_session() -> void:
|
||||
_handle_cmdline()
|
||||
|
||||
|
||||
# --- Session signal handlers ----------------------------------------------
|
||||
## Returns the reason the last session ended (if any) and clears it. The menu
|
||||
## pulls this on its own _ready() rather than depending on a live signal
|
||||
## connection to a panel that does not exist yet when the session ends.
|
||||
func take_status() -> String:
|
||||
var s := last_status
|
||||
last_status = ""
|
||||
return s
|
||||
|
||||
|
||||
# --- session signal handlers ----------------------------------------------
|
||||
|
||||
func _on_peer_connected(peer_id: int) -> void:
|
||||
log_line("peer_connected: %d" % peer_id)
|
||||
# Only the server reacts by materialising that peer's player.
|
||||
if is_server():
|
||||
_on_player_present(peer_id)
|
||||
player_joined.emit(peer_id)
|
||||
|
||||
func _on_peer_disconnected(peer_id: int) -> void:
|
||||
log_line("peer_disconnected: %d" % peer_id)
|
||||
if is_server():
|
||||
_on_player_absent(peer_id)
|
||||
# Anything still in their hand would otherwise stay frozen on every
|
||||
# remaining peer, waiting on an authority that has gone.
|
||||
NetGrab.reclaim_from(peer_id)
|
||||
player_left.emit(peer_id)
|
||||
|
||||
func _on_connected_to_server() -> void:
|
||||
log_line("connected_to_server (my id=%d)" % multiplayer.get_unique_id())
|
||||
@@ -508,18 +223,7 @@ func _on_server_disconnected() -> void:
|
||||
session_ended.emit()
|
||||
|
||||
|
||||
# Player materialise/dematerialise. Phase 2 wires these to the PlayersSpawner;
|
||||
# for now they announce presence so the transport layer is independently testable.
|
||||
func _on_player_present(peer_id: int) -> void:
|
||||
log_line("player_present: %d" % peer_id)
|
||||
player_joined.emit(peer_id)
|
||||
|
||||
func _on_player_absent(peer_id: int) -> void:
|
||||
log_line("player_absent: %d" % peer_id)
|
||||
player_left.emit(peer_id)
|
||||
|
||||
|
||||
# --- Command-line driven test bootstrap -----------------------------------
|
||||
# --- command-line driven test bootstrap -----------------------------------
|
||||
|
||||
func _handle_cmdline() -> void:
|
||||
var args := OS.get_cmdline_user_args()
|
||||
@@ -535,7 +239,7 @@ func _handle_cmdline() -> void:
|
||||
join(addr)
|
||||
|
||||
|
||||
# --- Logging ---------------------------------------------------------------
|
||||
# --- logging ---------------------------------------------------------------
|
||||
|
||||
func _open_log() -> void:
|
||||
var dir := OS.get_environment("TEMP")
|
||||
@@ -547,6 +251,7 @@ func _open_log() -> void:
|
||||
_log_file = FileAccess.open(path, FileAccess.WRITE)
|
||||
log_line("=== NetworkManager log (pid %d) ===" % OS.get_process_id())
|
||||
|
||||
|
||||
func log_line(s: String) -> void:
|
||||
var id := 0
|
||||
var p := multiplayer.multiplayer_peer
|
||||
|
||||
+55
-131
@@ -1,155 +1,79 @@
|
||||
extends Node
|
||||
class_name WorldLayout
|
||||
|
||||
## Data-driven description of what's in the multiplayer world. The server (or
|
||||
## the single machine, when offline) spawns every entry through
|
||||
## NetworkManager.spawn_item() instead of baking these into the scene file, so
|
||||
## a joining client receives them from the server rather than assuming its own
|
||||
## copy of the scene matches. Swapping the contents of these two functions is
|
||||
## the only change needed for a future varying/procedural layout.
|
||||
## Reads the kitchen a scene file authored and describes it as data, so the
|
||||
## server can respawn it as replicated objects.
|
||||
##
|
||||
## Positions below are transcribed verbatim from the previous baked layout in
|
||||
## Scenes/multiPlayer.tscn so the starting world is unchanged.
|
||||
## The authored nodes are a template, not the live world. Baking them into the
|
||||
## scene would mean each peer ran its own unsynced copy; spawning them means the
|
||||
## client receives the server's, through the same path as a mid-session join.
|
||||
|
||||
## Directories whose scenes count as world content, and the base type to look for
|
||||
## in each. Anything instanced from these is picked up automatically — adding a
|
||||
## new station or item needs no change here.
|
||||
const SOURCES := [
|
||||
{"dir": "res://Stations/", "type": "StaticBody3D"},
|
||||
{"dir": "res://Items/", "type": "XRToolsPickable"},
|
||||
{"dir": "res://Containers/", "type": "XRToolsPickable"},
|
||||
]
|
||||
|
||||
|
||||
func get_node_data(node):
|
||||
# {"scene": "res://Stations/Hob.tscn", "name": "Hob",
|
||||
# "xform": Transform3D(Basis(), Vector3(0.29336345, 0.8981018, -1.484)), "props": {}},
|
||||
var data = {}
|
||||
data["scene"] = node.scene_file_path
|
||||
data["name"] = node.name
|
||||
# global, not local: the copies are respawned under WorldContent, so an
|
||||
# authored node that was nested inside another (JonScene parents Counter5
|
||||
# under Counter3) would otherwise land in the wrong place.
|
||||
data["xform"] = node.global_transform
|
||||
data["props"] = {}
|
||||
var scrip = node.get_script()
|
||||
if scrip:
|
||||
for i in scrip.get_script_property_list():
|
||||
# Only authored configuration — i.e. @export vars, which are the ones
|
||||
# the editor exposes. Plain script variables are live runtime state:
|
||||
# copying those and replaying them into a fresh instance re-runs their
|
||||
# setters before the node is in the tree, so any setter touching an
|
||||
# @onready reference blows up (Table's _state calls into its progress
|
||||
# bar, which is still null at that point).
|
||||
if not (i.usage & PROPERTY_USAGE_EDITOR):
|
||||
continue
|
||||
if str(i["name"]).begins_with("_"):
|
||||
continue
|
||||
data["props"][i["name"]] = node.get(i["name"])
|
||||
return data
|
||||
|
||||
|
||||
## The authored station nodes sitting in the current scene: anything instanced
|
||||
## from res://Stations/. Exposed as nodes (not just data) because every peer has
|
||||
## to remove these originals — the server replaces them with replicated copies,
|
||||
## and a client that kept its own would end up showing two of everything.
|
||||
func get_station_nodes() -> Array[Node]:
|
||||
return _authored_nodes("res://Stations/", "StaticBody3D")
|
||||
|
||||
|
||||
## Likewise for authored items. Containers/ counts as items too — plates and
|
||||
## trays are things the player carries, and a client that never received one
|
||||
## would have an incomplete world.
|
||||
func get_item_nodes() -> Array[Node]:
|
||||
var found := _authored_nodes("res://Items/", "XRToolsPickable")
|
||||
found.append_array(_authored_nodes("res://Containers/", "XRToolsPickable"))
|
||||
## Every authored node in the current scene, stations first.
|
||||
##
|
||||
## Order matters: stations have to exist before items, so an item spawning on top
|
||||
## of one lands in a snap zone that is already there.
|
||||
func get_authored_nodes() -> Array[Node]:
|
||||
var found: Array[Node] = []
|
||||
for source in SOURCES:
|
||||
for node in _instances_of(source["dir"], source["type"]):
|
||||
if not found.has(node):
|
||||
found.append(node)
|
||||
return found
|
||||
|
||||
|
||||
func _authored_nodes(dir: String, type: String) -> Array[Node]:
|
||||
func _instances_of(dir: String, type: String) -> Array[Node]:
|
||||
var scenes := []
|
||||
for file in ResourceLoader.list_directory(dir):
|
||||
scenes.append(dir + file)
|
||||
var found: Array[Node] = []
|
||||
for node in get_tree().root.find_children("*", type, true, false):
|
||||
if node.scene_file_path in scenes and not found.has(node):
|
||||
if node.scene_file_path in scenes:
|
||||
found.append(node)
|
||||
return found
|
||||
|
||||
|
||||
func get_stations() -> Array[Dictionary]:
|
||||
## Turns authored nodes into spawn descriptions.
|
||||
func describe(nodes: Array[Node]) -> Array[Dictionary]:
|
||||
var data: Array[Dictionary] = []
|
||||
for node in get_station_nodes():
|
||||
data.append(get_node_data(node))
|
||||
for node in nodes:
|
||||
data.append(_describe_one(node))
|
||||
return data
|
||||
|
||||
|
||||
func get_items() -> Array[Dictionary]:
|
||||
var data: Array[Dictionary] = []
|
||||
for node in get_item_nodes():
|
||||
data.append(get_node_data(node))
|
||||
return data
|
||||
func _describe_one(node: Node) -> Dictionary:
|
||||
return {
|
||||
"scene": node.scene_file_path,
|
||||
"name": node.name,
|
||||
# Global, not local: the copies are respawned under one content root, so
|
||||
# an authored node nested inside another (JonScene parents Counter5 under
|
||||
# Counter3) would otherwise land in the wrong place.
|
||||
"xform": node.global_transform,
|
||||
"props": _authored_props(node),
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
static func get_stations_old() -> Array[Dictionary]:
|
||||
return [
|
||||
{"scene": "res://Stations/Hob.tscn", "name": "Hob",
|
||||
"xform": Transform3D(Basis(), Vector3(0.29336345, 0.8981018, -1.484)), "props": {}},
|
||||
{"scene": "res://Stations/BurgerBunsDispenser.tscn", "name": "BurgerBunsDispenser",
|
||||
"xform": Transform3D(Basis(), Vector3(-1.832131, 0.40028095, -1.4813508)), "props": {}},
|
||||
{"scene": "res://Stations/sink.tscn", "name": "Sink",
|
||||
"xform": Transform3D(Basis(), Vector3(1.3140475, 0.9061539, -1.4941733)), "props": {}},
|
||||
{"scene": "res://Stations/dirt_station.tscn", "name": "DirtStation",
|
||||
"xform": Transform3D(Basis(), Vector3(2.0864775, 0.8981018, -1.244947)), "props": {}},
|
||||
{"scene": "res://Stations/Counter.tscn", "name": "Counter",
|
||||
"xform": Transform3D(Basis(), Vector3(-0.7124918, 0.90304357, -1.4886917)), "props": {}},
|
||||
{"scene": "res://Stations/Counter.tscn", "name": "Counter2",
|
||||
"xform": Transform3D(Vector3(-4.371139e-08, 0.0, 1.0), Vector3(0.0, 1.0, 0.0), Vector3(-1.0, 0.0, -4.371139e-08), Vector3(-1.7648025, 0.90304357, -0.4458799)), "props": {}},
|
||||
{"scene": "res://Stations/Counter.tscn", "name": "Counter3",
|
||||
"xform": Transform3D(Vector3(-4.371139e-08, 0.0, 1.0), Vector3(0.0, 1.0, 0.0), Vector3(-1.0, 0.0, -4.371139e-08), Vector3(-1.7648025, 0.90304357, 0.55367994)), "props": {}},
|
||||
{"scene": "res://Stations/Counter.tscn", "name": "Counter4",
|
||||
"xform": Transform3D(Vector3(-4.371139e-08, 0.0, 1.0), Vector3(0.0, 1.0, 0.0), Vector3(-1.0, 0.0, -4.371139e-08), Vector3(-1.7648025, 0.90304357, 1.5539298)), "props": {}},
|
||||
{"scene": "res://Stations/table.tscn", "name": "Table",
|
||||
"xform": Transform3D(Basis(), Vector3(1.633146, 0.9030438, 1.1343781)),
|
||||
"props": {
|
||||
"initial_thinking_time": 8.0,
|
||||
"initial_primary_time": 40.0,
|
||||
"initial_friend_time": 3.0,
|
||||
"initial_eating_time": 3.0,
|
||||
}},
|
||||
]
|
||||
|
||||
|
||||
static func get_items_old() -> Array[Dictionary]:
|
||||
var items: Array[Dictionary] = []
|
||||
|
||||
items.append(_item("res://Items/BurgerBuns.tscn", "BurgerBuns", Vector3(-1.8162017, 1.6081157, -1.4714175)))
|
||||
items.append(_item("res://Items/BurgerBuns.tscn", "BurgerBuns2", Vector3(-1.3596323, 1.4110342, -0.22482127)))
|
||||
|
||||
items.append(_item("res://Containers/plate.tscn", "Plate", Vector3(-1.5717233, 1.5454081, 1.5373346)))
|
||||
items.append(_item("res://Containers/plate.tscn", "Plate2", Vector3(-1.5730225, 1.499024, 0.59790254)))
|
||||
items.append(_item("res://Containers/plate.tscn", "Plate3", Vector3(-1.5818124, 1.499024, -0.4634577)))
|
||||
|
||||
items.append(_item("res://Items/burger.tscn", "burger", Vector3(0.6888188, 1.4195822, -1.7110313)))
|
||||
items.append(_item("res://Items/burger.tscn", "burger2", Vector3(0.6931299, 1.5300478, -1.71225)))
|
||||
items.append(_item("res://Items/burger.tscn", "burger3", Vector3(0.69027674, 1.4969791, -1.7210286)))
|
||||
items.append(_item("res://Items/burger.tscn", "burger4", Vector3(0.69134104, 1.4543622, -1.7210286)))
|
||||
|
||||
items.append(_item("res://Items/hamburger.tscn", "Hamburger", Vector3(-1.9352558, 1.623975, 1.2447833)))
|
||||
items.append(_item("res://Items/hamburger.tscn", "Hamburger2", Vector3(-1.9857153, 1.5329368, 0.9472374)))
|
||||
items.append(_item("res://Items/hamburger.tscn", "Hamburger3", Vector3(-1.7201865, 1.5329367, 0.14773655)))
|
||||
|
||||
items.append(_item("res://Items/cooked_burger.tscn", "CookedBurger", Vector3(-0.30671906, 1.4131018, -1.0928738)))
|
||||
items.append(_item("res://Items/cooked_burger.tscn", "CookedBurger2", Vector3(-0.30671906, 1.4496142, -1.0928738)))
|
||||
items.append(_item("res://Items/cooked_burger.tscn", "CookedBurger3", Vector3(-1.3344773, 1.4398065, -0.7096845)))
|
||||
items.append(_item("res://Items/cooked_burger.tscn", "CookedBurger4", Vector3(-0.30671906, 1.525444, -1.0928738)))
|
||||
|
||||
items.append(_item("res://Items/PickupCube.tscn", "PickableObject", Vector3(0.6225724, 1.4792972, -1.0473135)))
|
||||
items.append(_item("res://Items/PickupCube.tscn", "PickableObject2", Vector3(0.6359743, 1.4639391, -1.1673055)))
|
||||
items.append(_item("res://Items/PickupCube.tscn", "PickableObject3", Vector3(0.5142721, 1.4792972, -1.0473135)))
|
||||
items.append(_item("res://Items/PickupCube.tscn", "PickableObject4", Vector3(0.5276739, 1.4639391, -1.1673055)))
|
||||
items.append(_item("res://Items/PickupCube.tscn", "PickableObject5", Vector3(0.73287535, 1.4792972, -1.0473135)))
|
||||
items.append(_item("res://Items/PickupCube.tscn", "PickableObject6", Vector3(0.7462772, 1.4639391, -1.1673055)))
|
||||
items.append(_item("res://Items/PickupCube.tscn", "PickableObject7", Vector3(-1.3556751, 1.4792972, 0.28881657)))
|
||||
items.append(_item("res://Items/PickupCube.tscn", "PickableObject8", Vector3(-1.3422732, 1.4639391, 0.16882455)))
|
||||
items.append(_item("res://Items/PickupCube.tscn", "PickableObject9", Vector3(-1.4639754, 1.4792972, 0.28881657)))
|
||||
items.append(_item("res://Items/PickupCube.tscn", "PickableObject10", Vector3(-1.4505737, 1.4639391, 0.16882455)))
|
||||
|
||||
return items
|
||||
|
||||
|
||||
static func _item(scene: String, name: String, pos: Vector3) -> Dictionary:
|
||||
return {"scene": scene, "name": name, "xform": Transform3D(Basis(), pos), "props": {}}
|
||||
# Only authored configuration — @export vars, the ones the editor exposes. Plain
|
||||
# script variables are live runtime state, and replaying those into a fresh
|
||||
# instance re-runs their setters before the node is in the tree, where any setter
|
||||
# touching an @onready reference blows up.
|
||||
func _authored_props(node: Node) -> Dictionary:
|
||||
var props := {}
|
||||
var script: Script = node.get_script() as Script
|
||||
if not script:
|
||||
return props
|
||||
for prop in script.get_script_property_list():
|
||||
var prop_name := str(prop["name"])
|
||||
if not (prop["usage"] & PROPERTY_USAGE_EDITOR) or prop_name.begins_with("_"):
|
||||
continue
|
||||
props[prop_name] = node.get(prop_name)
|
||||
return props
|
||||
|
||||
Reference in New Issue
Block a user