Fresh start: replace with naxIO/netfox-cs-sample foundation
Complete replacement of the tactical-shooter project with the netfox-cs-sample (MIT) — a CS 1.6 inspired multiplayer FPS built with Godot 4 and netfox. ## What's new - Full CS-style gameplay: teams (T/CT), rounds, economy, buy menu - 6 weapons: Knife, Glock, USP, AK-47, M4A1, AWP - Bomb plant/defuse with 2 bombsites - Flashbang & smoke grenades - Proper netfox rollback netcode at 64 tick - Network popup UI for host/join - HUD, crosshair, round timer, scoreboard - All netfox singletons registered as autoloads (works in exported builds) ## Architecture - Listen-server (host from client, no dedicated server binary) - Multiplayer-fps game lives at examples/multiplayer-fps/ - Netfox addons registered as autoloads for exported build compat - Godot 4.7 with Forward+ renderer ## Removed - Old headless-server architecture (client_main, server_main, player.gd, etc.) - Custom netfox bootstrap with ENet fallback - Old ChaffGames FPS template (2,420 lines, 844 KB) - SimulationServer GDExtension stub - Godot-jolt physics (netfox sample uses default Godot physics) - Duplicate weapon_data.gd, anti_cheat.gd, round_manager.gd, etc. - Server browser API Python venv (87 MB) - test_range map and modular assets ## Preserved - Git history - Server config at config/default_server_config.cfg - Windows export preset - Build directory (gitignored) Co-authored-by: naxIO <naxIO@users.noreply.github.com>
This commit is contained in:
@@ -0,0 +1,49 @@
|
||||
class_name _NetworkIdentifier
|
||||
extends RefCounted
|
||||
|
||||
var _subject: Object
|
||||
var _full_name: String
|
||||
var _ids: Dictionary = {} # peer to id
|
||||
var _local_id: int
|
||||
|
||||
signal on_id(peer: int, id: int)
|
||||
|
||||
func _init(subject: Object, full_name: String, local_id: int, local_peer: int):
|
||||
_subject = subject
|
||||
_full_name = full_name
|
||||
_local_id = local_id
|
||||
_ids[local_peer] = local_id
|
||||
|
||||
func has_id_for(peer: int) -> bool:
|
||||
return _ids.has(peer)
|
||||
|
||||
func get_id_for(peer: int) -> int:
|
||||
return _ids.get(peer, -1)
|
||||
|
||||
func set_id_for(peer: int, id: int) -> void:
|
||||
assert(not _ids.has(peer), "ID for peer #%d is already set!" % [peer])
|
||||
_ids[peer] = id
|
||||
on_id.emit(peer, id)
|
||||
|
||||
func get_local_id() -> int:
|
||||
return _local_id
|
||||
|
||||
func get_full_name() -> String:
|
||||
return _full_name
|
||||
|
||||
func get_subject() -> Object:
|
||||
return _subject
|
||||
|
||||
func get_known_peers() -> Array[int]:
|
||||
var result := [] as Array[int]
|
||||
result.assign(_ids.keys())
|
||||
return result
|
||||
|
||||
func reference_for(peer: int) -> _NetworkIdentityReference:
|
||||
if has_id_for(peer):
|
||||
return _NetworkIdentityReference.of_id(get_id_for(peer))
|
||||
else:
|
||||
return _NetworkIdentityReference.of_full_name(get_full_name())
|
||||
|
||||
func _to_string() -> String:
|
||||
return "NetworkIdentifier(%s)" % [_full_name]
|
||||
@@ -0,0 +1 @@
|
||||
uid://gnyygflpr78h
|
||||
@@ -0,0 +1,35 @@
|
||||
class_name _NetworkIdentityReference
|
||||
extends RefCounted
|
||||
|
||||
var _full_name: String = ""
|
||||
var _id: int = -1
|
||||
|
||||
static func of_full_name(full_name: String) -> _NetworkIdentityReference:
|
||||
var reference := _NetworkIdentityReference.new()
|
||||
reference._full_name = full_name
|
||||
return reference
|
||||
|
||||
static func of_id(id: int) -> _NetworkIdentityReference:
|
||||
var reference := _NetworkIdentityReference.new()
|
||||
reference._id = id
|
||||
return reference
|
||||
|
||||
func has_id() -> bool:
|
||||
return _id >= 0
|
||||
|
||||
func get_id() -> int:
|
||||
return _id
|
||||
|
||||
func get_full_name() -> String:
|
||||
return _full_name
|
||||
|
||||
func equals(other: Variant) -> bool:
|
||||
if other is _NetworkIdentityReference:
|
||||
return _full_name == other._full_name and _id == other._id
|
||||
return false
|
||||
|
||||
func _to_string() -> String:
|
||||
if has_id():
|
||||
return "NetworkIdentityReference#%d" % [_id]
|
||||
else:
|
||||
return "NetworkIdentityReference(%s)" % [_full_name]
|
||||
@@ -0,0 +1 @@
|
||||
uid://c6eyaau5r8g51
|
||||
@@ -0,0 +1,47 @@
|
||||
extends RefCounted
|
||||
class_name _ObjectSnapshot
|
||||
|
||||
# Represents snapshot data for a single object, by storing the object's values
|
||||
# for specified properties
|
||||
|
||||
var _object: Object
|
||||
var _is_auth: bool = false
|
||||
var _data: Dictionary = {}
|
||||
|
||||
func _init(p_object: Object) -> void:
|
||||
_object = p_object
|
||||
|
||||
func duplicate() -> _ObjectSnapshot:
|
||||
var result := _ObjectSnapshot.new(_object)
|
||||
result._is_auth = _is_auth
|
||||
result._data = _data.duplicate()
|
||||
return result
|
||||
|
||||
func get_value(property: NodePath, default: Variant = null) -> Variant:
|
||||
return _data.get(property, default)
|
||||
|
||||
func set_value(property: NodePath, value: Variant) -> void:
|
||||
_data[property] = value
|
||||
|
||||
func has_value(property: NodePath) -> bool:
|
||||
return _data.has(property)
|
||||
|
||||
func record_property(property: NodePath) -> void:
|
||||
set_value(property, _object.get_indexed(property))
|
||||
|
||||
func apply() -> void:
|
||||
for property in properties():
|
||||
var value := get_value(property)
|
||||
_object.set_indexed(property, value)
|
||||
|
||||
func is_auth() -> bool:
|
||||
return _is_auth
|
||||
|
||||
func set_auth(p_auth: bool) -> void:
|
||||
_is_auth = p_auth
|
||||
|
||||
func properties() -> Array:
|
||||
return _data.keys()
|
||||
|
||||
func _to_string() -> String:
|
||||
return "ObjectSnapshot(%s(%d), %s, %s)" % [_object, (_object as Node).get_multiplayer_authority() if _object is Node else -1, _is_auth, _data]
|
||||
@@ -0,0 +1 @@
|
||||
uid://bx4b8w54gleym
|
||||
@@ -0,0 +1,103 @@
|
||||
extends RefCounted
|
||||
class_name _PerObjectHistory
|
||||
|
||||
# Stores a per-object history of ObjectSnapshots
|
||||
# Each managed object has its own timeline of snapshots
|
||||
|
||||
var _history_size: int
|
||||
var _data := {} # Object to _HistoryBuffer
|
||||
|
||||
func _init(p_history_size: int):
|
||||
_history_size = p_history_size
|
||||
|
||||
func subjects() -> Array[Object]:
|
||||
var result := [] as Array[Object]
|
||||
result.assign(_data.keys())
|
||||
return result
|
||||
|
||||
func is_auth(tick: int, subject: Object) -> bool:
|
||||
if not _data.has(subject):
|
||||
return false
|
||||
|
||||
var history := _data[subject] as _HistoryBuffer
|
||||
if not history.has_at(tick):
|
||||
return false
|
||||
|
||||
var snapshot := history.get_at(tick) as _ObjectSnapshot
|
||||
return snapshot.is_auth()
|
||||
|
||||
func erase_subject(subject: Object) -> void:
|
||||
_data.erase(subject)
|
||||
|
||||
func ensure_snapshot(tick: int, subject: Object, carry_forward: bool) -> _ObjectSnapshot:
|
||||
var has_subject := _data.has(subject)
|
||||
if not _data.has(subject):
|
||||
_data[subject] = _HistoryBuffer.new(_history_size)
|
||||
|
||||
var history := _data[subject] as _HistoryBuffer
|
||||
var has_tick := history.has_at(tick)
|
||||
var has_latest := history.has_latest_at(tick)
|
||||
|
||||
if not history.has_at(tick):
|
||||
if not history.has_latest_at(tick):
|
||||
history.set_at(tick, _ObjectSnapshot.new(subject))
|
||||
elif carry_forward:
|
||||
history.set_at(tick, history.get_latest_at(tick).duplicate())
|
||||
else:
|
||||
history.set_at(tick, _ObjectSnapshot.new(subject))
|
||||
|
||||
assert(history.get_at(tick) != null, "Failed to ensure snapshot!")
|
||||
return history.get_at(tick) as _ObjectSnapshot
|
||||
|
||||
func get_latest_snapshot(tick: int, subject: Object) -> _ObjectSnapshot:
|
||||
if not _data.has(subject):
|
||||
return null
|
||||
|
||||
var history := _data[subject] as _HistoryBuffer
|
||||
if not history.has_latest_at(tick):
|
||||
return null
|
||||
|
||||
return history.get_latest_at(tick) as _ObjectSnapshot
|
||||
|
||||
func get_latest_tick(tick: int, subject: Object) -> int:
|
||||
if not _data.has(subject):
|
||||
return -1
|
||||
|
||||
var history := _data[subject] as _HistoryBuffer
|
||||
if not history.has_latest_at(tick):
|
||||
return -1
|
||||
|
||||
return history.get_latest_index_at(tick)
|
||||
|
||||
func set_property(tick: int, subject: Object, property: NodePath, value: Variant) -> void:
|
||||
if not _data.has(subject):
|
||||
_data[subject] = _HistoryBuffer.new(_history_size)
|
||||
|
||||
var history := _data[subject] as _HistoryBuffer
|
||||
if not history.has_at(tick):
|
||||
history.set_at(tick, _ObjectSnapshot.new(subject))
|
||||
|
||||
var snapshot := history.get_at(tick) as _ObjectSnapshot
|
||||
snapshot.set_value(property, value)
|
||||
|
||||
func has_property(tick: int, subject: Object, property: NodePath) -> bool:
|
||||
if not _data.has(subject):
|
||||
return false
|
||||
|
||||
var history := _data[subject] as _HistoryBuffer
|
||||
if not history.has_at(tick):
|
||||
return false
|
||||
|
||||
var snapshot := history.get_at(tick) as _ObjectSnapshot
|
||||
return snapshot.has_value(property)
|
||||
|
||||
func get_property(tick: int, subject: Object, property: NodePath, default: Variant = null) -> Variant:
|
||||
if not _data.has(subject):
|
||||
return default
|
||||
|
||||
var history := _data[subject] as _HistoryBuffer
|
||||
if not history.has_at(tick):
|
||||
return default
|
||||
|
||||
var snapshot := history.get_at(tick) as _ObjectSnapshot
|
||||
return snapshot.get_value(property, default)
|
||||
@@ -0,0 +1 @@
|
||||
uid://70ow466d8yqh
|
||||
@@ -0,0 +1,64 @@
|
||||
extends RefCounted
|
||||
class_name _PropertyPool
|
||||
|
||||
# Stores a set of properties, with each property belonging to a subject
|
||||
|
||||
var _properties_by_subject := {} # object to property array
|
||||
|
||||
static func of(entries: Array[Array]) -> _PropertyPool:
|
||||
var pool := _PropertyPool.new()
|
||||
|
||||
for entry in entries:
|
||||
var subject := entry[0] as Object
|
||||
var property := entry[1] as NodePath
|
||||
pool.add(subject, property)
|
||||
|
||||
return pool
|
||||
|
||||
func add(subject: Object, property: NodePath) -> void:
|
||||
if has(subject, property):
|
||||
return
|
||||
|
||||
if not _properties_by_subject.has(subject):
|
||||
_properties_by_subject[subject] = [property]
|
||||
else:
|
||||
_properties_by_subject[subject].append(property)
|
||||
|
||||
func has(subject: Object, property: NodePath) -> bool:
|
||||
return (_properties_by_subject.get(subject, []) as Array).has(property)
|
||||
|
||||
func erase(subject: Object, property: NodePath) -> void:
|
||||
if not _properties_by_subject.has(subject):
|
||||
return
|
||||
|
||||
var props := _properties_by_subject[subject] as Array
|
||||
props.erase(property)
|
||||
|
||||
if props.is_empty():
|
||||
_properties_by_subject.erase(subject)
|
||||
|
||||
func erase_subject(subject: Object) -> void:
|
||||
_properties_by_subject.erase(subject)
|
||||
|
||||
func clear() -> void:
|
||||
_properties_by_subject.clear()
|
||||
|
||||
func get_properties_of(subject: Object) -> Array[NodePath]:
|
||||
var properties := [] as Array[NodePath]
|
||||
properties.assign(_properties_by_subject.get(subject, []))
|
||||
return properties
|
||||
|
||||
func get_subjects() -> Array[Object]:
|
||||
var subjects := [] as Array[Object]
|
||||
subjects.assign(_properties_by_subject.keys())
|
||||
return subjects
|
||||
|
||||
func is_empty() -> bool:
|
||||
return _properties_by_subject.is_empty()
|
||||
|
||||
func set_from_paths(root: Node, paths: Array[String]) -> void:
|
||||
clear()
|
||||
|
||||
for path in paths:
|
||||
var prop := PropertyEntry.parse(root, path)
|
||||
add(prop.node, prop.property)
|
||||
@@ -0,0 +1 @@
|
||||
uid://j4luqnbeo8jv
|
||||
@@ -0,0 +1,171 @@
|
||||
extends RefCounted
|
||||
class_name _Snapshot
|
||||
|
||||
# Stores property values of multiple subjects, recorded for a specific tick
|
||||
|
||||
var tick: int
|
||||
var _data := {} # object to (property to variant)
|
||||
var _auth_subjects := _Set.new()
|
||||
|
||||
static func make_patch(from: _Snapshot, to: _Snapshot, tick: int = to.tick) -> _Snapshot:
|
||||
var patch := _Snapshot.new(tick)
|
||||
|
||||
for subject in from._data:
|
||||
# Target has no knowledge of subject, don't patch
|
||||
if not to._data.has(subject):
|
||||
continue
|
||||
# Only patch to auth subjects
|
||||
if not to.is_auth(subject):
|
||||
continue
|
||||
|
||||
for property in to._data[subject]:
|
||||
# Target snapshot has different value, patch it
|
||||
if from.get_property(subject, property) != to.get_property(subject, property):
|
||||
patch.set_property(subject, property, to.get_property(subject, property))
|
||||
patch.set_auth(subject, to.is_auth(subject))
|
||||
|
||||
return patch
|
||||
|
||||
# Each entry should be [subject, property, value]
|
||||
static func of(tick: int, entries: Array[Array], auth_subjects: Array[Object]) -> _Snapshot:
|
||||
var snapshot := _Snapshot.new(tick)
|
||||
for entry in entries:
|
||||
var subject := entry[0] as Object
|
||||
var property := entry[1] as NodePath
|
||||
var value := entry[2] as Variant
|
||||
|
||||
snapshot.set_property(subject, property, value)
|
||||
|
||||
for subject in auth_subjects:
|
||||
snapshot.set_auth(subject, true)
|
||||
|
||||
return snapshot
|
||||
|
||||
func _init(p_tick: int):
|
||||
tick = p_tick
|
||||
|
||||
func duplicate() -> _Snapshot:
|
||||
var result := _Snapshot.new(tick)
|
||||
result._data = _data.duplicate(true)
|
||||
result._auth_subjects = _auth_subjects.duplicate()
|
||||
return result
|
||||
|
||||
func set_auth(subject: Object, is_auth: bool) -> void:
|
||||
if is_auth:
|
||||
_auth_subjects.add(subject)
|
||||
else:
|
||||
_auth_subjects.erase(subject)
|
||||
|
||||
func set_property(subject: Object, property: NodePath, value: Variant) -> void:
|
||||
if not _data.has(subject):
|
||||
_data[subject] = { property: value }
|
||||
else:
|
||||
_data[subject][property] = value
|
||||
|
||||
func record_property(subject: Object, property: NodePath) -> void:
|
||||
var value := subject.get_indexed(property)
|
||||
set_property(subject, property, value)
|
||||
|
||||
func get_property(subject: Object, property: NodePath) -> Variant:
|
||||
return _data.get(subject, {}).get(property)
|
||||
|
||||
func has_property(subject: Object, property: NodePath) -> bool:
|
||||
if not _data.has(subject):
|
||||
return false
|
||||
if not _data[subject].has(property):
|
||||
return false
|
||||
return true
|
||||
|
||||
func merge(snapshot: _Snapshot) -> bool:
|
||||
var has_changed := false
|
||||
|
||||
for subject in snapshot._data:
|
||||
if not _data.has(subject):
|
||||
# We have no data of the subject, copy all
|
||||
_data[subject] = snapshot._data[subject].duplicate()
|
||||
set_auth(subject, snapshot.is_auth(subject))
|
||||
has_changed = true
|
||||
continue
|
||||
|
||||
if snapshot.is_auth(subject) or not is_auth(subject):
|
||||
var own_props := _data[subject] as Dictionary
|
||||
var their_props := snapshot._data[subject] as Dictionary
|
||||
|
||||
has_changed = has_changed or own_props != their_props
|
||||
|
||||
own_props.merge(their_props, true)
|
||||
set_auth(subject, snapshot.is_auth(subject))
|
||||
|
||||
return has_changed
|
||||
|
||||
func apply() -> void:
|
||||
for subject in _data:
|
||||
for property in _data[subject]:
|
||||
var value = _data[subject][property]
|
||||
(subject as Object).set_indexed(property, value)
|
||||
|
||||
func sanitize(sender: int) -> void:
|
||||
var invalid_subjects := []
|
||||
for subject in _data:
|
||||
if subject is Node:
|
||||
if subject.get_multiplayer_authority() != sender:
|
||||
invalid_subjects.append(subject)
|
||||
|
||||
for subject in invalid_subjects:
|
||||
_data.erase(invalid_subjects)
|
||||
|
||||
func has_subject(subject: Object, require_auth: bool = false) -> bool:
|
||||
if not _data.has(subject):
|
||||
return false
|
||||
if require_auth and not is_auth(subject):
|
||||
return false
|
||||
return true
|
||||
|
||||
func has_subjects(subjects: Array, require_auth: bool = false) -> bool:
|
||||
for subject in subjects:
|
||||
if not has_subject(subject, require_auth):
|
||||
return false
|
||||
return true
|
||||
|
||||
func get_subjects() -> Array:
|
||||
return _data.keys()
|
||||
|
||||
func get_auth_subjects() -> Array:
|
||||
return _auth_subjects.values()
|
||||
|
||||
func get_subject_properties(subject: Object) -> Array:
|
||||
return _data.get(subject, {}).keys()
|
||||
|
||||
func is_empty() -> bool:
|
||||
return _data.is_empty()
|
||||
|
||||
func size() -> int:
|
||||
var result := 0
|
||||
for subject in _data:
|
||||
result += (_data[subject] as Dictionary).size()
|
||||
return result
|
||||
|
||||
func is_auth(subject: Object) -> bool:
|
||||
return _auth_subjects.has(subject)
|
||||
|
||||
func equals(other) -> bool:
|
||||
if other is _Snapshot:
|
||||
return tick == other.tick and _data == other._data and _auth_subjects.equals(other._auth_subjects)
|
||||
else:
|
||||
return false
|
||||
|
||||
func _to_string() -> String:
|
||||
var result := "_Snapshot(#%d" % [tick]
|
||||
for subject in _data:
|
||||
for property in _data[subject]:
|
||||
var value = _data[subject][property]
|
||||
result += ", %s:%s(%s): %s" % [subject, property, is_auth(subject), value]
|
||||
result += ")"
|
||||
return result
|
||||
|
||||
func _to_vest():
|
||||
return {
|
||||
"tick": tick,
|
||||
"data": _data,
|
||||
"auth_subjects": _auth_subjects
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
uid://b76plodlwp2u6
|
||||
@@ -0,0 +1 @@
|
||||
uid://ch0j0cclkpey6
|
||||
@@ -0,0 +1,179 @@
|
||||
extends Node
|
||||
class_name _NetworkCommandServer
|
||||
|
||||
## Transmits commands over the network
|
||||
##
|
||||
## Commands are a simpler, lightweight alternative to RPCs. Commands consist of
|
||||
## a single byte for ID, and the raw binary data. The ID lets the receiving peer
|
||||
## decide what to execute, with the binary data serving as the input.
|
||||
## [br][br]
|
||||
## Being a simpler construct makes commands a good fit for regular, fundamental
|
||||
## operations.
|
||||
## [br][br]
|
||||
## Commands are, by default, transmitted over regular RPCs. To use less data,
|
||||
## commands can also be transmitted as raw packets, using
|
||||
## [method SceneMultiplayer.send_bytes]. This is an opt-in feature - if the game
|
||||
## is already using [method SceneMultiplayer.send_bytes], it needs to be aware
|
||||
## of commands, and must check each packet whether it's a command or one of its
|
||||
## own packets. To check if a packet is a command, use [method
|
||||
## is_command_packet].
|
||||
|
||||
var _packet_prefix := PackedByteArray([0, 78, 70]) # "\0nf"
|
||||
var _next_idx := 0
|
||||
var _rpc_transport := _RPCTransport.new()
|
||||
var _packet_transport := _PacketTransport.new(_packet_prefix)
|
||||
var _commands := {} # id to `Command`
|
||||
|
||||
var _use_raw := ProjectSettings.get_setting("netfox/general/use_raw_commands", false) as bool
|
||||
|
||||
static var _logger := NetfoxLogger._for_netfox("NetworkCommandServer")
|
||||
|
||||
func _ready():
|
||||
add_child(_rpc_transport, true)
|
||||
add_child(_packet_transport, true)
|
||||
|
||||
_rpc_transport.on_receive.connect(_handle_command)
|
||||
_packet_transport.on_receive.connect(_handle_command)
|
||||
|
||||
## Register a command at the next available ID
|
||||
func register_command(handler: Callable, mode: MultiplayerPeer.TransferMode = MultiplayerPeer.TRANSFER_MODE_RELIABLE, channel: int = 0) -> Command:
|
||||
var idx := _next_idx
|
||||
_next_idx += 1
|
||||
return register_command_at(idx, handler)
|
||||
|
||||
## Register a command at a specific index
|
||||
## [br][br]
|
||||
## A specific ID should only be registered once. Doing otherwise will trigger an
|
||||
## assert in the editor, but will overwrite the previous command in release.
|
||||
func register_command_at(idx: int, handler: Callable, mode: MultiplayerPeer.TransferMode = MultiplayerPeer.TRANSFER_MODE_RELIABLE, channel: int = 0) -> Command:
|
||||
assert(not _commands.has(idx), "Command #%d is already taken!" % idx)
|
||||
var command := Command.new(self, idx, handler, mode, channel)
|
||||
_commands[idx] = command
|
||||
|
||||
_next_idx = maxi(_next_idx, idx + 1)
|
||||
|
||||
return command
|
||||
|
||||
## Send a command with index and data
|
||||
func send_command(idx: int, data: PackedByteArray, target_peer: int = 0, mode: MultiplayerPeer.TransferMode = MultiplayerPeer.TRANSFER_MODE_RELIABLE, channel: int = 0) -> void:
|
||||
if _use_raw:
|
||||
_packet_transport.send(idx, data, target_peer, mode, channel)
|
||||
else:
|
||||
_rpc_transport.send(idx, data, target_peer, mode, channel)
|
||||
|
||||
## Return true if [param packet] is a command packet
|
||||
## [br][br]
|
||||
## Always returns [code]true[/code] if RPCs are used for transmitting commands.
|
||||
func is_command_packet(packet: PackedByteArray) -> bool:
|
||||
if not _use_raw:
|
||||
return true
|
||||
return _packet_transport.is_command_packet(packet)
|
||||
|
||||
## Return the prefix bytes for command packets
|
||||
## [br][br]
|
||||
## Can be used to avoid conflicts between command packets and game packets.
|
||||
func get_command_packet_prefix() -> PackedByteArray:
|
||||
return _packet_prefix
|
||||
|
||||
func _handle_command(sender: int, idx: int, data: PackedByteArray) -> void:
|
||||
var command := _commands.get(idx) as Command
|
||||
if not command:
|
||||
_logger.error("Received unknown command #%d!", [idx])
|
||||
return
|
||||
command._handle(sender, data)
|
||||
|
||||
## Networked command
|
||||
##
|
||||
## Provides a convenient interface for sending and managing networked commands.
|
||||
## [br][br]
|
||||
## Should not be instantiated manually.
|
||||
class Command:
|
||||
var _command_server: _NetworkCommandServer
|
||||
|
||||
var _idx: int
|
||||
var _handler: Callable
|
||||
var _mode: MultiplayerPeer.TransferMode
|
||||
var _channel: int
|
||||
|
||||
func _init(p_command_server: _NetworkCommandServer, p_idx: int, p_handler: Callable, p_mode: MultiplayerPeer.TransferMode, p_channel: int):
|
||||
_command_server = p_command_server
|
||||
_idx = p_idx
|
||||
_handler = p_handler
|
||||
_mode = p_mode
|
||||
_channel = p_channel
|
||||
|
||||
## Send command
|
||||
func send(data: PackedByteArray, target_peer: int = 0) -> void:
|
||||
_command_server.send_command(_idx, data, target_peer, _mode, _channel)
|
||||
|
||||
func _handle(sender: int, data: PackedByteArray) -> void:
|
||||
_handler.call(sender, data)
|
||||
|
||||
class _Transport extends Node:
|
||||
signal on_receive(idx: int, data: PackedByteArray)
|
||||
|
||||
func send(idx: int, data: PackedByteArray, target_peer: int, mode: MultiplayerPeer.TransferMode, channel: int) -> void:
|
||||
pass
|
||||
|
||||
class _PacketTransport extends _Transport:
|
||||
var _packet_prefix: PackedByteArray
|
||||
|
||||
func _init(p_packet_prefix: PackedByteArray):
|
||||
_packet_prefix = p_packet_prefix
|
||||
|
||||
func _ready():
|
||||
(multiplayer as SceneMultiplayer).peer_packet.connect(_handle_packet)
|
||||
|
||||
func send(idx: int, data: PackedByteArray, target_peer: int, mode: MultiplayerPeer.TransferMode, channel: int) -> void:
|
||||
var buffer := StreamPeerBuffer.new()
|
||||
buffer.put_data(_packet_prefix)
|
||||
buffer.put_u8(idx)
|
||||
buffer.put_data(data)
|
||||
|
||||
(multiplayer as SceneMultiplayer).send_bytes(buffer.data_array, target_peer, mode, channel)
|
||||
|
||||
func is_command_packet(packet: PackedByteArray) -> bool:
|
||||
if packet.size() < _packet_prefix.size():
|
||||
return false
|
||||
|
||||
for i in _packet_prefix.size():
|
||||
if packet[i] != _packet_prefix[i]:
|
||||
return false
|
||||
return true
|
||||
|
||||
func _handle_packet(peer: int, packet: PackedByteArray) -> void:
|
||||
var buffer := StreamPeerBuffer.new()
|
||||
buffer.data_array = packet
|
||||
|
||||
# Check header
|
||||
if not is_command_packet(packet):
|
||||
return
|
||||
|
||||
# Grab data
|
||||
buffer.seek(_packet_prefix.size())
|
||||
var idx := buffer.get_u8()
|
||||
var data := buffer.get_partial_data(buffer.get_available_bytes())[1] as PackedByteArray
|
||||
|
||||
on_receive.emit(peer, idx, data)
|
||||
|
||||
class _RPCTransport extends _Transport:
|
||||
func send(idx: int, data: PackedByteArray, target_peer: int, mode: MultiplayerPeer.TransferMode, _channel: int) -> void:
|
||||
match mode:
|
||||
MultiplayerPeer.TRANSFER_MODE_UNRELIABLE: _submit_unreliable.rpc_id(target_peer, idx, data)
|
||||
MultiplayerPeer.TRANSFER_MODE_UNRELIABLE_ORDERED: _submit_unreliable_ordered.rpc_id(target_peer, idx, data)
|
||||
MultiplayerPeer.TRANSFER_MODE_RELIABLE: _submit_reliable.rpc_id(target_peer, idx, data)
|
||||
|
||||
@rpc("any_peer", "call_remote", "unreliable")
|
||||
func _submit_unreliable(idx: int, data: PackedByteArray):
|
||||
var sender := multiplayer.get_remote_sender_id()
|
||||
on_receive.emit(sender, idx, data)
|
||||
|
||||
@rpc("any_peer", "call_remote", "unreliable_ordered")
|
||||
func _submit_unreliable_ordered(idx: int, data: PackedByteArray):
|
||||
var sender := multiplayer.get_remote_sender_id()
|
||||
on_receive.emit(sender, idx, data)
|
||||
|
||||
@rpc("any_peer", "call_remote", "reliable")
|
||||
func _submit_reliable(idx: int, data: PackedByteArray):
|
||||
var sender := multiplayer.get_remote_sender_id()
|
||||
on_receive.emit(sender, idx, data)
|
||||
@@ -0,0 +1 @@
|
||||
uid://mkgjb8gdl0fp
|
||||
@@ -0,0 +1,273 @@
|
||||
extends Node
|
||||
class_name _NetworkHistoryServer
|
||||
|
||||
## Tracks the history of objects' properties
|
||||
##
|
||||
## Specifically, history is stored for rollback state properties, rollback input
|
||||
## properties, and synchronized state properties.
|
||||
## [br][br]
|
||||
## Keeping history lets rollback restore earlier game states for resimulation,
|
||||
## and enables [_NetworkSynchronizationServer] to send diff states by comparing
|
||||
## against historical data.
|
||||
|
||||
var _rb_input_properties := _PropertyPool.new()
|
||||
var _rb_state_properties := _PropertyPool.new()
|
||||
var _sync_state_properties := _PropertyPool.new()
|
||||
|
||||
var _rb_history_size := NetworkRollback.history_limit
|
||||
var _sync_history_size := ProjectSettings.get_setting("netfox/state_synchronizer/history_limit", 64) as int
|
||||
|
||||
# Source of truth for history
|
||||
var _rb_input_history := _PerObjectHistory.new(_rb_history_size)
|
||||
var _rb_state_history := _PerObjectHistory.new(_rb_history_size)
|
||||
var _sync_history := _PerObjectHistory.new(_sync_history_size)
|
||||
|
||||
# Cached snapshots for syncing
|
||||
var _rb_input_snapshots := _HistoryBuffer.new(_rb_history_size)
|
||||
var _rb_state_snapshots := _HistoryBuffer.new(_rb_history_size)
|
||||
var _sync_state_snapshots := _HistoryBuffer.new(_sync_history_size)
|
||||
|
||||
static var _logger := NetfoxLogger._for_netfox("NetworkHistoryServer")
|
||||
|
||||
## Register a rollback state property
|
||||
func register_rollback_state(node: Node, property: NodePath) -> void:
|
||||
_rb_state_properties.add(node, property)
|
||||
|
||||
## Deregister a rollback state property
|
||||
func deregister_rollback_state(node: Node, property: NodePath) -> void:
|
||||
_rb_state_properties.erase(node, property)
|
||||
|
||||
## Register a rollback input property
|
||||
func register_rollback_input(node: Node, property: NodePath) -> void:
|
||||
_rb_input_properties.add(node, property)
|
||||
|
||||
## Deregister a rollback input property
|
||||
func deregister_rollback_input(node: Node, property: NodePath) -> void:
|
||||
_rb_input_properties.erase(node, property)
|
||||
|
||||
## Register a synchronized state property
|
||||
func register_sync_state(node: Node, property: NodePath) -> void:
|
||||
_sync_state_properties.add(node, property)
|
||||
|
||||
## Deregister a synchronized state property
|
||||
func deregister_sync_state(node: Node, property: NodePath) -> void:
|
||||
_sync_state_properties.erase(node, property)
|
||||
|
||||
## Deregister a node, no longer tracking any property it had registered using
|
||||
## any of the [code]register_*()[/code] methods
|
||||
func deregister(node: Node) -> void:
|
||||
_rb_state_properties.erase_subject(node)
|
||||
_rb_input_properties.erase_subject(node)
|
||||
_sync_state_properties.erase_subject(node)
|
||||
|
||||
_rb_state_history.erase_subject(node)
|
||||
_rb_input_history.erase_subject(node)
|
||||
_sync_history.erase_subject(node)
|
||||
|
||||
## Return the latest tick where any of the [param]subjects[/param] had rollback
|
||||
## state data available
|
||||
func get_latest_state_tick_for(subjects: Array, tick: int) -> int:
|
||||
return _get_latest_for(subjects, tick, _rb_state_history)
|
||||
|
||||
## Return how old is the latest rollback state data for any of the [param]
|
||||
## subjects[/param], in ticks
|
||||
func get_state_age_for(subjects: Array, tick: int) -> int:
|
||||
var latest_state := get_latest_state_tick_for(subjects, tick)
|
||||
if latest_state < 0:
|
||||
return -1
|
||||
else:
|
||||
return tick - latest_state
|
||||
|
||||
## Return the latest tick where any of the [param]subjects[/param] had rollback
|
||||
## input data available
|
||||
func get_latest_input_for(subjects: Array, tick: int) -> int:
|
||||
return _get_latest_for(subjects, tick, _rb_input_history)
|
||||
|
||||
## Return how old is the latest rollback input data for any of the [param]
|
||||
## subjects[/param], in ticks
|
||||
func get_input_age_for(subjects: Array, tick: int) -> int:
|
||||
var latest_input := get_latest_input_for(subjects, tick)
|
||||
if latest_input < 0:
|
||||
return -1
|
||||
else:
|
||||
return tick - latest_input
|
||||
|
||||
func _record_rollback_input(tick: int) -> void:
|
||||
_record(tick, _rb_input_history, _rb_input_snapshots, _rb_input_properties, true, func(subject: Node):
|
||||
return subject.is_multiplayer_authority()
|
||||
)
|
||||
|
||||
func _record_rollback_state(tick: int) -> void:
|
||||
var input_snapshot := _get_rollback_input_snapshot(tick - 1)
|
||||
|
||||
_record(tick, _rb_state_history, _rb_state_snapshots, _rb_state_properties, false, func(subject: Node):
|
||||
if not subject.is_multiplayer_authority():
|
||||
return false
|
||||
if RollbackSimulationServer._is_predicting(input_snapshot, subject):
|
||||
return false
|
||||
return true
|
||||
)
|
||||
|
||||
func _record_sync_state(tick: int) -> void:
|
||||
_record(tick, _sync_history, _sync_state_snapshots, _sync_state_properties, true, func(subject: Node):
|
||||
return subject.is_multiplayer_authority()
|
||||
)
|
||||
|
||||
func _restore_rollback_input(tick: int) -> bool:
|
||||
return _restore_latest(tick, _rb_input_history)
|
||||
|
||||
func _restore_rollback_state(tick: int) -> bool:
|
||||
return _restore_latest(tick, _rb_state_history)
|
||||
|
||||
func _restore_synchronizer_state(tick: int) -> bool:
|
||||
return _restore_latest(tick, _sync_history)
|
||||
|
||||
func _get_rollback_input_snapshot(tick: int) -> _Snapshot:
|
||||
return _rb_input_snapshots.get_at(tick)
|
||||
|
||||
func _get_rollback_state_snapshot(tick: int) -> _Snapshot:
|
||||
return _rb_state_snapshots.get_at(tick)
|
||||
|
||||
func _get_synchronizer_state_snapshot(tick: int) -> _Snapshot:
|
||||
return _sync_state_snapshots.get_at(tick)
|
||||
|
||||
func _merge_rollback_input(snapshot: _Snapshot) -> bool:
|
||||
_merge_snapshot(snapshot, _rb_input_snapshots, true)
|
||||
return _merge_history(snapshot, _rb_input_history, true)
|
||||
|
||||
func _merge_rollback_state(snapshot: _Snapshot) -> bool:
|
||||
_merge_snapshot(snapshot, _rb_state_snapshots, true)
|
||||
return _merge_history(snapshot, _rb_state_history)
|
||||
|
||||
func _merge_synchronizer_state(snapshot: _Snapshot) -> bool:
|
||||
_merge_snapshot(snapshot, _sync_state_snapshots, true)
|
||||
return _merge_history(snapshot, _sync_history)
|
||||
|
||||
func _record(tick: int, history: _PerObjectHistory, snapshots: _HistoryBuffer, property_pool: _PropertyPool, only_auth: bool, auth_filter: Callable) -> void:
|
||||
var snapshot := snapshots.get_at(tick, _Snapshot.new(tick)) as _Snapshot
|
||||
if not snapshots.has_at(tick):
|
||||
snapshots.set_at(tick, snapshot)
|
||||
|
||||
for subject in property_pool.get_subjects():
|
||||
assert(subject is Node, "Only nodes supported for now!")
|
||||
|
||||
var is_auth := auth_filter.call(subject)
|
||||
|
||||
if only_auth and not is_auth:
|
||||
continue
|
||||
if not is_auth and history.is_auth(tick, subject):
|
||||
continue
|
||||
|
||||
var subject_snapshot := history.ensure_snapshot(tick, subject, false) #!!
|
||||
assert(not property_pool.get_properties_of(subject).is_empty(), "Subject present in property pool without properties! Please report a bug!")
|
||||
for property in property_pool.get_properties_of(subject):
|
||||
subject_snapshot.record_property(property)
|
||||
snapshot.record_property(subject, property)
|
||||
snapshot.set_auth(subject, is_auth)
|
||||
subject_snapshot.set_auth(is_auth)
|
||||
|
||||
match history:
|
||||
_rb_input_history:
|
||||
_logger.trace("Recorded input @%d: %s", [tick, snapshot])
|
||||
_rb_state_history:
|
||||
_logger.trace("Recorded state @%d: %s", [tick, snapshot])
|
||||
|
||||
func _restore_latest(tick: int, history: _PerObjectHistory) -> bool:
|
||||
var any_applied := false
|
||||
|
||||
for subject in history.subjects():
|
||||
# Grab latest snapshot up to tick
|
||||
var snapshot := history.get_latest_snapshot(tick, subject)
|
||||
|
||||
# Apply if any
|
||||
if snapshot:
|
||||
snapshot.apply()
|
||||
any_applied = true
|
||||
|
||||
match history:
|
||||
_rb_input_history: _logger.trace("Restored input @%d: %s", [tick, snapshot])
|
||||
_rb_state_history: _logger.trace("Restored state @%d: %s", [tick, snapshot])
|
||||
|
||||
return any_applied
|
||||
|
||||
func _merge_snapshot(snapshot: _Snapshot, snapshots: _HistoryBuffer, reverse: bool = false) -> bool:
|
||||
var tick := snapshot.tick
|
||||
|
||||
if not snapshots.has_at(snapshot.tick):
|
||||
snapshots.set_at(tick, snapshot)
|
||||
return true
|
||||
|
||||
var original_snapshot := snapshots.get_at(tick) as _Snapshot
|
||||
if reverse:
|
||||
var original_subjects := original_snapshot.get_auth_subjects()
|
||||
var incoming_subjects := snapshot.get_auth_subjects()
|
||||
|
||||
# Merge the original snapshot on top of the incoming
|
||||
# This prevents players from changing history, e.g. rewrite their past
|
||||
# inputs
|
||||
snapshots.set_at(tick, snapshot)
|
||||
snapshot.merge(original_snapshot)
|
||||
|
||||
# Only return true if we've received inputs for a new node
|
||||
return incoming_subjects.any(func(it): return not original_subjects.has(it))
|
||||
else:
|
||||
return original_snapshot.merge(snapshot)
|
||||
|
||||
func _merge_history(snapshot: _Snapshot, history: _PerObjectHistory, reverse: bool = false) -> bool:
|
||||
var tick := snapshot.tick
|
||||
var has_updated := false
|
||||
|
||||
if tick < NetworkRollback.history_start:
|
||||
_logger.warning("Snapshot being merged is too old! (@%d)", [tick])
|
||||
return false
|
||||
|
||||
for subject in snapshot.get_subjects():
|
||||
var object_snapshot := history.ensure_snapshot(tick, subject, not reverse)
|
||||
|
||||
# Never overwrite auth data
|
||||
if object_snapshot.is_auth() and not snapshot.is_auth(subject):
|
||||
continue
|
||||
|
||||
for property in snapshot.get_subject_properties(subject):
|
||||
# If merging in reverse, don't update anything that we already have
|
||||
# a value for - only accept previously unknown property values
|
||||
if reverse and object_snapshot.has_value(property):
|
||||
continue
|
||||
|
||||
var original_value := object_snapshot.get_value(property)
|
||||
var new_value := snapshot.get_property(subject, property)
|
||||
|
||||
object_snapshot.set_value(property, new_value)
|
||||
if not has_updated and original_value != new_value:
|
||||
has_updated = true
|
||||
object_snapshot.set_auth(snapshot.is_auth(subject))
|
||||
|
||||
return has_updated
|
||||
|
||||
func _get_latest_for(subjects: Array, tick: int, history: _PerObjectHistory) -> int:
|
||||
var latest := -1
|
||||
|
||||
for subject in subjects:
|
||||
var subject_latest := history.get_latest_tick(tick, subject)
|
||||
if subject_latest < 0:
|
||||
continue
|
||||
|
||||
# Should we track `mini()` instead?
|
||||
latest = maxi(latest, subject_latest)
|
||||
|
||||
return latest
|
||||
|
||||
func _get_earliest_for(subjects: Array, tick: int, history: _PerObjectHistory) -> int:
|
||||
var earliest := -1
|
||||
|
||||
for subject in subjects:
|
||||
var subject_latest := history.get_latest_tick(tick, subject)
|
||||
if subject_latest < 0:
|
||||
return -1
|
||||
|
||||
if earliest < 0:
|
||||
earliest = earliest
|
||||
else:
|
||||
earliest = mini(earliest, subject_latest)
|
||||
|
||||
return earliest
|
||||
@@ -0,0 +1 @@
|
||||
uid://c554fbsy6yos3
|
||||
@@ -0,0 +1,190 @@
|
||||
extends Node
|
||||
class_name _NetworkIdentityServer
|
||||
|
||||
## Tracks identities for use over the network
|
||||
##
|
||||
## Internally, netfox sends packets that refer to specific nodes, e.g. to
|
||||
## synchronize their state. Nodes are referenced based on their path in the
|
||||
## scene tree. To save on bandwidth, node paths are replaced with numeric IDs
|
||||
## when possible.
|
||||
## [br][br]
|
||||
## This class manages these numerical IDs and their broadcast among peers.
|
||||
## [br][br]
|
||||
## Each node that is to be referred to over the network must be registered using
|
||||
## [method register_node]. It is best to deregister freed nodes using [method
|
||||
## deregister_node].
|
||||
## [br][br]
|
||||
## Node registration and deregistration are done automatically by the high-level
|
||||
## nodes ( like RollbackSynchronizer ), and usually doesn't need to be done
|
||||
## manually.
|
||||
|
||||
var _command_server: _NetworkCommandServer
|
||||
|
||||
var _next_id := 0
|
||||
var _identifiers := {} # object to NetworkIdentifier
|
||||
var _push_queue := {} # peer to (full name to id)
|
||||
|
||||
var _identifier_by_name := {} # full name to NetworkIdentifier
|
||||
var _identifier_by_id := {} # peer to (id to NetworkIdentifier)
|
||||
|
||||
var _cmd_ids: _NetworkCommandServer.Command
|
||||
|
||||
static var _logger := NetfoxLogger._for_netfox("NetworkIdentityServer")
|
||||
|
||||
func _init(p_command_server: _NetworkCommandServer = null):
|
||||
_command_server = p_command_server
|
||||
|
||||
func _ready():
|
||||
if not _command_server:
|
||||
_command_server = NetworkCommandServer
|
||||
|
||||
_cmd_ids = _command_server.register_command(_handle_ids, MultiplayerPeer.TRANSFER_MODE_RELIABLE)
|
||||
|
||||
# TODO(#561): Handle peer disconnect by clearing up data
|
||||
|
||||
## Register a node
|
||||
## [br][br]
|
||||
## Once a node is registered, it can be referred to over the network. The same
|
||||
## node must be registered with the same node path on all peers.
|
||||
func register_node(node: Node) -> void:
|
||||
if not node.is_inside_tree():
|
||||
_logger.error("Can't register node %s that is not inside tree!", [node])
|
||||
return
|
||||
_register(node, node.get_path())
|
||||
|
||||
## Deregister a node, freeing all identity data associated with it
|
||||
func deregister_node(node: Node) -> void:
|
||||
_deregister(node)
|
||||
|
||||
## Clear all identities
|
||||
func clear() -> void:
|
||||
_identifiers.clear()
|
||||
_identifier_by_name.clear()
|
||||
_identifier_by_id.clear()
|
||||
_next_id = 0
|
||||
|
||||
## Queue sending the numeric ID of [param node] to [param peer]
|
||||
## [br][br]
|
||||
## This happens automatically when the [param node] is first referred to in a
|
||||
## packet. This method allows frontloading that, at a more feasible moment.
|
||||
## [br][br]
|
||||
## This method does not send any data. To force sending identifiers, use [method
|
||||
## flush_queue].
|
||||
func queue_identifier_for(node: Node, peer: int) -> bool:
|
||||
var identifier := _get_identifier_of(node)
|
||||
if not identifier:
|
||||
return false
|
||||
_queue_for(identifier, peer)
|
||||
return true
|
||||
|
||||
## Broadcast all identities queued for synchronization
|
||||
## [br][br]
|
||||
## Flushed automatically by default
|
||||
func flush_queue() -> void:
|
||||
for peer in _push_queue:
|
||||
_cmd_ids.send(_serialize_ids(_push_queue[peer]), peer)
|
||||
_push_queue.clear()
|
||||
|
||||
func _get_identifier_of(what: Object) -> _NetworkIdentifier:
|
||||
return _identifiers.get(what)
|
||||
|
||||
func _resolve_reference(peer: int, identity_reference: _NetworkIdentityReference, allow_queue: bool = true) -> _NetworkIdentifier:
|
||||
if identity_reference.has_id():
|
||||
return _get_identifier_by_id(peer, identity_reference.get_id())
|
||||
else:
|
||||
var identifier := _get_identifier_by_name(identity_reference.get_full_name())
|
||||
if allow_queue and identifier:
|
||||
_queue_for(identifier, peer)
|
||||
return identifier
|
||||
|
||||
func _queue_for(identifier: _NetworkIdentifier, peer: int) -> void:
|
||||
if not _push_queue.has(peer):
|
||||
_push_queue[peer] = { identifier.get_full_name(): identifier.get_id_for(peer) }
|
||||
else:
|
||||
_push_queue[peer][identifier.get_full_name()] = identifier.get_id_for(peer)
|
||||
|
||||
func _register(what: Object, path: String) -> void:
|
||||
if _identifiers.has(what):
|
||||
return
|
||||
|
||||
var identifier := _NetworkIdentifier.new(what, path, _make_id(), multiplayer.get_unique_id())
|
||||
_identifiers[what] = identifier
|
||||
_identifier_by_name[identifier.get_full_name()] = identifier
|
||||
|
||||
identifier.on_id.connect(func(peer: int, id: int): _update_id_cache(identifier, peer, id))
|
||||
_update_id_cache(identifier, multiplayer.get_unique_id(), identifier.get_local_id())
|
||||
|
||||
func _deregister(what: Object) -> void:
|
||||
if not _identifiers.has(what):
|
||||
return
|
||||
|
||||
var identifier := _identifiers[what] as _NetworkIdentifier
|
||||
_identifiers.erase(what)
|
||||
_identifier_by_name.erase(identifier.get_full_name())
|
||||
_erase_from_id_cache(identifier)
|
||||
|
||||
|
||||
func _get_identifier_by_name(full_name: String) -> _NetworkIdentifier:
|
||||
return _identifier_by_name.get(full_name)
|
||||
|
||||
func _get_identifier_by_id(peer: int, id: int) -> _NetworkIdentifier:
|
||||
return _identifier_by_id.get(peer, {}).get(id, null)
|
||||
|
||||
func _make_id() -> int:
|
||||
_next_id += 1
|
||||
return _next_id
|
||||
|
||||
func _update_id_cache(identifier: _NetworkIdentifier, peer: int, id: int) -> void:
|
||||
if not _identifier_by_id.has(peer):
|
||||
_identifier_by_id[peer] = { id: identifier }
|
||||
else:
|
||||
_identifier_by_id[peer][id] = identifier
|
||||
|
||||
func _erase_from_id_cache(identifier: _NetworkIdentifier) -> void:
|
||||
for peer in identifier.get_known_peers():
|
||||
if not _identifier_by_id.has(peer):
|
||||
# nani?
|
||||
continue
|
||||
|
||||
var cache := _identifier_by_id.get(peer) as Dictionary
|
||||
cache.erase(identifier.get_id_for(peer))
|
||||
if cache.is_empty():
|
||||
_identifier_by_id.erase(peer)
|
||||
|
||||
func _handle_ids(sender: int, data: PackedByteArray) -> void:
|
||||
var ids := _deserialize_ids(data)
|
||||
|
||||
for full_name in ids:
|
||||
var id := ids[full_name] as int
|
||||
var identifier := _get_identifier_by_name(full_name)
|
||||
if not identifier:
|
||||
# Deleted since then
|
||||
_logger.debug("Received identifier for unknown object with full name %s, id #%d", [full_name, id])
|
||||
continue
|
||||
identifier.set_id_for(sender, id)
|
||||
|
||||
func _serialize_ids(ids: Dictionary) -> PackedByteArray:
|
||||
var buffer := StreamPeerBuffer.new()
|
||||
var varuint := NetworkSchemas.varuint()
|
||||
|
||||
for full_name in ids.keys():
|
||||
var id := ids[full_name] as int
|
||||
|
||||
buffer.put_utf8_string(full_name)
|
||||
varuint.encode(ids[full_name], buffer)
|
||||
|
||||
return buffer.data_array
|
||||
|
||||
func _deserialize_ids(data: PackedByteArray) -> Dictionary:
|
||||
var ids := {}
|
||||
var varuint := NetworkSchemas.varuint()
|
||||
var buffer := StreamPeerBuffer.new()
|
||||
buffer.data_array = data
|
||||
|
||||
while buffer.get_available_bytes() > 0:
|
||||
var full_name := buffer.get_utf8_string()
|
||||
var id := varuint.decode(buffer) as int
|
||||
|
||||
ids[full_name] = id
|
||||
|
||||
return ids
|
||||
@@ -0,0 +1 @@
|
||||
uid://pc8gwg1lbusp
|
||||
@@ -0,0 +1,381 @@
|
||||
extends Node
|
||||
class_name _NetworkSynchronizationServer
|
||||
|
||||
## Synchronizes properties over the network
|
||||
##
|
||||
## Handles synchronization of rollback and state properties (
|
||||
## [RollbackSynchronizer] and [StateSynchronizer] ), while respecting visibility
|
||||
## filters and schemas for serialization.
|
||||
## [br][br]
|
||||
## Packets are sent per tick, instead of per object. So for every simulated
|
||||
## rollback tick, a packet is sent with states, and for every recorded input,
|
||||
## a packet is sent with the inputs.
|
||||
## [br][br]
|
||||
## Optionally, diff states can be used, sending only the property values that
|
||||
## have changed, saving on bandwidth.
|
||||
|
||||
# Dependencies
|
||||
var _command_server: _NetworkCommandServer
|
||||
var _history_server: _NetworkHistoryServer
|
||||
var _identity_server: _NetworkIdentityServer
|
||||
var _simulation_server: _RollbackSimulationServer
|
||||
|
||||
# Configuration
|
||||
var _rb_input_properties := _PropertyPool.new()
|
||||
var _rb_state_properties := _PropertyPool.new()
|
||||
var _rb_owned_input_properties := _PropertyPool.new()
|
||||
var _rb_owned_state_properties := _PropertyPool.new()
|
||||
var _sync_state_properties := _PropertyPool.new()
|
||||
var _sync_owned_state_properties := _PropertyPool.new()
|
||||
|
||||
var _visibility_filters := {} # Node to PeerVisibilityFilter
|
||||
|
||||
var _rb_enable_input_broadcast := ProjectSettings.get_setting("netfox/rollback/enable_input_broadcast", false) as bool
|
||||
var _rb_enable_diffs := NetworkRollback.enable_diff_states
|
||||
var _rb_full_interval := ProjectSettings.get_setting("netfox/rollback/full_state_interval", 24) as int
|
||||
var _rb_full_scheduler := _IntervalScheduler.new(_rb_full_interval)
|
||||
|
||||
var _input_redundancy := NetworkRollback.input_redundancy
|
||||
|
||||
var _last_sync_state_sent := _Snapshot.new(0)
|
||||
var _sync_enable_diffs := ProjectSettings.get_setting("netfox/state_synchronizer/enable_diff_states", true) as bool
|
||||
var _sync_full_interval := ProjectSettings.get_setting("netfox/state_synchronizer/full_state_interval", 24) as int
|
||||
var _sync_full_scheduler := _IntervalScheduler.new(_sync_full_interval)
|
||||
|
||||
var _schemas := _NetworkSchema.new()
|
||||
|
||||
var _dense_serializer: _DenseSnapshotSerializer
|
||||
var _sparse_serializer: _SparseSnapshotSerializer
|
||||
var _redundant_serializer: _RedundantSnapshotSerializer
|
||||
|
||||
var _cmd_full_state: NetworkCommandServer.Command
|
||||
var _cmd_diff_state: NetworkCommandServer.Command
|
||||
var _cmd_input: NetworkCommandServer.Command
|
||||
|
||||
var _cmd_full_sync: NetworkCommandServer.Command
|
||||
var _cmd_diff_sync: NetworkCommandServer.Command
|
||||
|
||||
static var _logger := NetfoxLogger._for_netfox("NetworkSynchronizationServer")
|
||||
|
||||
signal _on_input(snapshot: _Snapshot)
|
||||
signal _on_state(snapshot: _Snapshot)
|
||||
|
||||
## Register a [param]property[/param] of [param]node[/param] to be synchronized
|
||||
## as rollback state
|
||||
func register_rollback_state(node: Node, property: NodePath) -> void:
|
||||
_rb_state_properties.add(node, property)
|
||||
if node.is_multiplayer_authority():
|
||||
_rb_owned_state_properties.add(node, property)
|
||||
|
||||
## Deregister a [param]property[/param] of [param]node[/param] from being
|
||||
## synchronized as rollback state
|
||||
func deregister_rollback_state(node: Node, property: NodePath) -> void:
|
||||
_rb_state_properties.erase(node, property)
|
||||
_rb_owned_state_properties.erase(node, property)
|
||||
|
||||
## Register a [param]property[/param] of [param]node[/param] to be synchronized
|
||||
## as rollback input
|
||||
func register_rollback_input(node: Node, property: NodePath) -> void:
|
||||
_rb_input_properties.add(node, property)
|
||||
if node.is_multiplayer_authority():
|
||||
_rb_owned_input_properties.add(node, property)
|
||||
|
||||
## Deregister a [param]property[/param] of [param]node[/param] from being
|
||||
## synchronized as rollback input
|
||||
func deregister_rollback_input(node: Node, property: NodePath) -> void:
|
||||
_rb_input_properties.erase(node, property)
|
||||
_rb_owned_input_properties.erase(node, property)
|
||||
|
||||
## Register a [param]property[/param] of [param]node[/param] to be synchronized
|
||||
## as synchronized state
|
||||
func register_sync_state(node: Node, property: NodePath) -> void:
|
||||
_sync_state_properties.add(node, property)
|
||||
if node.is_multiplayer_authority():
|
||||
_sync_owned_state_properties.add(node, property)
|
||||
|
||||
## Deregister a [param]property[/param] of [param]node[/param] from being
|
||||
## synchronized as synchronized state
|
||||
func deregister_sync_state(node: Node, property: NodePath) -> void:
|
||||
_sync_state_properties.erase(node, property)
|
||||
_sync_owned_state_properties.erase(node, property)
|
||||
|
||||
## Register a [param]serializer[/param] to use when transmitting
|
||||
## [param]property[/param] of [param]node[/param] over the network
|
||||
func register_schema(node: Node, property: NodePath, serializer: NetworkSchemaSerializer) -> void:
|
||||
_schemas.add(node, property, serializer)
|
||||
|
||||
## Deregister any serializers used for [param]property[/param] on
|
||||
## [param]node[/param] when transmitting over the network
|
||||
func deregister_schema(node: Node, property: NodePath) -> void:
|
||||
_schemas.erase(node, property)
|
||||
|
||||
## Deregister all serializers registered for any properties of
|
||||
## [param]node[/param]
|
||||
func deregister_schema_for(node: Node) -> void:
|
||||
_schemas.erase_subject(node)
|
||||
|
||||
## Register a visibility [param]filter[/param] for use with [param]node[/param]
|
||||
func register_visibility_filter(node: Node, filter: PeerVisibilityFilter) -> void:
|
||||
_visibility_filters[node] = filter
|
||||
|
||||
## Deregister the visibility filter used for [param]node[/param]
|
||||
func deregister_visibility_filter(node: Node) -> void:
|
||||
_visibility_filters.erase(node)
|
||||
|
||||
## Deregister any and all settings associated with [param]node[/param]
|
||||
func deregister(node: Node) -> void:
|
||||
_rb_state_properties.erase_subject(node)
|
||||
_rb_input_properties.erase_subject(node)
|
||||
_rb_owned_state_properties.erase_subject(node)
|
||||
_rb_owned_input_properties.erase_subject(node)
|
||||
_sync_state_properties.erase_subject(node)
|
||||
_visibility_filters.erase(node)
|
||||
_schemas.erase_subject(node)
|
||||
|
||||
func _is_node_visible_to(peer: int, node: Node) -> bool:
|
||||
var filter := _visibility_filters.get(node) as PeerVisibilityFilter
|
||||
if not filter:
|
||||
return true
|
||||
else:
|
||||
return filter.get_visible_peers().has(peer)
|
||||
|
||||
func _synchronize_input(tick: int) -> void:
|
||||
# We don't own inputs, nothing to synchronize
|
||||
if _rb_owned_input_properties.is_empty():
|
||||
return
|
||||
|
||||
var snapshots := [] as Array[_Snapshot]
|
||||
var notified_peers := _Set.new()
|
||||
|
||||
if not _rb_enable_input_broadcast:
|
||||
# If input broadcast is off, find which peers need to know our inputs
|
||||
# That is all peers who own state controlled by our input
|
||||
|
||||
# Grab owned input objects
|
||||
for input_subject in _rb_owned_input_properties.get_subjects():
|
||||
# Grab state objects controlled by input
|
||||
var controlled_nodes := RollbackSimulationServer._get_controlled_by(input_subject)
|
||||
|
||||
# Notify peers owning nodes about the input
|
||||
for node in controlled_nodes:
|
||||
notified_peers.add(node.get_multiplayer_authority())
|
||||
else:
|
||||
# If input broadcast is on, send inputs to everyone
|
||||
for peer in multiplayer.get_peers():
|
||||
notified_peers.add(peer)
|
||||
|
||||
# Make sure to not send input to ourselves
|
||||
notified_peers.erase(multiplayer.get_unique_id())
|
||||
|
||||
# Prepare snapshot package
|
||||
for offset in _input_redundancy:
|
||||
# Grab snapshot from NetworkHistoryServer
|
||||
var snapshot := NetworkHistoryServer._get_rollback_input_snapshot(tick - offset)
|
||||
if not snapshot:
|
||||
break
|
||||
|
||||
_logger.trace("Submitting input: %s", [snapshot])
|
||||
snapshots.append(snapshot)
|
||||
|
||||
_logger.trace("Submitting input to peers: %s", [notified_peers])
|
||||
for peer in notified_peers:
|
||||
var data := _redundant_serializer.write_for(peer, snapshots, _rb_owned_input_properties)
|
||||
_cmd_input.send(data, peer)
|
||||
|
||||
func _synchronize_state(tick: int) -> void:
|
||||
# We don't own state, nothing to synchronize
|
||||
if _rb_owned_state_properties.is_empty():
|
||||
return
|
||||
|
||||
# Grab snapshot from NetworkHistoryServer
|
||||
var snapshot := NetworkHistoryServer._get_rollback_state_snapshot(tick)
|
||||
if not snapshot:
|
||||
# No data for tick
|
||||
return
|
||||
|
||||
if snapshot.is_empty():
|
||||
# Nothing to send
|
||||
return
|
||||
|
||||
# Figure out whether to send full- or diff state
|
||||
var is_full := _rb_full_scheduler.is_now()
|
||||
if not _rb_enable_diffs:
|
||||
is_full = true
|
||||
|
||||
# Check if we have history to diff to
|
||||
var reference_snapshot := NetworkHistoryServer._get_rollback_state_snapshot(tick - 1)
|
||||
if not reference_snapshot:
|
||||
is_full = true
|
||||
|
||||
if is_full:
|
||||
# Send full states
|
||||
for peer in multiplayer.get_peers():
|
||||
var filter := func(subject): return _is_node_visible_to(peer, subject)
|
||||
|
||||
var data := _dense_serializer.write_for(peer, snapshot, _rb_owned_state_properties, filter)
|
||||
if data.is_empty():
|
||||
# Peer can't see anything, send nothing
|
||||
continue
|
||||
|
||||
_cmd_full_state.send(data, peer)
|
||||
|
||||
NetworkPerformance.push_full_state_props(snapshot.size())
|
||||
NetworkPerformance.push_sent_state_props(snapshot.size())
|
||||
else:
|
||||
var diff := _Snapshot.make_patch(reference_snapshot, snapshot)
|
||||
if diff.is_empty():
|
||||
# Nothing changed, don't send anything
|
||||
return
|
||||
|
||||
# Send diff states
|
||||
for peer in multiplayer.get_peers():
|
||||
var filter := func(subject): return _is_node_visible_to(peer, subject)
|
||||
|
||||
var data := _sparse_serializer.write_for(peer, diff, _rb_owned_state_properties, filter)
|
||||
if data.is_empty():
|
||||
# Peer can't see any changes, send nothing
|
||||
continue
|
||||
|
||||
_cmd_diff_state.send(data, peer)
|
||||
|
||||
NetworkPerformance.push_full_state_props(snapshot.size())
|
||||
NetworkPerformance.push_sent_state_props(diff.size())
|
||||
|
||||
func _synchronize_sync_state(tick: int) -> void:
|
||||
# We don't own sync state, nothing to synchronize
|
||||
if _sync_owned_state_properties.is_empty():
|
||||
return
|
||||
|
||||
# Grab snapshot from NetworkHistoryServer
|
||||
var snapshot := NetworkHistoryServer._get_synchronizer_state_snapshot(tick)
|
||||
if not snapshot:
|
||||
return
|
||||
|
||||
# Figure out whether to send full- or diff state
|
||||
var is_full := _sync_full_scheduler.is_now()
|
||||
if not _sync_enable_diffs:
|
||||
is_full = true
|
||||
|
||||
if is_full:
|
||||
# Send full states
|
||||
for peer in multiplayer.get_peers():
|
||||
var filter := func(subject): return _is_node_visible_to(peer, subject)
|
||||
|
||||
var data := _dense_serializer.write_for(peer, snapshot, _sync_owned_state_properties, filter)
|
||||
if data.is_empty():
|
||||
# Peer can't see anything, send nothing
|
||||
continue
|
||||
|
||||
_cmd_full_sync.send(data, peer)
|
||||
|
||||
NetworkPerformance.push_full_state_props(snapshot.size())
|
||||
NetworkPerformance.push_sent_state_props(snapshot.size())
|
||||
else:
|
||||
var diff := _Snapshot.make_patch(_last_sync_state_sent, snapshot)
|
||||
|
||||
# Send diffs
|
||||
for peer in multiplayer.get_peers():
|
||||
var filter := func(subject): return _is_node_visible_to(peer, subject)
|
||||
|
||||
var data := _sparse_serializer.write_for(peer, diff, _sync_owned_state_properties, filter)
|
||||
if data.is_empty():
|
||||
# Peer can't see anything, send nothing
|
||||
continue
|
||||
|
||||
_cmd_diff_sync.send(data, peer)
|
||||
|
||||
NetworkPerformance.push_full_state_props(snapshot.size())
|
||||
NetworkPerformance.push_sent_state_props(diff.size())
|
||||
|
||||
# Remember last sent state for diffing
|
||||
# NOTE: This is a shared instance, theoretically shouldn't screw things up
|
||||
_last_sync_state_sent = snapshot
|
||||
|
||||
func _init(
|
||||
p_command_server: _NetworkCommandServer = null,
|
||||
p_history_server: _NetworkHistoryServer = null,
|
||||
p_identity_server: _NetworkIdentityServer = null,
|
||||
p_simulation_server: _RollbackSimulationServer = null
|
||||
):
|
||||
_command_server = p_command_server
|
||||
_history_server = p_history_server
|
||||
_identity_server = p_identity_server
|
||||
_simulation_server = p_simulation_server
|
||||
|
||||
func _ready():
|
||||
# Ensure dependencies
|
||||
if not _command_server: _command_server = NetworkCommandServer
|
||||
if not _history_server: _history_server = NetworkHistoryServer
|
||||
if not _identity_server: _identity_server = NetworkIdentityServer
|
||||
if not _simulation_server: _simulation_server = RollbackSimulationServer
|
||||
|
||||
# Setup serializers
|
||||
_dense_serializer = _DenseSnapshotSerializer.new(_schemas, _identity_server)
|
||||
_sparse_serializer = _SparseSnapshotSerializer.new(_schemas, _identity_server)
|
||||
_redundant_serializer = _RedundantSnapshotSerializer.new(_schemas, _identity_server)
|
||||
|
||||
# Setup commands
|
||||
_cmd_full_state = _command_server.register_command(_handle_full_state, MultiplayerPeer.TRANSFER_MODE_UNRELIABLE)
|
||||
_cmd_diff_state = _command_server.register_command(_handle_diff_state, MultiplayerPeer.TRANSFER_MODE_UNRELIABLE)
|
||||
_cmd_input = _command_server.register_command(_handle_input, MultiplayerPeer.TRANSFER_MODE_UNRELIABLE)
|
||||
|
||||
_cmd_full_sync = _command_server.register_command(_handle_full_sync, MultiplayerPeer.TRANSFER_MODE_UNRELIABLE_ORDERED)
|
||||
_cmd_diff_sync = _command_server.register_command(_handle_diff_sync, MultiplayerPeer.TRANSFER_MODE_UNRELIABLE_ORDERED)
|
||||
|
||||
func _handle_input(sender: int, data: PackedByteArray):
|
||||
var buffer := StreamPeerBuffer.new()
|
||||
buffer.data_array = data
|
||||
|
||||
var snapshots := _redundant_serializer.read_from(sender, _rb_input_properties, buffer, true)
|
||||
|
||||
for snapshot in snapshots:
|
||||
snapshot.sanitize(sender)
|
||||
|
||||
_logger.trace("Ingesting input: %s", [snapshot])
|
||||
if NetworkHistoryServer._merge_rollback_input(snapshot):
|
||||
_on_input.emit(snapshot)
|
||||
|
||||
func _handle_full_state(sender: int, data: PackedByteArray):
|
||||
var buffer := StreamPeerBuffer.new()
|
||||
buffer.data_array = data
|
||||
|
||||
var snapshot := _dense_serializer.read_from(sender, _rb_state_properties, buffer, true)
|
||||
|
||||
_ingest_state(sender, snapshot)
|
||||
|
||||
func _handle_diff_state(sender: int, data: PackedByteArray):
|
||||
var buffer := StreamPeerBuffer.new()
|
||||
buffer.data_array = data
|
||||
|
||||
var diff := _sparse_serializer.read_from(sender, _rb_state_properties, buffer)
|
||||
_logger.trace("Received diff state for @%d", [diff.tick])
|
||||
|
||||
_ingest_state(sender, diff)
|
||||
|
||||
func _handle_full_sync(sender: int, data: PackedByteArray):
|
||||
var buffer := StreamPeerBuffer.new()
|
||||
buffer.data_array = data
|
||||
|
||||
var snapshot := _dense_serializer.read_from(sender, _sync_state_properties, buffer, true)
|
||||
snapshot.sanitize(sender)
|
||||
|
||||
NetworkHistoryServer._merge_synchronizer_state(snapshot)
|
||||
_logger.trace("Ingested sync state: %s", [snapshot])
|
||||
|
||||
func _handle_diff_sync(sender: int, data: PackedByteArray):
|
||||
var buffer := StreamPeerBuffer.new()
|
||||
buffer.data_array = data
|
||||
|
||||
var snapshot := _sparse_serializer.read_from(sender, _sync_state_properties, buffer)
|
||||
snapshot.sanitize(sender)
|
||||
|
||||
NetworkHistoryServer._merge_synchronizer_state(snapshot)
|
||||
_logger.trace("Ingested sync diff: %s", [snapshot])
|
||||
|
||||
func _ingest_state(sender: int, snapshot: _Snapshot) -> void:
|
||||
snapshot.sanitize(sender)
|
||||
|
||||
NetworkHistoryServer._merge_rollback_state(snapshot)
|
||||
_logger.trace("Ingested state: %s", [snapshot])
|
||||
|
||||
_on_state.emit(snapshot)
|
||||
@@ -0,0 +1 @@
|
||||
uid://yrhqsbd5ubhs
|
||||
@@ -0,0 +1,201 @@
|
||||
extends Node
|
||||
class_name _RollbackSimulationServer
|
||||
|
||||
## Runs gameplay simulation during rollback
|
||||
##
|
||||
## Rollback involves restoring the game state to an earlier point in time and
|
||||
## re-running game logic from there. This class tracks which nodes participate
|
||||
## in rollback, which of them need to be actually simulated, and runs the
|
||||
## simulation itself.
|
||||
## [br][br]
|
||||
## Node simulation honors scene tree order. Processing order and physics
|
||||
## processing order are [b]not[/b] considered.
|
||||
## [br][br]
|
||||
## To participate in rollback, call [method register] using the method to call
|
||||
## to simulate the node. Only one [Callable] can be actively registered per
|
||||
## node.
|
||||
|
||||
var _history_server: _NetworkHistoryServer
|
||||
|
||||
var _callbacks := {} # node to callback
|
||||
var _simulated_ticks := {} # node to array of ticks
|
||||
|
||||
var _input_graph := _Graph.new() # Links inputs to objects controlled by them
|
||||
|
||||
# Currently simulated object
|
||||
var _current_object: Object = null
|
||||
# Predicted nodes for next simulation
|
||||
var _predicted_nodes := _Set.new()
|
||||
|
||||
var _group := StringName("__nf_rollback_sim" + str(get_instance_id()))
|
||||
|
||||
static var _logger := NetfoxLogger._for_netfox("RollbackSimulationServer")
|
||||
|
||||
## Register a [param]callback[/param] to run as part of the rollback loop
|
||||
func register(callback: Callable) -> void:
|
||||
if not is_instance_valid(callback.get_object()):
|
||||
_logger.error("Trying to register callback that belongs to an invalid object!")
|
||||
return
|
||||
|
||||
assert(callback.get_object() is Node, "Only nodes supported for now!")
|
||||
|
||||
_callbacks[callback.get_object()] = callback
|
||||
|
||||
## Deregister a [param]callback[/param] from the rollback loop
|
||||
func deregister(callback: Callable) -> void:
|
||||
if not callback or not callback.is_valid(): return
|
||||
|
||||
var object := callback.get_object()
|
||||
|
||||
if not is_instance_valid(object): return
|
||||
if _callbacks[object] != callback: return
|
||||
|
||||
_callbacks.erase(object)
|
||||
_input_graph.erase(object)
|
||||
_simulated_ticks.erase(object)
|
||||
|
||||
## Deregister a [param]node[/param] from the rollback loop
|
||||
func deregister_node(node: Node) -> void:
|
||||
if _callbacks.has(node):
|
||||
deregister(_callbacks[node])
|
||||
_input_graph.erase(node)
|
||||
|
||||
## Register [param]input[/param] as providing input for [param]node[/param]
|
||||
func register_rollback_input_for(node: Node, input: Node) -> void:
|
||||
_input_graph.link(input, node)
|
||||
|
||||
## Deregister [param]input[/param] from providing input for [param]node[/param]
|
||||
func deregister_rollback_input(node: Node, input: Node) -> void:
|
||||
_input_graph.unlink(input, node)
|
||||
|
||||
## Return true if the currently simulated node is being predicted
|
||||
func is_predicting_current() -> bool:
|
||||
if not _current_object or not is_instance_valid(_current_object):
|
||||
return false
|
||||
return _predicted_nodes.has(_current_object)
|
||||
|
||||
## Get the currently simulated object
|
||||
func get_simulated_object() -> Object:
|
||||
return _current_object
|
||||
|
||||
## Simulate a tick
|
||||
func simulate(delta: float, tick: int) -> void:
|
||||
_current_object = null
|
||||
|
||||
var input_snapshot := NetworkHistoryServer._get_rollback_input_snapshot(tick)
|
||||
var state_snapshot := NetworkHistoryServer._get_rollback_state_snapshot(tick)
|
||||
var nodes := _get_nodes_to_simulate(input_snapshot)
|
||||
_predicted_nodes.clear()
|
||||
|
||||
# Sort based on SceneTree order
|
||||
for node in nodes:
|
||||
node.add_to_group(_group)
|
||||
nodes = get_tree().get_nodes_in_group(_group)
|
||||
|
||||
# Determine predicted nodes
|
||||
for node in _callbacks.keys():
|
||||
if _is_predicting(input_snapshot, node):
|
||||
_predicted_nodes.add(node)
|
||||
|
||||
# Run callbacks and clear group
|
||||
for node in nodes:
|
||||
_current_object = node
|
||||
|
||||
var callback := _callbacks[node] as Callable
|
||||
var is_fresh := _is_tick_fresh_for(node, tick)
|
||||
callback.call(delta, tick, is_fresh)
|
||||
node.remove_from_group(_group)
|
||||
|
||||
_current_object = null
|
||||
_set_tick_simulated_for(node, tick)
|
||||
|
||||
# Metrics
|
||||
NetworkPerformance.push_rollback_nodes_simulated(nodes.size())
|
||||
|
||||
func _get_nodes_to_simulate(input_snapshot: _Snapshot) -> Array[Node]:
|
||||
var result: Array[Node] = []
|
||||
if not input_snapshot:
|
||||
return []
|
||||
|
||||
var tick := input_snapshot.tick
|
||||
for node in _callbacks.keys():
|
||||
var inputs := [] as Array[Node]
|
||||
inputs.assign(_input_graph.get_linked_to(node))
|
||||
|
||||
if inputs.is_empty():
|
||||
# Node has no input, simulate it
|
||||
result.append(node)
|
||||
continue
|
||||
|
||||
if NetworkRollback.is_mutated(node, tick):
|
||||
# Node is mutated, must simulate
|
||||
result.append(node)
|
||||
continue
|
||||
|
||||
if not input_snapshot.has_subjects(inputs, true):
|
||||
# We don't have input for node, don't simulate
|
||||
continue
|
||||
|
||||
result.append(node)
|
||||
|
||||
return result
|
||||
|
||||
func _is_predicting(input_snapshot: _Snapshot, node: Node) -> bool:
|
||||
var input_nodes := [] as Array[Node]
|
||||
input_nodes.assign(_input_graph.get_linked_to(node))
|
||||
|
||||
var is_owned := node.is_multiplayer_authority()
|
||||
var is_inputless := input_nodes.is_empty()
|
||||
var has_input := false
|
||||
|
||||
if not is_inputless and input_snapshot:
|
||||
has_input = input_snapshot.has_subjects(input_nodes, true)
|
||||
|
||||
if not is_owned and has_input:
|
||||
# We don't own the node, but we own input for it - not (input) predicting
|
||||
return false
|
||||
if not is_owned:
|
||||
# We don't own the node, so we can only guess - i.e. predict
|
||||
return true
|
||||
if is_owned and is_inputless:
|
||||
# We own the node, node doesn't depend on input, we're sure
|
||||
return false
|
||||
if is_owned and not has_input:
|
||||
# We own the node, node depends on input, we don't have data for input - predict
|
||||
return true
|
||||
# We own the node and we have data for node's input - we're sure
|
||||
return false
|
||||
|
||||
func _is_tick_fresh_for(node: Node, tick: int) -> bool:
|
||||
if not _simulated_ticks.has(node):
|
||||
return true
|
||||
var ticks := _simulated_ticks.get(node) as Array[int]
|
||||
return not ticks.has(tick)
|
||||
|
||||
func _set_tick_simulated_for(node: Node, tick: int) -> void:
|
||||
if not _simulated_ticks.has(node):
|
||||
_simulated_ticks[node] = [tick] as Array[int]
|
||||
else:
|
||||
_simulated_ticks[node].append(tick)
|
||||
|
||||
func _trim_ticks_simulated(beginning: int) -> void:
|
||||
for object in _simulated_ticks:
|
||||
_simulated_ticks[object] = _simulated_ticks[object]\
|
||||
.filter(func(tick): return tick >= beginning)
|
||||
|
||||
func _get_controlled_by(input: Node) -> Array[Node]:
|
||||
var result := [] as Array[Node]
|
||||
result.assign(_input_graph.get_linked_from(input))
|
||||
return result
|
||||
|
||||
func _get_inputs_of(node: Node) -> Array[Node]:
|
||||
var result := [] as Array[Node]
|
||||
result.assign(_input_graph.get_linked_to(node))
|
||||
return result
|
||||
|
||||
func _init(p_history_server: _NetworkHistoryServer = null):
|
||||
_history_server = p_history_server
|
||||
|
||||
func _ready():
|
||||
# Ensure dependencies
|
||||
if not _history_server: _history_server = NetworkHistoryServer
|
||||
@@ -0,0 +1 @@
|
||||
uid://d5vx6blln3jr
|
||||
Reference in New Issue
Block a user