M2.3: the shared world (trees, pickups, pieces, chests, fires, doors, graves, clock on the server)
This commit is contained in:
Paul Bailey
626
scripts/net/world_net.gd
Normal file
626
scripts/net/world_net.gd
Normal file
@@ -0,0 +1,626 @@
|
||||
extends Node
|
||||
## Autoload "WorldNet": the shared world (M2.3, docs/MULTIPLAYER_PLAN.md §5).
|
||||
##
|
||||
## A dedicated server runs the real world scene headless, with no player of its
|
||||
## own (world.gd `server_mode`). It owns everything in the island that changes:
|
||||
## trees and rocks (damage, felling, regrowth), pickups, berry bushes, dropped
|
||||
## items, building pieces, chests and graves, fires, doors and the clock. The
|
||||
## weather follows from the seed and the clock, so it needs no syncing.
|
||||
##
|
||||
## Clients ask; the server checks, applies and tells everyone:
|
||||
## client -> server _c2s_hit uid server -> all _s2c_node uid hp
|
||||
## client -> server _c2s_place item server -> all _s2c_piece_added {...}
|
||||
## ...and so on for each kind of change (the _c2s_* / _s2c_* pairs below).
|
||||
## When a change earns the asker something (wood from a tree, a pickup, a
|
||||
## dismantled wall back), the server sends it to them with _s2c_give.
|
||||
##
|
||||
## Inventories, stats and crafting stay on each player's own game until M2.4,
|
||||
## so the server trusts what a client says it puts into the world (a placed
|
||||
## wall, a chest deposit) but decides everything it takes out.
|
||||
##
|
||||
## On joining, a client's world asks for a snapshot (_c2s_world) once its
|
||||
## scenery is up; from then on it gets every change, in order.
|
||||
|
||||
const REACH := 3.2 + 2.5 ## Actions._in_reach, plus slack for latency
|
||||
const SLACK := 2.0
|
||||
const MAX_HIT := 12.0 ## no tool hits harder than this
|
||||
const FIRE_SYNC := 10.0 ## seconds between fire fuel updates
|
||||
const SAVE_AFTER := 10.0 ## seconds after a change before saving
|
||||
const FUELS := ["wood", "stick", "fiber"]
|
||||
|
||||
var world: Node3D ## server: its world; client: ours while online
|
||||
var pieces: Dictionary = {} ## net id -> piece (both sides)
|
||||
var dropped: Dictionary = {} ## net id -> dropped pickup (both sides)
|
||||
var _next_nid := 1
|
||||
var _ready_peers: Dictionary = {} ## server: peers that have their snapshot
|
||||
var _fire_left := FIRE_SYNC
|
||||
var _blocker_left := 0.0
|
||||
var _save_left := INF ## counting down to a save after a change
|
||||
var _chest_cb := Callable() ## client: waiting for a chest click's result
|
||||
var chest_busy := false
|
||||
|
||||
## Counters the tests read.
|
||||
var received := 0 ## client: world events applied
|
||||
|
||||
func is_server() -> bool:
|
||||
return Net.is_server() and world != null
|
||||
|
||||
func is_client() -> bool:
|
||||
return Net.state == "connected" and world != null and is_instance_valid(world)
|
||||
|
||||
# --- server: the world -----------------------------------------------------------
|
||||
|
||||
## Loads (or creates) the server's world from its config and adds it to the
|
||||
## tree. Saves live next to server.json, in worlds/<world>/.
|
||||
func open_server_world(config: RefCounted) -> Node3D:
|
||||
Saves.root_dir = config.path.get_base_dir().path_join("worlds")
|
||||
var id := String(config.v("world")).validate_filename()
|
||||
if id.is_empty():
|
||||
id = "server-world"
|
||||
Saves.current_id = Saves.open_or_create(id, int(config.v("seed")))
|
||||
var w: Node3D = load("res://scenes/world.tscn").instantiate()
|
||||
w.server_mode = true
|
||||
w.day_length = float(config.v("day_length_minutes")) * 60.0
|
||||
w.autosave_seconds = maxf(float(config.v("autosave_minutes")), 0.5) * 60.0
|
||||
get_tree().root.add_child(w)
|
||||
world = w
|
||||
pieces.clear()
|
||||
dropped.clear()
|
||||
_ready_peers.clear()
|
||||
_next_nid = 1
|
||||
for p in w.all_pieces():
|
||||
if p.has_meta("nid"):
|
||||
_next_nid = maxi(_next_nid, int(p.get_meta("nid")) + 1)
|
||||
for p in w.all_pieces():
|
||||
if not p.has_meta("nid"):
|
||||
p.set_meta("nid", _new_nid())
|
||||
pieces[int(p.get_meta("nid"))] = p
|
||||
for d in w.all_dropped():
|
||||
if not d.has_meta("nid"):
|
||||
d.set_meta("nid", _new_nid())
|
||||
dropped[int(d.get_meta("nid"))] = d
|
||||
_next_nid = maxi(_next_nid, _max_nid() + 1)
|
||||
w.props.regrown.connect(_on_regrown)
|
||||
var args: Dictionary = Net.parse_args(OS.get_cmdline_user_args())
|
||||
if args.has("debug-regrow"):
|
||||
w.props.regrow_scale = float(args["debug-regrow"]) # (tests: things grow back in seconds)
|
||||
print("[server] world '%s' (seed %d): %d pieces, %d dropped items. Saves: %s" % [Saves.current_id,
|
||||
w.terrain.noise_seed, pieces.size(), dropped.size(), ProjectSettings.globalize_path(Saves.root_dir)])
|
||||
return w
|
||||
|
||||
func close_server_world() -> void:
|
||||
if world == null:
|
||||
return
|
||||
if Net.is_server() and is_instance_valid(world):
|
||||
save()
|
||||
if is_instance_valid(world):
|
||||
world.queue_free()
|
||||
world = null
|
||||
pieces.clear()
|
||||
dropped.clear()
|
||||
_ready_peers.clear()
|
||||
|
||||
func save() -> void:
|
||||
_save_left = INF
|
||||
if world != null and is_instance_valid(world) and world.server_mode:
|
||||
world.save_now()
|
||||
|
||||
func _new_nid() -> int:
|
||||
_next_nid += 1
|
||||
return _next_nid - 1
|
||||
|
||||
func _max_nid() -> int:
|
||||
var m := 0
|
||||
for k in pieces:
|
||||
m = maxi(m, k)
|
||||
for k in dropped:
|
||||
m = maxi(m, k)
|
||||
return m
|
||||
|
||||
## A player left: they no longer get events. Save while it's fresh.
|
||||
func peer_left(peer: int) -> void:
|
||||
_ready_peers.erase(peer)
|
||||
save()
|
||||
|
||||
func _process(delta: float) -> void:
|
||||
if not is_server():
|
||||
return
|
||||
# Pause the island while nobody's on (fires, regrowth, the clock).
|
||||
var paused: bool = Net.players.is_empty() and bool(Net.config.v("pause_when_empty"))
|
||||
world.process_mode = Node.PROCESS_MODE_DISABLED if paused else Node.PROCESS_MODE_INHERIT
|
||||
if paused:
|
||||
return
|
||||
_blocker_left -= delta
|
||||
if _blocker_left <= 0.0:
|
||||
_blocker_left = 1.0
|
||||
var at: Array = []
|
||||
for peer in Net.players:
|
||||
at.append(Net.player_pos(peer))
|
||||
world.props.blockers = at # nothing regrows on top of a player
|
||||
_save_left -= delta
|
||||
if _save_left <= 0.0:
|
||||
_save_left = INF
|
||||
save()
|
||||
_fire_left -= delta
|
||||
if _fire_left <= 0.0:
|
||||
_fire_left = FIRE_SYNC
|
||||
var fires: Array = []
|
||||
for nid in pieces:
|
||||
var p: Node3D = pieces[nid]
|
||||
if is_instance_valid(p) and p.get("fuel") != null:
|
||||
fires.append([nid, p.fuel])
|
||||
if not fires.is_empty():
|
||||
_all("_s2c_fires", [fires])
|
||||
|
||||
## Sends to every player who has their snapshot. Any change to the island
|
||||
## also means saving soon: Ctrl+C kills Godot without a chance to save, so
|
||||
## this keeps the loss to a few seconds.
|
||||
func _all(method: String, args: Array) -> void:
|
||||
if method != "_s2c_fires" and _save_left == INF:
|
||||
_save_left = SAVE_AFTER
|
||||
for peer in _ready_peers:
|
||||
callv("rpc_id", [peer, method] + args)
|
||||
|
||||
func _give_to(peer: int, items: Dictionary) -> void:
|
||||
var clean := {}
|
||||
for id in items:
|
||||
if int(items[id]) > 0:
|
||||
clean[id] = int(items[id])
|
||||
if not clean.is_empty():
|
||||
_s2c_give.rpc_id(peer, clean)
|
||||
|
||||
func _tell(peer: int, text: String) -> void:
|
||||
_s2c_notify.rpc_id(peer, text)
|
||||
|
||||
## The asker, if they're a player in the world (else 0).
|
||||
func _asker() -> int:
|
||||
var peer := multiplayer.get_remote_sender_id()
|
||||
if not is_server() or not _ready_peers.has(peer):
|
||||
return 0
|
||||
return peer
|
||||
|
||||
func _near(peer: int, at: Vector3, r: float) -> bool:
|
||||
return Net.player_pos(peer).distance_to(at) <= r + SLACK
|
||||
|
||||
func _piece(nid: int) -> Node3D:
|
||||
var p: Node3D = pieces.get(nid)
|
||||
if p == null or not is_instance_valid(p) or p.is_queued_for_deletion():
|
||||
pieces.erase(nid)
|
||||
return null
|
||||
return p
|
||||
|
||||
func _entry(p: Node3D) -> Dictionary:
|
||||
return world.piece_entry(p)
|
||||
|
||||
static func _clean_stack(s: Variant) -> Variant:
|
||||
if not s is Dictionary:
|
||||
return null
|
||||
var id := String(s.get("id", ""))
|
||||
var n := int(s.get("count", 0))
|
||||
if ItemDB.get_item(id).is_empty() or n <= 0:
|
||||
return null
|
||||
return {"id": id, "count": mini(n, ItemDB.stack_size(id))}
|
||||
|
||||
static func _empty(inv: Inventory) -> bool:
|
||||
for s in inv.slots:
|
||||
if s != null:
|
||||
return false
|
||||
return true
|
||||
|
||||
# --- client -> server -------------------------------------------------------------
|
||||
|
||||
@rpc("any_peer", "call_remote", "reliable")
|
||||
func _c2s_world() -> void:
|
||||
var peer := multiplayer.get_remote_sender_id()
|
||||
if not is_server() or not Net.players.has(peer):
|
||||
return
|
||||
_ready_peers[peer] = true
|
||||
_s2c_world.rpc_id(peer, world.collect_shared())
|
||||
|
||||
@rpc("any_peer", "call_remote", "reliable")
|
||||
func _c2s_hit(uid: String, damage: float, point: Vector3) -> void:
|
||||
var peer := _asker()
|
||||
var n: Node3D = world.props.resource_nodes.get(uid) if peer != 0 else null
|
||||
if n == null or not is_instance_valid(n) or n.depleted:
|
||||
return
|
||||
if not _near(peer, point, 3.2 + 1.0) or point.distance_to(n.global_position) > 6.0:
|
||||
return
|
||||
var from: Vector3 = Net.player_pos(peer)
|
||||
var drops: Dictionary = n.hit(clampf(damage, 0.0, MAX_HIT), point, from)
|
||||
_give_to(peer, drops)
|
||||
_all("_s2c_node", [uid, n.hp, point, from])
|
||||
|
||||
@rpc("any_peer", "call_remote", "reliable")
|
||||
func _c2s_take(key: String) -> void:
|
||||
var peer := _asker()
|
||||
if peer == 0:
|
||||
return
|
||||
var pk: Node3D = _find_pickup(key)
|
||||
if pk == null or pk.taken or not _near(peer, pk.global_position, REACH):
|
||||
return
|
||||
var got := {pk.item_id: pk.amount}
|
||||
if key.begins_with("#"):
|
||||
dropped.erase(int(key.substr(1)))
|
||||
pk.collected()
|
||||
_give_to(peer, got)
|
||||
_all("_s2c_taken", [key])
|
||||
|
||||
func _find_pickup(key: String) -> Node3D:
|
||||
var pk: Node3D
|
||||
if key.begins_with("#"):
|
||||
pk = dropped.get(int(key.substr(1)))
|
||||
else:
|
||||
pk = world.props.pickups.get(key) if world != null else null
|
||||
return pk if pk != null and is_instance_valid(pk) else null
|
||||
|
||||
@rpc("any_peer", "call_remote", "reliable")
|
||||
func _c2s_forage(uid: String) -> void:
|
||||
var peer := _asker()
|
||||
var bush: Node3D = world.props.forage.get(uid) if peer != 0 else null
|
||||
if bush == null or not bush.ripe() or not _near(peer, bush.global_position, REACH):
|
||||
return
|
||||
_give_to(peer, bush.harvest())
|
||||
_all("_s2c_forage", [uid, bush.regrow_left])
|
||||
|
||||
## Places `item` at `xf`. The client has already taken it out of its
|
||||
## inventory: if it can't go here, it's given back. A grave carries what the
|
||||
## player was holding when they died.
|
||||
@rpc("any_peer", "call_remote", "reliable")
|
||||
func _c2s_place(item: String, xf: Transform3D, contents: Array) -> void:
|
||||
var peer := _asker()
|
||||
if peer == 0:
|
||||
return
|
||||
var def: Dictionary = ItemDB.get_item(item)
|
||||
if def.is_empty() or not def.has("place"):
|
||||
return
|
||||
# (A grave can be further off: drowning puts it on the nearest shore.)
|
||||
var ok := xf.origin.is_finite() and _near(peer, xf.origin, 40.0 if item == "grave" else 8.0)
|
||||
if item == "grave":
|
||||
ok = ok and not contents.is_empty()
|
||||
else:
|
||||
ok = ok and world.placement_valid(def, xf)
|
||||
if not ok:
|
||||
if item != "grave":
|
||||
_give_to(peer, {item: 1})
|
||||
_tell(peer, "Can't place that here")
|
||||
return
|
||||
var p: Node3D = world.spawn_piece(def, xf.orthonormalized())
|
||||
if item == "grave" and p.get("inventory") != null:
|
||||
var clean: Array = []
|
||||
for s in contents.slice(0, p.inventory.size()):
|
||||
clean.append(_clean_stack(s))
|
||||
p.inventory.load_data(clean)
|
||||
p.set_meta("nid", _new_nid())
|
||||
pieces[int(p.get_meta("nid"))] = p
|
||||
_all("_s2c_piece_added", [_entry(p)])
|
||||
|
||||
@rpc("any_peer", "call_remote", "reliable")
|
||||
func _c2s_dismantle(nid: int) -> void:
|
||||
var peer := _asker()
|
||||
var p: Node3D = _piece(nid) if peer != 0 else null
|
||||
if p == null or not _near(peer, p.global_position, 8.0) or p.item_id == "grave":
|
||||
return
|
||||
var why: String = p.dismantle_block_reason()
|
||||
if not why.is_empty():
|
||||
_tell(peer, why)
|
||||
return
|
||||
# Whatever loses its support collapses: those come back to you too.
|
||||
var items := {}
|
||||
for k in pieces:
|
||||
if _piece(k) != null:
|
||||
items[k] = pieces[k].item_id
|
||||
world.remove_piece(p, null)
|
||||
var gone: Array = []
|
||||
var fell: Array = []
|
||||
var refund := {}
|
||||
for k in items:
|
||||
if _piece(k) == null:
|
||||
gone.append(k)
|
||||
refund[items[k]] = refund.get(items[k], 0) + 1
|
||||
if k != nid:
|
||||
fell.append(k)
|
||||
_all("_s2c_pieces_removed", [gone, fell])
|
||||
_give_to(peer, refund)
|
||||
|
||||
@rpc("any_peer", "call_remote", "reliable")
|
||||
func _c2s_door(nid: int) -> void:
|
||||
var peer := _asker()
|
||||
var p: Node3D = _piece(nid) if peer != 0 else null
|
||||
if p == null or p.get("open") == null or not _near(peer, p.global_position, REACH + 1.0):
|
||||
return
|
||||
p.set_open(not p.open)
|
||||
_all("_s2c_piece_state", [nid, p.save_extra()])
|
||||
|
||||
@rpc("any_peer", "call_remote", "reliable")
|
||||
func _c2s_fuel(nid: int, item: String) -> void:
|
||||
var peer := _asker()
|
||||
if peer == 0 or not item in FUELS:
|
||||
return
|
||||
var p := _piece(nid)
|
||||
if p == null or p.get("fuel") == null or not _near(peer, p.global_position, REACH) \
|
||||
or p.fuel >= p.MAX_FUEL - 1.0:
|
||||
_give_to(peer, {item: 1})
|
||||
return
|
||||
p.add_fuel(float(ItemDB.get_item(item).get("fuel", 10)))
|
||||
_all("_s2c_piece_state", [nid, p.save_extra()])
|
||||
|
||||
## A click on a chest slot while holding `cursor`: the same as clicking in
|
||||
## your own inventory (pick up, put down, swap). The new cursor comes back.
|
||||
@rpc("any_peer", "call_remote", "reliable")
|
||||
func _c2s_chest_click(nid: int, slot: int, cursor: Variant, right: bool) -> void:
|
||||
var peer := _asker()
|
||||
if peer == 0:
|
||||
return
|
||||
var c: Variant = _clean_stack(cursor)
|
||||
var p := _piece(nid)
|
||||
if p == null or p.get("inventory") == null or slot < 0 or slot >= p.inventory.size() \
|
||||
or not _near(peer, p.global_position, REACH + 1.0):
|
||||
_s2c_cursor.rpc_id(peer, c) # nothing happened: keep what you were holding
|
||||
return
|
||||
var res: Variant = p.inventory.click(slot, c, right)
|
||||
_s2c_cursor.rpc_id(peer, res)
|
||||
_chest_changed(nid, p)
|
||||
|
||||
## Shift-click from your inventory: as much of `stack` as fits goes in, the
|
||||
## rest comes back.
|
||||
@rpc("any_peer", "call_remote", "reliable")
|
||||
func _c2s_chest_put(nid: int, stack: Variant) -> void:
|
||||
var peer := _asker()
|
||||
var s: Variant = _clean_stack(stack)
|
||||
if peer == 0 or s == null:
|
||||
return
|
||||
var p := _piece(nid)
|
||||
if p == null or p.get("inventory") == null or not _near(peer, p.global_position, REACH + 1.0):
|
||||
_give_to(peer, {s.id: s.count})
|
||||
return
|
||||
var left: int = p.inventory.add(s.id, s.count)
|
||||
_give_to(peer, {s.id: left})
|
||||
_chest_changed(nid, p)
|
||||
|
||||
## Shift-click on a chest slot: up to `room` of it comes to you.
|
||||
@rpc("any_peer", "call_remote", "reliable")
|
||||
func _c2s_chest_take(nid: int, slot: int, room: int) -> void:
|
||||
var peer := _asker()
|
||||
var p: Node3D = _piece(nid) if peer != 0 else null
|
||||
if p == null or p.get("inventory") == null or slot < 0 or slot >= p.inventory.size() or room <= 0 \
|
||||
or not _near(peer, p.global_position, REACH + 1.0):
|
||||
return
|
||||
var s: Variant = p.inventory.get_slot(slot)
|
||||
if s == null:
|
||||
return
|
||||
var id: String = s.id
|
||||
var n: int = p.inventory.take_from(slot, room)
|
||||
_give_to(peer, {id: n})
|
||||
_chest_changed(nid, p)
|
||||
|
||||
func _chest_changed(nid: int, p: Node3D) -> void:
|
||||
_all("_s2c_chest", [nid, p.inventory.to_data()])
|
||||
# An emptied grave crumbles.
|
||||
if p.item_id == "grave" and _empty(p.inventory):
|
||||
world.remove_piece(p, null)
|
||||
pieces.erase(nid)
|
||||
_all("_s2c_pieces_removed", [[nid], []])
|
||||
|
||||
## Something the player put down in the world: an arrow that landed, a fish
|
||||
## that didn't fit. Anyone can pick it up.
|
||||
@rpc("any_peer", "call_remote", "reliable")
|
||||
func _c2s_drop(item: String, count: int, xf: Transform3D) -> void:
|
||||
var peer := _asker()
|
||||
if peer == 0 or ItemDB.get_item(item).is_empty() or count <= 0 or count > 999 \
|
||||
or not xf.origin.is_finite() or not _near(peer, xf.origin, 60.0):
|
||||
return # (60 m: an arrow can land a long way off)
|
||||
var d: Node3D = world.drop_item(item, count, xf.orthonormalized())
|
||||
d.set_meta("nid", _new_nid())
|
||||
dropped[int(d.get_meta("nid"))] = d
|
||||
_all("_s2c_dropped", [world.dropped_entry(d)])
|
||||
|
||||
func _on_regrown(uid: String) -> void:
|
||||
_all("_s2c_regrown", [uid])
|
||||
|
||||
# --- client: asking ----------------------------------------------------------------
|
||||
|
||||
## Our world is up: ask for the shared state.
|
||||
func join_world(w: Node3D) -> void:
|
||||
world = w
|
||||
pieces.clear()
|
||||
dropped.clear()
|
||||
chest_busy = false
|
||||
_chest_cb = Callable()
|
||||
received = 0
|
||||
_c2s_world.rpc_id(1)
|
||||
|
||||
func leave_world() -> void:
|
||||
if not Net.is_server():
|
||||
world = null
|
||||
pieces.clear()
|
||||
dropped.clear()
|
||||
|
||||
func hit(node: Node3D, damage: float, point: Vector3) -> void:
|
||||
_c2s_hit.rpc_id(1, String(node.uid), damage, point)
|
||||
|
||||
## The key the server knows a pickup by: its scenery id, or "#<net id>".
|
||||
func pickup_key(pk: Node3D) -> String:
|
||||
return "#%d" % int(pk.get_meta("nid")) if pk.has_meta("nid") else String(pk.uid)
|
||||
|
||||
func take(pk: Node3D) -> void:
|
||||
_c2s_take.rpc_id(1, pickup_key(pk))
|
||||
|
||||
func forage(bush: Node3D) -> void:
|
||||
_c2s_forage.rpc_id(1, String(bush.uid))
|
||||
|
||||
func place(item: String, xf: Transform3D, contents: Array = []) -> void:
|
||||
_c2s_place.rpc_id(1, item, xf, contents)
|
||||
|
||||
static func nid(p: Node3D) -> int:
|
||||
return int(p.get_meta("nid", 0))
|
||||
|
||||
func dismantle(p: Node3D) -> void:
|
||||
_c2s_dismantle.rpc_id(1, nid(p))
|
||||
|
||||
func door(p: Node3D) -> void:
|
||||
_c2s_door.rpc_id(1, nid(p))
|
||||
|
||||
func fuel(p: Node3D, item: String) -> void:
|
||||
_c2s_fuel.rpc_id(1, nid(p), item)
|
||||
|
||||
## `done(cursor)` gets what you're holding afterwards.
|
||||
func chest_click(p: Node3D, slot: int, cursor: Variant, right: bool, done: Callable) -> void:
|
||||
chest_busy = true
|
||||
_chest_cb = done
|
||||
_c2s_chest_click.rpc_id(1, nid(p), slot, cursor, right)
|
||||
|
||||
func chest_put(p: Node3D, stack: Dictionary) -> void:
|
||||
_c2s_chest_put.rpc_id(1, nid(p), stack)
|
||||
|
||||
func chest_take(p: Node3D, slot: int, room: int) -> void:
|
||||
_c2s_chest_take.rpc_id(1, nid(p), slot, room)
|
||||
|
||||
func drop(item: String, count: int, xf: Transform3D) -> void:
|
||||
_c2s_drop.rpc_id(1, item, count, xf)
|
||||
|
||||
# --- server -> client ------------------------------------------------------------
|
||||
|
||||
@rpc("authority", "call_remote", "reliable")
|
||||
func _s2c_world(state: Dictionary) -> void:
|
||||
if not is_client():
|
||||
return
|
||||
world.apply_shared(state)
|
||||
pieces.clear()
|
||||
dropped.clear()
|
||||
for p in world.all_pieces():
|
||||
if p.has_meta("nid"):
|
||||
pieces[int(p.get_meta("nid"))] = p
|
||||
for d in world.all_dropped():
|
||||
if d.has_meta("nid"):
|
||||
dropped[int(d.get_meta("nid"))] = d
|
||||
received += 1
|
||||
|
||||
@rpc("authority", "call_remote", "reliable")
|
||||
func _s2c_node(uid: String, hp: float, point: Vector3, from: Vector3) -> void:
|
||||
if not is_client():
|
||||
return
|
||||
var n: Node3D = world.props.resource_nodes.get(uid)
|
||||
if n != null and is_instance_valid(n):
|
||||
n.apply_remote(hp, point, from)
|
||||
received += 1
|
||||
|
||||
@rpc("authority", "call_remote", "reliable")
|
||||
func _s2c_regrown(uid: String) -> void:
|
||||
if not is_client():
|
||||
return
|
||||
var n: Node3D = world.props.pickups.get(uid, world.props.resource_nodes.get(uid))
|
||||
if n != null and is_instance_valid(n):
|
||||
world.props.regrow.erase(uid)
|
||||
n.regrow()
|
||||
received += 1
|
||||
|
||||
@rpc("authority", "call_remote", "reliable")
|
||||
func _s2c_taken(key: String) -> void:
|
||||
if not is_client():
|
||||
return
|
||||
var pk := _find_pickup(key)
|
||||
if key.begins_with("#"):
|
||||
dropped.erase(int(key.substr(1)))
|
||||
if pk != null:
|
||||
pk.collected()
|
||||
received += 1
|
||||
|
||||
@rpc("authority", "call_remote", "reliable")
|
||||
func _s2c_forage(uid: String, left: float) -> void:
|
||||
if not is_client():
|
||||
return
|
||||
var bush: Node3D = world.props.forage.get(uid)
|
||||
if bush != null:
|
||||
bush.restore(left)
|
||||
received += 1
|
||||
|
||||
@rpc("authority", "call_remote", "reliable")
|
||||
func _s2c_piece_added(e: Dictionary) -> void:
|
||||
if not is_client():
|
||||
return
|
||||
var p: Node3D = world.add_piece_entry(e)
|
||||
if p != null:
|
||||
pieces[int(e.nid)] = p
|
||||
received += 1
|
||||
|
||||
@rpc("authority", "call_remote", "reliable")
|
||||
func _s2c_pieces_removed(nids: Array, fell: Array) -> void:
|
||||
if not is_client():
|
||||
return
|
||||
var gone: Array = []
|
||||
for k in nids:
|
||||
var p: Node3D = pieces.get(int(k))
|
||||
pieces.erase(int(k))
|
||||
if p != null and is_instance_valid(p):
|
||||
gone.append(p)
|
||||
var collapsed: Array = []
|
||||
for k in fell:
|
||||
collapsed.append(int(k))
|
||||
world.remove_pieces_net(gone, collapsed)
|
||||
received += 1
|
||||
|
||||
@rpc("authority", "call_remote", "reliable")
|
||||
func _s2c_piece_state(nid_: int, extra: Dictionary) -> void:
|
||||
if not is_client():
|
||||
return
|
||||
var p: Node3D = pieces.get(nid_)
|
||||
if p == null or not is_instance_valid(p):
|
||||
return
|
||||
if extra.has("open") and p.has_method("set_open"):
|
||||
p.set_open(bool(extra.open))
|
||||
elif p.has_method("load_extra"):
|
||||
p.load_extra(extra)
|
||||
received += 1
|
||||
|
||||
@rpc("authority", "call_remote", "reliable")
|
||||
func _s2c_fires(fires: Array) -> void:
|
||||
if not is_client():
|
||||
return
|
||||
for f in fires:
|
||||
var p: Node3D = pieces.get(int(f[0]))
|
||||
if p != null and is_instance_valid(p) and p.has_method("load_extra"):
|
||||
p.load_extra({"fuel": float(f[1])})
|
||||
|
||||
@rpc("authority", "call_remote", "reliable")
|
||||
func _s2c_chest(nid_: int, data: Array) -> void:
|
||||
if not is_client():
|
||||
return
|
||||
var p: Node3D = pieces.get(nid_)
|
||||
if p != null and is_instance_valid(p) and p.get("inventory") != null:
|
||||
p.inventory.load_data(data)
|
||||
received += 1
|
||||
|
||||
@rpc("authority", "call_remote", "reliable")
|
||||
func _s2c_dropped(e: Dictionary) -> void:
|
||||
if not is_client():
|
||||
return
|
||||
var d: Node3D = world.add_dropped_entry(e)
|
||||
if d != null:
|
||||
dropped[int(e.nid)] = d
|
||||
received += 1
|
||||
|
||||
## Items the server decided we earned. Anything that doesn't fit goes back
|
||||
## on the ground at our feet (for anyone to pick up).
|
||||
@rpc("authority", "call_remote", "reliable")
|
||||
func _s2c_give(items: Dictionary) -> void:
|
||||
if not is_client():
|
||||
return
|
||||
for id in items:
|
||||
var n := int(items[id])
|
||||
var got: int = Actions._give(world.player, String(id), n)
|
||||
if got < n:
|
||||
drop(String(id), n - got, Transform3D(Basis(), world.player.global_position + Vector3(0, 0.1, 0)))
|
||||
|
||||
@rpc("authority", "call_remote", "reliable")
|
||||
func _s2c_cursor(stack: Variant) -> void:
|
||||
chest_busy = false
|
||||
var cb := _chest_cb
|
||||
_chest_cb = Callable()
|
||||
if cb.is_valid():
|
||||
cb.call(stack)
|
||||
elif stack != null and is_client():
|
||||
_s2c_give({stack.id: stack.count})
|
||||
|
||||
@rpc("authority", "call_remote", "reliable")
|
||||
func _s2c_notify(text: String) -> void:
|
||||
Actions.notify.emit(text)
|
||||
Reference in New Issue
Block a user