Fixed all the issues with SyncGroups.

Author: AndreaCatania

net_utilities.cpp

@@ -72,7 +72,21 @@ void NS::SyncGroup::remove_listening_peer(int p_peer) {
 }
 
 uint32_t NS::SyncGroup::add_new_sync_object(ObjectData *p_object_data, bool p_is_simulated) {
-	if (p_object_data->get_controlled_by_peer() != -1) {
+	if (p_is_simulated) {
+		// Make sure the node is not contained into the trickled sync.
+		const int tso_index = trickled_sync_objects.find(p_object_data);
+		if (tso_index >= 0) {
+			remove_sync_object(tso_index, false);
+		}
+	} else {
+		// Make sure the node is not contained into the realtime sync.
+		const int rsn_index = simulated_sync_objects.find(p_object_data);
+		if (rsn_index >= 0) {
+			remove_sync_object(rsn_index, true);
+		}
+	}
+
+	if (p_object_data->get_controlled_by_peer() > 0) {
 		// This is a controller with an associated peer, update the networked_peer list.
 		// Regardless if it's simulated or not.
 		const int peer = p_object_data->get_controlled_by_peer();
@@ -82,12 +96,6 @@ uint32_t NS::SyncGroup::add_new_sync_object(ObjectData *p_object_data, bool p_is
 	}
 
 	if (p_is_simulated) {
-		// Make sure the node is not contained into the trickled sync.
-		const int tso_index = trickled_sync_objects.find(p_object_data);
-		if (tso_index >= 0) {
-			remove_sync_object(tso_index, false);
-		}
-
 		// Add it into the realtime sync nodes
 		int index = simulated_sync_objects.find(p_object_data);
 
@@ -112,12 +120,6 @@ uint32_t NS::SyncGroup::add_new_sync_object(ObjectData *p_object_data, bool p_is
 
 		return index;
 	} else {
-		// Make sure the node is not contained into the realtime sync.
-		const int rsn_index = simulated_sync_objects.find(p_object_data);
-		if (rsn_index >= 0) {
-			remove_sync_object(rsn_index, true);
-		}
-
 		// Add it into the trickled sync nodes
 		int index = trickled_sync_objects.find(p_object_data);
 
@@ -153,45 +155,7 @@ void NS::SyncGroup::remove_sync_object(std::size_t p_index, bool p_is_simulated)
 		trickled_sync_objects_list_changed = true;
 	}
 
-	if (associted_peer > 0) {
-		// If no other simulated objects controlled by `associated_peer` remove it from
-		bool is_simulating = false;
-		bool is_networking = false;
-
-		for (auto &soi : simulated_sync_objects) {
-			if (soi.od->get_controlled_by_peer() == associted_peer) {
-				is_networking = true;
-				is_simulating = true;
-				break;
-			}
-		}
-
-		if (!is_networking) {
-			if (NS::VecFunc::has(listening_peers, associted_peer)) {
-				is_networking = true;
-			}
-		}
-
-		if (!is_networking) {
-			for (auto &toi : trickled_sync_objects) {
-				if (toi.od->get_controlled_by_peer() == associted_peer) {
-					is_networking = true;
-					break;
-				}
-			}
-		}
-
-		if (!is_simulating) {
-			// No other objects associated to this peer are simulated, remove from simulating peers.
-			VecFunc::remove_unordered(simulating_peers, associted_peer);
-			update_listeners_to_simulating_peer(associted_peer, false);
-		}
-
-		if (!is_networking) {
-			NS::VecFunc::remove_unordered(networked_peers, associted_peer);
-			NS::VecFunc::remove_unordered(peers_with_newly_calculated_latency, associted_peer);
-		}
-	}
+	validate_peer_association(associted_peer);
 }
 
 void NS::SyncGroup::remove_sync_object(const ObjectData &p_object_data) {
@@ -324,6 +288,38 @@ void NS::SyncGroup::notify_peer_has_newly_calculated_latency(int p_peer) {
 	}
 }
 
+void NS::SyncGroup::notify_controller_changed(NS::ObjectData *p_object_data, int p_previous_controlling_peer) {
+	if (p_object_data->get_controlled_by_peer() == p_previous_controlling_peer) {
+		return;
+	}
+
+	bool is_in_this_sync_group = false;
+	bool is_simulated = false;
+	if (simulated_sync_objects.find(p_object_data) != -1) {
+		is_in_this_sync_group = true;
+		is_simulated = true;
+	} else if (trickled_sync_objects.find(p_object_data) != -1) {
+		is_in_this_sync_group = true;
+	}
+
+	if (is_in_this_sync_group) {
+		validate_peer_association(p_previous_controlling_peer);
+
+		if (p_object_data->get_controlled_by_peer() > 0) {
+			const int peer = p_object_data->get_controlled_by_peer();
+
+			if (is_simulated) {
+				VecFunc::insert_unique(simulating_peers, peer);
+				update_listeners_to_simulating_peer(peer, true);
+			}
+
+			if (NS::VecFunc::insert_unique(networked_peers, peer)) {
+				NS::VecFunc::insert_unique(peers_with_newly_calculated_latency, peer);
+			}
+		}
+	}
+}
+
 void NS::SyncGroup::notify_simulating_peers_about_listener_status(int p_peer_listener, bool p_simulating) {
 	for (int peer : simulating_peers) {
 		NetworkedControllerBase *controller = scene_sync->get_controller_for_peer(peer);
@@ -338,6 +334,44 @@ void NS::SyncGroup::update_listeners_to_simulating_peer(int p_simulating_peer, b
 	}
 }
 
+void NS::SyncGroup::validate_peer_association(int p_peer) {
+	if (p_peer <= 0) {
+		return;
+	}
+
+	// If no other simulated objects controlled by `associated_peer` remove it from
+	bool is_simulating = false;
+	bool is_networking = false;
+
+	for (auto &soi : simulated_sync_objects) {
+		if (soi.od->get_controlled_by_peer() == p_peer) {
+			is_networking = true;
+			is_simulating = true;
+			break;
+		}
+	}
+
+	if (!is_networking) {
+		for (auto &toi : trickled_sync_objects) {
+			if (toi.od->get_controlled_by_peer() == p_peer) {
+				is_networking = true;
+				break;
+			}
+		}
+	}
+
+	if (!is_simulating) {
+		// No other objects associated to this peer are simulated, remove from simulating peers.
+		VecFunc::remove_unordered(simulating_peers, p_peer);
+		update_listeners_to_simulating_peer(p_peer, false);
+	}
+
+	if (!is_networking) {
+		NS::VecFunc::remove_unordered(networked_peers, p_peer);
+		NS::VecFunc::remove_unordered(peers_with_newly_calculated_latency, p_peer);
+	}
+}
+
 std::size_t NS::SyncGroup::find_simulated(const struct ObjectData &p_object_data) const {
 	std::size_t i = 0;
 	for (auto sso : simulated_sync_objects) {

net_utilities.h

@@ -566,6 +566,7 @@ struct SyncGroup {
 	void remove_listening_peer(int p_peer);
 	const std::vector<int> &get_listening_peers() const { return listening_peers; };
 
+	const std::vector<int> &get_networked_peers() const { return networked_peers; }
 	const std::vector<int> &get_simulating_peers() const { return simulating_peers; }
 
 	/// Returns the `index` or `UINT32_MAX` on error.
@@ -585,12 +586,18 @@ struct SyncGroup {
 
 	void notify_peer_has_newly_calculated_latency(int p_peer);
 
+	void notify_controller_changed(NS::ObjectData *p_object_data, int p_previous_controlling_peer);
+
 	// Used when a new listener is added or removed.
 	void notify_simulating_peers_about_listener_status(int p_peer_listener, bool p_simulating);
 	// Used when a new simulated object (which is controlled) is added, to notify
 	// such controller about the listeners.
 	void update_listeners_to_simulating_peer(int p_simulating_peer, bool p_simulating);
 
+	// Removes the peer from this sync group if it's not associated to any object
+	// data into this group.
+	void validate_peer_association(int p_peer);
+
 private:
 	std::size_t find_simulated(const struct ObjectData &p_object_data) const;
 	std::size_t find_trickled(const struct ObjectData &p_object_data) const;

scene_synchronizer.cpp

@@ -384,15 +384,16 @@ void SceneSynchronizerBase::setup_controller(
 	NS::ObjectData *object_data = get_object_data(p_id);
 	ENSURE(object_data != nullptr);
 
+	const int previous_controlling_peer = object_data->get_controlled_by_peer();
 	object_data->set_controlled_by_peer(p_peer, p_collect_input_func, p_count_input_size_func, p_are_inputs_different_func, p_process_func);
 
 	NetworkedControllerBase *controller = get_controller_for_peer(p_peer);
 	if (controller) {
 		controller->notify_controllable_objects_changed();
 	}
 
-	if (is_server()) {
-		static_cast<ServerSynchronizer *>(synchronizer)->notify_need_full_snapshot(p_peer, true);
+	if (synchronizer) {
+		synchronizer->on_object_data_controller_changed(object_data, previous_controlling_peer);
 	}
 }
 
@@ -1760,6 +1761,20 @@ void ServerSynchronizer::on_object_data_removed(NS::ObjectData &p_object_data) {
 	}
 }
 
+void ServerSynchronizer::on_object_data_controller_changed(NS::ObjectData *p_object_data, int p_previous_controlling_peer) {
+	if (p_object_data->get_controlled_by_peer() == p_previous_controlling_peer) {
+		return;
+	}
+
+	if (p_object_data->get_controlled_by_peer() > 0) {
+		notify_need_full_snapshot(p_object_data->get_controlled_by_peer(), true);
+	}
+
+	for (SyncGroup &sync_group : sync_groups) {
+		sync_group.notify_controller_changed(p_object_data, p_previous_controlling_peer);
+	}
+}
+
 void ServerSynchronizer::on_variable_added(NS::ObjectData *p_object_data, const std::string &p_var_name) {
 #ifdef DEBUG_ENABLED
 	// Can't happen on server

scene_synchronizer.h

@@ -529,6 +529,7 @@ class Synchronizer {
 	virtual void on_peer_disconnected(int p_peer_id) {}
 	virtual void on_object_data_added(NS::ObjectData *p_object_data) {}
 	virtual void on_object_data_removed(NS::ObjectData &p_object_data) {}
+	virtual void on_object_data_controller_changed(NS::ObjectData *p_object_data, int p_previous_controlling_peer) {}
 	virtual void on_variable_added(NS::ObjectData *p_object_data, const std::string &p_var_name) {}
 	virtual void on_variable_changed(NS::ObjectData *p_object_data, VarId p_var_id, const VarData &p_old_value, int p_flag) {}
 	virtual void on_controller_reset(NetworkedControllerBase &p_controller) {}
@@ -588,6 +589,7 @@ class ServerSynchronizer final : public Synchronizer {
 	virtual void on_peer_disconnected(int p_peer_id) override;
 	virtual void on_object_data_added(NS::ObjectData *p_object_data) override;
 	virtual void on_object_data_removed(NS::ObjectData &p_object_data) override;
+	virtual void on_object_data_controller_changed(NS::ObjectData *p_object_data, int p_previous_controlling_peer) override;
 	virtual void on_variable_added(NS::ObjectData *p_object_data, const std::string &p_var_name) override;
 	virtual void on_variable_changed(NS::ObjectData *p_object_data, VarId p_var_id, const VarData &p_old_value, int p_flag) override;
 	virtual const std::vector<ObjectData *> &get_active_objects() const override { return active_objects; }