Merged in the backwards utilities.

modules/network_synchronizer/godot_backward_utility_header.h → modules/network_synchronizer/compat_object_id.h

@@ -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

modules/network_synchronizer/net_utilities.cpp

@@ -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;
 }

modules/network_synchronizer/net_utilities.h

@@ -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

modules/network_synchronizer/networked_controller.cpp

@@ -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,34 +420,34 @@ void NetworkedController::native_controller_process(double p_delta, DataBuffer &
 	PROFILE_NODE
 
 	call(
-			SNAME("_controller_process"),
+			"_controller_process",
 			p_delta,
 			&p_buffer);
 }
 
 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);
 }
 

modules/network_synchronizer/networked_controller.h

@@ -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;

modules/network_synchronizer/scene_synchronizer.cpp

@@ -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() {