Relintai/pandemonium_engine
1
0
Fork 0
mirror of https://github.com/Relintai/pandemonium_engine.git synced 2025-03-15 17:26:21 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merged in the backwards utilities.

Browse Source
This commit is contained in:
Relintai 2023-12-25 20:12:56 +01:00
parent e44c46d7a9
commit 2ae29884cb
8 changed files with 59 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
modules/network_synchronizer/godot_backward_utility_header.h → modules/network_synchronizer/compat_object_id.h
View File

@ -1,10 +1,5 @@
#pragma once
/// Used to compile against Godot 3.x
/**
@author AndreaCatania
*/
#ifndef COMPAT_OBJECT_ID_H
#define COMPAT_OBJECT_ID_H
#include "core/typedefs.h"
@ -20,4 +15,6 @@ struct CompatObjectID {
bool is_valid() const { return id != 0; }
bool is_null() const { return id == 0; }
};
};
#endif

14
modules/network_synchronizer/godot_backward_utility_cpp.h
View File

@ -1,14 +0,0 @@
#pragma once
/// Used to compile against Godot 3.x
/**
@author AndreaCatania
*/
#include "core/config/engine.h"
#include "scene/main/viewport.h"
#define FLOAT REAL
#define STRING_NAME STRING
#define Callable(a, b) a, b
#define ObjectID CompatObjectID
#define SNAME(a) a

2
modules/network_synchronizer/net_utilities.cpp
View File

@ -35,8 +35,6 @@
#include "net_utilities.h"
#include "scene/main/node.h"
#include "godot_backward_utility_cpp.h"
bool NetUtility::ChangeListener::operator==(const ChangeListener &p_other) const {
return object_id == p_other.object_id && method == p_other.method;
}

9
modules/network_synchronizer/net_utilities.h
View File

@ -42,8 +42,7 @@
#include "net_action_info.h"
#include "net_action_processor.h"
#include "godot_backward_utility_header.h"
#define ObjectID CompatObjectID
#include "compat_object_id.h"
#ifdef DEBUG_ENABLED
#define NET_DEBUG_PRINT(msg) \
@ -306,7 +305,7 @@ struct NodeChangeListener {
/// by the flag.
struct ChangeListener {
// TODO use a callable instead??
ObjectID object_id = ObjectID();
CompatObjectID object_id = CompatObjectID();
StringName method;
uint32_t method_argument_count;
NetEventFlag flag;
@ -341,7 +340,7 @@ struct VarData {
struct NodeData {
// ID used to reference this Node in the networked calls.
uint32_t id = 0;
ObjectID instance_id = ObjectID();
CompatObjectID instance_id = CompatObjectID();
NodeData *controlled_by = nullptr;
/// When `false`, this node is not sync. It's usefult to locally pause sync
@ -397,6 +396,6 @@ struct PostponedRecover {
} // namespace NetUtility
#undef ObjectID
#undef CompatObjectID
#endif

54
modules/network_synchronizer/networked_controller.cpp
View File

@ -41,8 +41,6 @@
#include "scene_synchronizer_debugger.h"
#include <algorithm>
#include "godot_backward_utility_cpp.h"
#define METADATA_SIZE 1
#define DOLL_EPOCH_METADATA_SIZE (DataBuffer::get_bit_taken(DataBuffer::DATA_TYPE_REAL, DataBuffer::COMPRESSION_LEVEL_1) + DataBuffer::get_bit_taken(DataBuffer::DATA_TYPE_INT, DataBuffer::COMPRESSION_LEVEL_1))
@ -112,26 +110,26 @@ void NetworkedController::_bind_methods() {
ClassDB::bind_method(D_METHOD("__on_sync_paused"), &NetworkedController::__on_sync_paused);
BIND_VMETHOD(MethodInfo("_collect_inputs", PropertyInfo(Variant::FLOAT, "delta"), PropertyInfo(Variant::OBJECT, "buffer", PROPERTY_HINT_RESOURCE_TYPE, "DataBuffer")));
BIND_VMETHOD(MethodInfo("_controller_process", PropertyInfo(Variant::FLOAT, "delta"), PropertyInfo(Variant::OBJECT, "buffer", PROPERTY_HINT_RESOURCE_TYPE, "DataBuffer")));
BIND_VMETHOD(MethodInfo("_collect_inputs", PropertyInfo(Variant::REAL, "delta"), PropertyInfo(Variant::OBJECT, "buffer", PROPERTY_HINT_RESOURCE_TYPE, "DataBuffer")));
BIND_VMETHOD(MethodInfo("_controller_process", PropertyInfo(Variant::REAL, "delta"), PropertyInfo(Variant::OBJECT, "buffer", PROPERTY_HINT_RESOURCE_TYPE, "DataBuffer")));
BIND_VMETHOD(MethodInfo(Variant::BOOL, "_are_inputs_different", PropertyInfo(Variant::OBJECT, "inputs_A", PROPERTY_HINT_RESOURCE_TYPE, "DataBuffer"), PropertyInfo(Variant::OBJECT, "inputs_B", PROPERTY_HINT_RESOURCE_TYPE, "DataBuffer")));
BIND_VMETHOD(MethodInfo(Variant::INT, "_count_input_size", PropertyInfo(Variant::OBJECT, "inputs", PROPERTY_HINT_RESOURCE_TYPE, "DataBuffer")));
BIND_VMETHOD(MethodInfo("_collect_epoch_data", PropertyInfo(Variant::OBJECT, "buffer", PROPERTY_HINT_RESOURCE_TYPE, "DataBuffer")));
BIND_VMETHOD(MethodInfo("_apply_epoch", PropertyInfo(Variant::FLOAT, "delta"), PropertyInfo(Variant::FLOAT, "interpolation_alpha"), PropertyInfo(Variant::OBJECT, "past_buffer", PROPERTY_HINT_RESOURCE_TYPE, "DataBuffer"), PropertyInfo(Variant::OBJECT, "future_buffer", PROPERTY_HINT_RESOURCE_TYPE, "DataBuffer")));
BIND_VMETHOD(MethodInfo("_apply_epoch", PropertyInfo(Variant::REAL, "delta"), PropertyInfo(Variant::REAL, "interpolation_alpha"), PropertyInfo(Variant::OBJECT, "past_buffer", PROPERTY_HINT_RESOURCE_TYPE, "DataBuffer"), PropertyInfo(Variant::OBJECT, "future_buffer", PROPERTY_HINT_RESOURCE_TYPE, "DataBuffer")));
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "server_controlled"), "set_server_controlled", "get_server_controlled");
ADD_PROPERTY(PropertyInfo(Variant::INT, "input_storage_size", PROPERTY_HINT_RANGE, "5,2000,1"), "set_player_input_storage_size", "get_player_input_storage_size");
ADD_PROPERTY(PropertyInfo(Variant::INT, "max_redundant_inputs", PROPERTY_HINT_RANGE, "0,1000,1"), "set_max_redundant_inputs", "get_max_redundant_inputs");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "tick_speedup_notification_delay", PROPERTY_HINT_RANGE, "0,5000,1"), "set_tick_speedup_notification_delay", "get_tick_speedup_notification_delay");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "tick_speedup_notification_delay", PROPERTY_HINT_RANGE, "0,5000,1"), "set_tick_speedup_notification_delay", "get_tick_speedup_notification_delay");
ADD_PROPERTY(PropertyInfo(Variant::INT, "network_traced_frames", PROPERTY_HINT_RANGE, "1,1000,1"), "set_network_traced_frames", "get_network_traced_frames");
ADD_PROPERTY(PropertyInfo(Variant::INT, "min_frames_delay", PROPERTY_HINT_RANGE, "0,100,1"), "set_min_frames_delay", "get_min_frames_delay");
ADD_PROPERTY(PropertyInfo(Variant::INT, "max_frames_delay", PROPERTY_HINT_RANGE, "0,100,1"), "set_max_frames_delay", "get_max_frames_delay");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "tick_acceleration", PROPERTY_HINT_RANGE, "0.1,20.0,0.01"), "set_tick_acceleration", "get_tick_acceleration");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "tick_acceleration", PROPERTY_HINT_RANGE, "0.1,20.0,0.01"), "set_tick_acceleration", "get_tick_acceleration");
ADD_PROPERTY(PropertyInfo(Variant::INT, "doll_sync_rate", PROPERTY_HINT_RANGE, "1,240,1"), "set_doll_sync_rate", "get_doll_sync_rate");
ADD_PROPERTY(PropertyInfo(Variant::INT, "doll_min_frames_delay", PROPERTY_HINT_RANGE, "0,240,1"), "set_doll_min_frames_delay", "get_doll_min_frames_delay");
ADD_PROPERTY(PropertyInfo(Variant::INT, "doll_max_frames_delay", PROPERTY_HINT_RANGE, "0,240,1"), "set_doll_max_frames_delay", "get_doll_max_frames_delay");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "doll_net_sensitivity", PROPERTY_HINT_RANGE, "0,1.0,0.00001"), "set_doll_net_sensitivity", "get_doll_net_sensitivity");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "doll_interpolation_max_overshot", PROPERTY_HINT_RANGE, "0.01,5.0,0.01"), "set_doll_interpolation_max_overshot", "get_doll_interpolation_max_overshot");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "doll_net_sensitivity", PROPERTY_HINT_RANGE, "0,1.0,0.00001"), "set_doll_net_sensitivity", "get_doll_net_sensitivity");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "doll_interpolation_max_overshot", PROPERTY_HINT_RANGE, "0.01,5.0,0.01"), "set_doll_interpolation_max_overshot", "get_doll_interpolation_max_overshot");
ADD_PROPERTY(PropertyInfo(Variant::INT, "doll_connection_stats_frame_span", PROPERTY_HINT_RANGE, "1,1000,1"), "set_doll_connection_stats_frame_span", "get_doll_connection_stats_frame_span");
ADD_SIGNAL(MethodInfo("doll_sync_started"));
@ -142,11 +140,11 @@ void NetworkedController::_bind_methods() {
}
NetworkedController::NetworkedController() {
rpc_config(SNAME("_rpc_server_send_inputs"), MultiplayerAPI::RPC_MODE_REMOTE);
rpc_config(SNAME("_rpc_set_server_controlled"), MultiplayerAPI::RPC_MODE_REMOTE);
rpc_config(SNAME("_rpc_notify_fps_acceleration"), MultiplayerAPI::RPC_MODE_REMOTE);
rpc_config(SNAME("_rpc_doll_notify_sync_pause"), MultiplayerAPI::RPC_MODE_REMOTE);
rpc_config(SNAME("_rpc_doll_send_epoch_batch"), MultiplayerAPI::RPC_MODE_REMOTE);
rpc_config("_rpc_server_send_inputs", MultiplayerAPI::RPC_MODE_REMOTE);
rpc_config("_rpc_set_server_controlled", MultiplayerAPI::RPC_MODE_REMOTE);
rpc_config("_rpc_notify_fps_acceleration", MultiplayerAPI::RPC_MODE_REMOTE);
rpc_config("_rpc_doll_notify_sync_pause", MultiplayerAPI::RPC_MODE_REMOTE);
rpc_config("_rpc_doll_send_epoch_batch", MultiplayerAPI::RPC_MODE_REMOTE);
}
NetworkedController::~NetworkedController() {
@ -181,7 +179,7 @@ void NetworkedController::set_server_controlled(bool p_server_controlled) {
if (get_network_master() != 1) {
rpc_id(
get_network_master(),
SNAME("_rpc_set_server_controlled"),
"_rpc_set_server_controlled",
server_controlled);
} else {
SceneSynchronizerDebugger::singleton()->debug_warning(this, "The node is owned by the server, there is no client that can control it; please assign the proper authority.");
@ -383,7 +381,7 @@ void NetworkedController::set_doll_peer_active(int p_peer_id, bool p_active) {
if (p_active == false) {
// Notify the doll only for deactivations. The activations are automatically
// handled when the first epoch is received.
rpc_id(p_peer_id, SNAME("_rpc_doll_notify_sync_pause"), server_controller->epoch);
rpc_id(p_peer_id, "_rpc_doll_notify_sync_pause", server_controller->epoch);
}
}
@ -395,7 +393,7 @@ void NetworkedController::pause_notify_dolls() {
for (uint32_t i = 0; i < server_controller->peers.size(); i += 1) {
if (server_controller->peers[i].active) {
// Notify this actor is no more active.
rpc_id(server_controller->peers[i].peer, SNAME("_rpc_doll_notify_sync_pause"), server_controller->epoch);
rpc_id(server_controller->peers[i].peer, "_rpc_doll_notify_sync_pause", server_controller->epoch);
}
}
}
@ -413,7 +411,7 @@ void NetworkedController::native_collect_inputs(double p_delta, DataBuffer &r_bu
PROFILE_NODE
call(
SNAME("_collect_inputs"),
"_collect_inputs",
p_delta,
&r_buffer);
}
@ -422,7 +420,7 @@ void NetworkedController::native_controller_process(double p_delta, DataBuffer &
PROFILE_NODE
call(
SNAME("_controller_process"),
"_controller_process",
p_delta,
&p_buffer);
}
@ -430,26 +428,26 @@ void NetworkedController::native_controller_process(double p_delta, DataBuffer &
bool NetworkedController::native_are_inputs_different(DataBuffer &p_buffer_A, DataBuffer &p_buffer_B) {
PROFILE_NODE
return call(SNAME("_are_inputs_different"), &p_buffer_A, &p_buffer_B);
return call("_are_inputs_different", &p_buffer_A, &p_buffer_B);
}
uint32_t NetworkedController::native_count_input_size(DataBuffer &p_buffer) {
PROFILE_NODE
return call(SNAME("_count_input_size"), &p_buffer);
return call("_count_input_size", &p_buffer);
}
void NetworkedController::native_collect_epoch_data(DataBuffer &r_buffer) {
PROFILE_NODE
call(SNAME("_collect_epoch_data"), &r_buffer);
call("_collect_epoch_data", &r_buffer);
}
void NetworkedController::native_apply_epoch(double p_delta, real_t p_interpolation_alpha, DataBuffer &p_past_buffer, DataBuffer &p_future_buffer) {
PROFILE_NODE
call(
SNAME("_apply_epoch"),
"_apply_epoch",
p_delta,
p_interpolation_alpha,
&p_past_buffer,
@ -528,13 +526,13 @@ void NetworkedController::set_inputs_buffer(const BitArray &p_new_buffer, uint32
void NetworkedController::set_scene_synchronizer(SceneSynchronizer *p_synchronizer) {
if (scene_synchronizer) {
scene_synchronizer->disconnect(SNAME("sync_paused"), Callable(this, SNAME("__on_sync_paused")));
scene_synchronizer->disconnect("sync_paused", this, "__on_sync_paused");
}
scene_synchronizer = p_synchronizer;
if (scene_synchronizer) {
scene_synchronizer->connect(SNAME("sync_paused"), Callable(this, SNAME("__on_sync_paused")));
scene_synchronizer->connect("sync_paused", this, "__on_sync_paused");
}
}
@ -1115,7 +1113,7 @@ void ServerController::doll_sync(real_t p_delta) {
// Send the data
node->rpc_unreliable_id(
peers[i].peer,
SNAME("_rpc_doll_send_epoch_batch"),
"_rpc_doll_send_epoch_batch",
epoch_state_data_cache.get_buffer().get_bytes());
}
@ -1189,7 +1187,7 @@ void ServerController::adjust_player_tick_rate(double p_delta) {
node->rpc_unreliable_id(
node->get_network_master(),
SNAME("_rpc_notify_fps_acceleration"),
"_rpc_notify_fps_acceleration",
packet_data);
}
}
@ -1555,7 +1553,7 @@ void PlayerController::send_frame_input_buffer_to_server() {
const int server_peer_id = 1;
node->rpc_unreliable_id(
server_peer_id,
SNAME("_rpc_server_send_inputs"),
"_rpc_server_send_inputs",
packet_data);
}

2
modules/network_synchronizer/networked_controller.h
View File

@ -41,7 +41,7 @@
#include "net_utilities.h"
#include <deque>
#include "godot_backward_utility_header.h"
#include "compat_object_id.h"
class SceneSynchronizer;
struct Controller;

44
modules/network_synchronizer/scene_synchronizer.cpp
View File

@ -40,8 +40,8 @@
#include "networked_controller.h"
#include "scene_diff.h"
#include "scene_synchronizer_debugger.h"
#include "godot_backward_utility_cpp.h"
#include "compat_object_id.h"
#include "scene/main/viewport.h"
void SceneSynchronizer::_bind_methods() {
BIND_ENUM_CONSTANT(CHANGE)
@ -132,10 +132,10 @@ void SceneSynchronizer::_bind_methods() {
ClassDB::bind_method(D_METHOD("_rpc_notify_peer_status", "enabled"), &SceneSynchronizer::_rpc_notify_peer_status);
ClassDB::bind_method(D_METHOD("_rpc_send_actions", "enabled"), &SceneSynchronizer::_rpc_send_actions);
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "server_notify_state_interval", PROPERTY_HINT_RANGE, "0.001,10.0,0.0001"), "set_server_notify_state_interval", "get_server_notify_state_interval");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "comparison_float_tolerance", PROPERTY_HINT_RANGE, "0.000001,0.01,0.000001"), "set_comparison_float_tolerance", "get_comparison_float_tolerance");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "server_notify_state_interval", PROPERTY_HINT_RANGE, "0.001,10.0,0.0001"), "set_server_notify_state_interval", "get_server_notify_state_interval");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "comparison_float_tolerance", PROPERTY_HINT_RANGE, "0.000001,0.01,0.000001"), "set_comparison_float_tolerance", "get_comparison_float_tolerance");
ADD_PROPERTY(PropertyInfo(Variant::INT, "actions_redundancy", PROPERTY_HINT_RANGE, "1,10,1"), "set_actions_redundancy", "get_actions_redundancy");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "actions_resend_time", PROPERTY_HINT_RANGE, "0.000001,0.5,0.000001"), "set_actions_resend_time", "get_actions_resend_time");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "actions_resend_time", PROPERTY_HINT_RANGE, "0.000001,0.5,0.000001"), "set_actions_resend_time", "get_actions_resend_time");
ADD_SIGNAL(MethodInfo("sync_started"));
ADD_SIGNAL(MethodInfo("sync_paused"));
@ -166,10 +166,10 @@ void SceneSynchronizer::_notification(int p_what) {
clear();
reset_synchronizer_mode();
get_multiplayer()->connect(SNAME("network_peer_connected"), Callable(this, SNAME("_on_peer_connected")));
get_multiplayer()->connect(SNAME("network_peer_disconnected"), Callable(this, SNAME("_on_peer_disconnected")));
get_multiplayer()->connect("network_peer_connected", this, "_on_peer_connected");
get_multiplayer()->connect("network_peer_disconnected", this, "_on_peer_disconnected");
get_tree()->connect(SNAME("node_removed"), Callable(this, SNAME("_on_node_removed")));
get_tree()->connect("node_removed", this, "_on_node_removed");
// Make sure to reset all the assigned controllers.
reset_controllers();
@ -190,10 +190,10 @@ void SceneSynchronizer::_notification(int p_what) {
clear_peers();
get_multiplayer()->disconnect(SNAME("network_peer_connected"), Callable(this, SNAME("_on_peer_connected")));
get_multiplayer()->disconnect(SNAME("network_peer_disconnected"), Callable(this, SNAME("_on_peer_disconnected")));
get_multiplayer()->disconnect("network_peer_connected", this, "_on_peer_connected");
get_multiplayer()->disconnect("network_peer_disconnected", this, "_on_peer_disconnected");
get_tree()->disconnect(SNAME("node_removed"), Callable(this, SNAME("_on_node_removed")));
get_tree()->disconnect("node_removed", this, "_on_node_removed");
clear();
@ -212,11 +212,11 @@ void SceneSynchronizer::_notification(int p_what) {
}
SceneSynchronizer::SceneSynchronizer() {
rpc_config(SNAME("_rpc_send_state"), MultiplayerAPI::RPC_MODE_REMOTE);
rpc_config(SNAME("_rpc_notify_need_full_snapshot"), MultiplayerAPI::RPC_MODE_REMOTE);
rpc_config(SNAME("_rpc_set_network_enabled"), MultiplayerAPI::RPC_MODE_REMOTE);
rpc_config(SNAME("_rpc_notify_peer_status"), MultiplayerAPI::RPC_MODE_REMOTE);
rpc_config(SNAME("_rpc_send_actions"), MultiplayerAPI::RPC_MODE_REMOTE);
rpc_config("_rpc_send_state", MultiplayerAPI::RPC_MODE_REMOTE);
rpc_config("_rpc_notify_need_full_snapshot", MultiplayerAPI::RPC_MODE_REMOTE);
rpc_config("_rpc_set_network_enabled", MultiplayerAPI::RPC_MODE_REMOTE);
rpc_config("_rpc_notify_peer_status", MultiplayerAPI::RPC_MODE_REMOTE);
rpc_config("_rpc_send_actions", MultiplayerAPI::RPC_MODE_REMOTE);
// Avoid too much useless re-allocations
event_listener.reserve(100);
@ -962,7 +962,7 @@ void SceneSynchronizer::dirty_peers() {
void SceneSynchronizer::set_enabled(bool p_enable) {
ERR_FAIL_COND_MSG(synchronizer_type == SYNCHRONIZER_TYPE_SERVER, "The server is always enabled.");
if (synchronizer_type == SYNCHRONIZER_TYPE_CLIENT) {
rpc_id(1, SNAME("_rpc_set_network_enabled"), p_enable);
rpc_id(1, "_rpc_set_network_enabled", p_enable);
if (p_enable == false) {
// If the peer want to disable, we can disable it locally
// immediately. When it wants to enable the networking, the server
@ -1006,7 +1006,7 @@ void SceneSynchronizer::set_peer_networking_enable(int p_peer, bool p_enable) {
dirty_peers();
// Just notify the peer status.
rpc_id(p_peer, SNAME("_rpc_notify_peer_status"), p_enable);
rpc_id(p_peer, "_rpc_notify_peer_status", p_enable);
} else {
ERR_FAIL_COND_MSG(synchronizer_type != SYNCHRONIZER_TYPE_NONETWORK, "At this point no network is expected.");
static_cast<NoNetSynchronizer *>(synchronizer)->set_enabled(p_enable);
@ -1319,7 +1319,7 @@ void SceneSynchronizer::change_events_flush() {
if (obj == nullptr) {
// Setting the flag to 0 so no events trigger this anymore.
listener.flag = NetEventFlag::EMPTY;
listener.object_id = ObjectID();
listener.object_id = CompatObjectID();
listener.method = StringName();
// Make sure this listener is not tracking any variable.
@ -1529,7 +1529,7 @@ bool SceneSynchronizer::compare(const Variant &p_first, const Variant &p_second,
// Custom evaluation methods
switch (p_first.get_type()) {
case Variant::FLOAT: {
case Variant::REAL: {
return Math::is_equal_approx(p_first, p_second, p_tolerance);
}
case Variant::VECTOR2: {
@ -2259,7 +2259,7 @@ void ServerSynchronizer::process_snapshot_notificator(real_t p_delta) {
snap.append_array(delta_global_nodes_snapshot);
}
scene_synchronizer->rpc_id(*peer_it.key, SNAME("_rpc_send_state"), snap);
scene_synchronizer->rpc_id(*peer_it.key, "_rpc_send_state", snap);
if (nd) {
NetworkedController *controller = static_cast<NetworkedController *>(nd->node);
@ -4009,7 +4009,7 @@ void ClientSynchronizer::notify_server_full_snapshot_is_needed() {
// Notify the server that a full snapshot is needed.
need_full_snapshot_notified = true;
scene_synchronizer->rpc_id(1, SNAME("_rpc_notify_need_full_snapshot"));
scene_synchronizer->rpc_id(1, "_rpc_notify_need_full_snapshot");
}
void ClientSynchronizer::send_actions_to_server() {

2
modules/network_synchronizer/scene_synchronizer.h
View File

@ -43,7 +43,7 @@
#include "net_utilities.h"
#include <deque>
#include "godot_backward_utility_header.h"
#include "compat_object_id.h"
class Synchronizer;
class NetworkedController;