Fixes bug about the client not properly storing its own latency info.

Author: AndreaCatania

godot4/gd_scene_synchronizer.cpp

@@ -62,6 +62,9 @@ void GdSceneSynchronizer::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_nodes_relevancy_update_time", "time"), &GdSceneSynchronizer::set_nodes_relevancy_update_time);
 	ClassDB::bind_method(D_METHOD("get_nodes_relevancy_update_time"), &GdSceneSynchronizer::get_nodes_relevancy_update_time);
 
+	ClassDB::bind_method(D_METHOD("set_frames_per_seconds", "fps"), &GdSceneSynchronizer::set_frames_per_seconds);
+	ClassDB::bind_method(D_METHOD("get_frames_per_seconds"), &GdSceneSynchronizer::get_frames_per_seconds);
+
 	ClassDB::bind_method(D_METHOD("register_node", "node"), &GdSceneSynchronizer::register_node_gdscript);
 	ClassDB::bind_method(D_METHOD("register_node_as_controller_by_peer", "node", "peer"), &GdSceneSynchronizer::register_node_as_controller_by_peer);
 	ClassDB::bind_method(D_METHOD("unregister_node", "node"), &GdSceneSynchronizer::unregister_node);
@@ -84,6 +87,8 @@ void GdSceneSynchronizer::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("setup_trickled_sync", "node", "collect_epoch_func", "apply_epoch_func"), &GdSceneSynchronizer::setup_trickled_sync);
 
+	ClassDB::bind_method(D_METHOD("get_peer_latency", "peer"), &GdSceneSynchronizer::get_peer_latency);
+
 	ClassDB::bind_method(D_METHOD("sync_group_create"), &GdSceneSynchronizer::sync_group_create);
 	ClassDB::bind_method(D_METHOD("sync_group_add_node", "node_id", "group_id", "realtime"), &GdSceneSynchronizer::sync_group_add_node_by_id);
 	ClassDB::bind_method(D_METHOD("sync_group_remove_node", "node_id", "group_id"), &GdSceneSynchronizer::sync_group_remove_node_by_id);
@@ -101,7 +106,7 @@ void GdSceneSynchronizer::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("set_enabled", "enabled"), &GdSceneSynchronizer::set_enabled);
 	ClassDB::bind_method(D_METHOD("set_peer_networking_enable", "peer", "enabled"), &GdSceneSynchronizer::set_peer_networking_enable);
-	ClassDB::bind_method(D_METHOD("get_peer_networking_enable", "peer"), &GdSceneSynchronizer::is_peer_networking_enable);
+	ClassDB::bind_method(D_METHOD("get_peer_networking_enabled", "peer"), &GdSceneSynchronizer::is_peer_networking_enabled);
 
 	ClassDB::bind_method(D_METHOD("is_server"), &GdSceneSynchronizer::is_server);
 	ClassDB::bind_method(D_METHOD("is_client"), &GdSceneSynchronizer::is_client);
@@ -428,6 +433,14 @@ real_t GdSceneSynchronizer::get_nodes_relevancy_update_time() const {
 	return scene_synchronizer.get_objects_relevancy_update_time();
 }
 
+void GdSceneSynchronizer::set_frames_per_seconds(int p_fps) {
+	scene_synchronizer.set_frames_per_seconds(p_fps);
+}
+
+int GdSceneSynchronizer::get_frames_per_seconds() const {
+	return scene_synchronizer.get_frames_per_seconds();
+}
+
 void GdSceneSynchronizer::_rpc_net_sync_reliable(const Vector<uint8_t> &p_args) {
 	static_cast<GdNetworkInterface *>(&scene_synchronizer.get_network_interface())->gd_rpc_receive(p_args);
 }
@@ -586,6 +599,10 @@ void GdSceneSynchronizer::setup_trickled_sync(Node *p_node, const Callable &p_co
 			});
 }
 
+int GdSceneSynchronizer::get_peer_latency(int p_peer) const {
+	return scene_synchronizer.get_peer_latency(p_peer);
+}
+
 Array GdSceneSynchronizer::local_controller_get_controlled_nodes() const {
 	Array a;
 
@@ -700,8 +717,8 @@ void GdSceneSynchronizer::set_peer_networking_enable(int p_peer, bool p_enable)
 	scene_synchronizer.set_peer_networking_enable(p_peer, p_enable);
 }
 
-bool GdSceneSynchronizer::is_peer_networking_enable(int p_peer) const {
-	return scene_synchronizer.is_peer_networking_enable(p_peer);
+bool GdSceneSynchronizer::is_peer_networking_enabled(int p_peer) const {
+	return scene_synchronizer.is_peer_networking_enabled(p_peer);
 }
 
 bool GdSceneSynchronizer::is_server() const {

godot4/gd_scene_synchronizer.h

@@ -62,6 +62,9 @@ class GdSceneSynchronizer : public Node, public NS::SynchronizerManager {
 	void set_nodes_relevancy_update_time(real_t p_time);
 	real_t get_nodes_relevancy_update_time() const;
 
+	void set_frames_per_seconds(int p_fps);
+	int get_frames_per_seconds() const;
+
 public: // ---------------------------------------- Scene Synchronizer Interface
 	virtual void on_init_synchronizer(bool p_was_generating_ids) override;
 	virtual void on_uninit_synchronizer() override;
@@ -139,6 +142,8 @@ class GdSceneSynchronizer : public Node, public NS::SynchronizerManager {
 
 	Array local_controller_get_controlled_nodes() const;
 
+	int get_peer_latency(int p_peer) const;
+
 	/// Creates a realtime sync group containing a list of nodes.
 	/// The Peers listening to this group will receive the updates only
 	/// from the nodes within this group.
@@ -177,7 +182,7 @@ class GdSceneSynchronizer : public Node, public NS::SynchronizerManager {
 	void set_enabled(bool p_enable);
 
 	void set_peer_networking_enable(int p_peer, bool p_enable);
-	bool is_peer_networking_enable(int p_peer) const;
+	bool is_peer_networking_enabled(int p_peer) const;
 
 	/// Returns true if this peer is server.
 	bool is_server() const;

net_utilities.cpp

@@ -4,12 +4,12 @@
 #include "networked_controller.h"
 #include <limits>
 
-void NS::PeerData::set_ping(int p_ping) {
-	compressed_ping = std::round(float(std::min(p_ping, 1000)) / 4.0);
+void NS::PeerData::set_latency(int p_latency) {
+	compressed_latency = std::round(float(std::min(p_latency, 1000)) / 4.0);
 }
 
-int NS::PeerData::get_ping() const {
-	return compressed_ping * 4.0;
+int NS::PeerData::get_latency() const {
+	return compressed_latency * 4.0;
 }
 
 bool NS::SyncGroup::is_realtime_node_list_changed() const {
@@ -20,8 +20,8 @@ bool NS::SyncGroup::is_trickled_node_list_changed() const {
 	return trickled_sync_objects_list_changed;
 }
 
-const std::vector<int> NS::SyncGroup::get_peers_with_newly_calculated_ping() const {
-	return peers_with_newly_calculated_ping;
+const std::vector<int> NS::SyncGroup::get_peers_with_newly_calculated_latency() const {
+	return peers_with_newly_calculated_latency;
 }
 
 const LocalVector<NS::SyncGroup::SimulatedObjectInfo> &NS::SyncGroup::get_simulated_sync_objects() const {
@@ -47,7 +47,7 @@ void NS::SyncGroup::mark_changes_as_notified() {
 	}
 	simulated_sync_objects_list_changed = false;
 	trickled_sync_objects_list_changed = false;
-	peers_with_newly_calculated_ping.clear();
+	peers_with_newly_calculated_latency.clear();
 }
 
 void NS::SyncGroup::add_listening_peer(int p_peer) {
@@ -66,7 +66,7 @@ uint32_t NS::SyncGroup::add_new_sync_object(ObjectData *p_object_data, bool p_is
 		// Regardless if it's simulated or not.
 		const int peer = p_object_data->get_controller()->server_get_associated_peer();
 		if (NS::VecFunc::insert_unique(networked_peers, peer)) {
-			NS::VecFunc::insert_unique(peers_with_newly_calculated_ping, peer);
+			NS::VecFunc::insert_unique(peers_with_newly_calculated_latency, peer);
 		}
 	}
 
@@ -138,7 +138,7 @@ void NS::SyncGroup::remove_sync_object(std::size_t p_index, bool p_is_simulated)
 
 	if (associted_peer != 0) {
 		NS::VecFunc::remove_unordered(networked_peers, associted_peer);
-		NS::VecFunc::remove_unordered(peers_with_newly_calculated_ping, associted_peer);
+		NS::VecFunc::remove_unordered(peers_with_newly_calculated_latency, associted_peer);
 	}
 }
 
@@ -266,9 +266,9 @@ void NS::SyncGroup::sort_trickled_node_by_update_priority() {
 	trickled_sync_objects.sort_custom<DNIComparator>();
 }
 
-void NS::SyncGroup::notify_peer_has_newly_calculated_ping(int p_peer) {
+void NS::SyncGroup::notify_peer_has_newly_calculated_latency(int p_peer) {
 	if (NS::VecFunc::has(networked_peers, p_peer)) {
-		NS::VecFunc::insert_unique(peers_with_newly_calculated_ping, p_peer);
+		NS::VecFunc::insert_unique(peers_with_newly_calculated_latency, p_peer);
 	}
 }
 

net_utilities.h

@@ -426,28 +426,45 @@ void StatisticalRingBuffer<T>::force_recompute_avg_sum() {
 	}
 }
 
-struct PeerData {
-	ObjectNetId controller_id = ObjectNetId::NONE;
-	// For new peers notify the state as soon as possible.
-	bool force_notify_snapshot = true;
-	// For new peers a full snapshot is needed.
-	bool need_full_snapshot = true;
+// These data are used by the server and are never synchronized.
+struct PeerAuthorityData {
 	// Used to know if the peer is enabled.
 	bool enabled = true;
+
 	// The Sync group this peer is in.
 	SyncGroupId sync_group_id = SyncGroupId::GLOBAL;
+};
 
-	// The ping between this peer and the server in ms.
-	std::chrono::high_resolution_clock::time_point ping_timestamp;
-	bool ping_calculation_in_progress = false;
+struct PeerData {
+public:
+	PeerAuthorityData authority_data;
 
-	void set_ping(int p_ping);
-	int get_ping() const;
-	void set_compressed_ping(std::uint8_t p_compressed_ping) { compressed_ping = p_compressed_ping; }
-	std::uint8_t get_compressed_ping() const { return compressed_ping; }
+	ObjectNetId controller_id = ObjectNetId::NONE;
 
 private:
-	std::uint8_t compressed_ping = 0;
+	std::uint8_t compressed_latency = -1;
+
+public:
+	// In ms
+	void set_latency(int p_ping);
+
+	// In ms
+	int get_latency() const;
+
+	void set_compressed_latency(std::uint8_t p_compressed_latency) { compressed_latency = p_compressed_latency; }
+	std::uint8_t get_compressed_latency() const { return compressed_latency; }
+};
+
+struct PeerServerData {
+	// For new peers notify the state as soon as possible.
+	bool force_notify_snapshot = true;
+
+	// For new peers a full snapshot is needed.
+	bool need_full_snapshot = true;
+
+	// The latency, in ms, between this peer and the server.
+	std::chrono::high_resolution_clock::time_point latency_ping_timestamp;
+	bool latency_calculation_in_progress = false;
 };
 
 struct SyncGroup {
@@ -509,7 +526,7 @@ struct SyncGroup {
 	LocalVector<TrickledObjectInfo> trickled_sync_objects;
 
 	std::vector<int> networked_peers;
-	std::vector<int> peers_with_newly_calculated_ping;
+	std::vector<int> peers_with_newly_calculated_latency;
 
 	std::vector<int> listening_peers;
 
@@ -521,7 +538,7 @@ struct SyncGroup {
 public:
 	bool is_realtime_node_list_changed() const;
 	bool is_trickled_node_list_changed() const;
-	const std::vector<int> get_peers_with_newly_calculated_ping() const;
+	const std::vector<int> get_peers_with_newly_calculated_latency() const;
 
 	const LocalVector<NS::SyncGroup::SimulatedObjectInfo> &get_simulated_sync_objects() const;
 	const LocalVector<NS::SyncGroup::TrickledObjectInfo> &get_trickled_sync_objects() const;
@@ -548,7 +565,7 @@ struct SyncGroup {
 
 	void sort_trickled_node_by_update_priority();
 
-	void notify_peer_has_newly_calculated_ping(int p_peer);
+	void notify_peer_has_newly_calculated_latency(int p_peer);
 
 private:
 	void notify_controller_about_simulating_peers(struct ObjectData *p_object_data, bool p_simulating);