Implemented doll's apply snapshot

Author: AndreaCatania

core/peer_networked_controller.cpp

@@ -1609,6 +1609,17 @@ void DollController::on_received_server_snapshot(const Snapshot &p_snapshot) {
 		return;
 	}
 
+	// This check ensure that the server_snapshots contains just a single FrameIndex::NONE
+	// snapshot or a bunch of indexed one.
+	if (p_snapshot.input_id == FrameIndex::NONE) {
+		// The received snapshot doesn't have a FrameIndex set, it means there is no controller
+		// so assume this is the most up-to-date snapshot.
+		server_snapshots.clear();
+	} else {
+		// Make sure to remove all the snapshots with FrameIndex::NONE received before this one.
+		VecFunc::remove(server_snapshots, DollSnapshot(FrameIndex::NONE));
+	}
+
 	copy_controlled_objects_snapshot(p_snapshot, p_snapshot.input_id, server_snapshots);
 }
 
@@ -1622,7 +1633,7 @@ void DollController::copy_controlled_objects_snapshot(
 		std::vector<DollSnapshot> &r_snapshots) {
 	const std::vector<ObjectData *> *controlled_objects = peer_controller->scene_synchronizer->get_peer_controlled_objects_data(peer_controller->get_authority_peer());
 	if (!controlled_objects || controlled_objects->size() <= 0) {
-		// Nothing to store.
+		// Nothing to store for this doll.
 		return;
 	}
 
@@ -1691,12 +1702,12 @@ bool DollController::__pcr__fetch_recovery_info(
 	// 1. Fetch the server snapshot.
 	//    The server snapshot can be fetched, normally, using the index.
 	std::vector<DollSnapshot>::const_iterator server_snap_it = VecFunc::find(server_snapshots, DollSnapshot(p_checking_frame_index));
-	// The server snapshot was not found, this is impossible because we store
-	// all the snapshots.
-	ENSURE_V_MSG(server_snapshots.end() != server_snap_it, false, "Doll fetch recovery info failed because the snapshot was not found, though this should be impossible to trigger. checking_frame_index: " + p_checking_frame_index);
-
-	const DollSnapshot *server_snapshot = &*server_snap_it;
-	ENSURE_V(server_snapshot, false);
+	if (server_snapshots.end() == server_snap_it) {
+		// The server snapshot was not found on this doll, that can only happen
+		// when this doll is not simulating anything on this client.
+		// So, just return true.
+		return true;
+	}
 
 	// 2. Now fetch the client snapshot.
 	//    Since the doll is following a a different timeline, we need to fetch the
@@ -1707,12 +1718,16 @@ bool DollController::__pcr__fetch_recovery_info(
 			client_snapshot = &snapshot;
 		}
 	}
-	ENSURE_V_MSG(client_snapshot, false, "Doll fetch recovery info failed because the client snapshot was not found. checking_frame: " + p_checking_frame_index)
+	if (!client_snapshot) {
+		// The client was not found, most likely there was nothing to store,
+		// it can be considered as the two snapshots are different.
+		return false;
+	}
 
 	// Now just compare the two snapshots.
 	return Snapshot::compare(
 			*peer_controller->scene_synchronizer,
-			server_snapshot->data,
+			server_snap_it->data,
 			client_snapshot->data,
 			-1,
 			r_no_rewind_recover,
@@ -1725,21 +1740,19 @@ bool DollController::__pcr__fetch_recovery_info(
 }
 
 void DollController::on_snapshot_applied(const Snapshot &p_snapshot) {
-	// Since this doll is executing on a different timeline, we can't apply
-	// the received snapshot.
-	// 1. Search which input was executed by this doll when this snapshot was executed.
-	FrameIndex doll_executed_input;
-	{
-		const auto client_snap_it = VecFunc::find(client_snapshots, DollSnapshot(p_snapshot.input_id));
-		ENSURE_MSG(client_snap_it != client_snapshots.end(), "The doll was unable to set the snapshot because it was unable to find the client snapshot with ID: " + p_snapshot.input_id);
+	// This function can't run on the server.
+	ENSURE(peer_controller->scene_synchronizer->is_client());
 
-		doll_executed_input = client_snap_it->doll_executed_input;
-	}
+	// At this point it's necessary to mention that due to the fact the doll is
+	// processing on a different timeline, we may not have the server snapshot
+	// to reconcile the doll with the server right away.
+	// For this reason, this function apply the client snapshot, and leaves to
+	// Rewinding's process function the task to apply the server snapshot.
+
+	const auto client_snap_it = VecFunc::find(client_snapshots, DollSnapshot(p_snapshot.input_id));
+	ENSURE_MSG(client_snap_it != client_snapshots.end(), "The doll was unable to set the snapshot because it was unable to find the client snapshot with ID: " + p_snapshot.input_id);
 
-	// Now it has the executed input so, fetch the snapshot to apply.
-	// 2. Fetch the server snapshot.
-	const auto server_snap_it = VecFunc::find(server_snapshots, DollSnapshot(doll_executed_input));
-	if (server_snap_it ==)
+	static_cast<ClientSynchronizer *>(peer_controller->scene_synchronizer->get_synchronizer_internal())->apply_snapshot(p_snapshot, 0, nullptr, true, true, true, true, true);
 }
 
 NoNetController::NoNetController(PeerNetworkedController *p_peer_controller) :

scene_synchronizer.cpp

@@ -3679,19 +3679,27 @@ void ClientSynchronizer::update_simulated_objects_list(const std::vector<ObjectN
 
 void ClientSynchronizer::apply_snapshot(
 		const NS::Snapshot &p_snapshot,
-		int p_flag,
+		const int p_flag,
 		std::vector<std::string> *r_applied_data_info,
-		bool p_skip_custom_data) {
+		const bool p_skip_custom_data,
+		const bool p_skip_simulated_objects_update,
+		const bool p_disable_apply_non_doll_controlled_only,
+		const bool p_skip_snapshot_applied_event_broadcast,
+		const bool p_skip_change_event) {
 	NS_PROFILE
 
 	const std::vector<NS::NameAndVar> *snap_objects_vars = p_snapshot.object_vars.data();
 
-	scene_synchronizer->change_events_begin(p_flag);
+	if (!p_skip_change_event) {
+		scene_synchronizer->change_events_begin(p_flag);
+	}
 	const int this_peer = scene_synchronizer->network_interface->fetch_local_peer_id();
 
-	update_simulated_objects_list(p_snapshot.simulated_objects);
+	if (!p_skip_simulated_objects_update) {
+		update_simulated_objects_list(p_snapshot.simulated_objects);
+	}
 
-	for (ObjectNetId net_node_id = { 0 }; net_node_id < ObjectNetId{ uint32_t(p_snapshot.object_vars.size()) }; net_node_id += 1) {
+	for (ObjectNetId net_node_id : p_snapshot.simulated_objects) {
 		NS::ObjectData *object_data = scene_synchronizer->get_object_data(net_node_id);
 
 		if (object_data == nullptr) {
@@ -3701,12 +3709,17 @@ void ClientSynchronizer::apply_snapshot(
 			continue;
 		}
 
-		if (object_data->realtime_sync_enabled_on_client == false) {
-			// This is not a simulated object.
-			continue;
+#ifdef DEBUG_ENABLED
+		if (!p_skip_simulated_objects_update) {
+			// This can't trigger because the `update_simulated_objects_list` make sure to set this.
+			ASSERT_COND(object_data->realtime_sync_enabled_on_client);
 		}
+#endif
 
-		if (object_data->get_controlled_by_peer() > 0 && object_data->get_controlled_by_peer() != this_peer) {
+		if (
+				!p_disable_apply_non_doll_controlled_only &&
+				object_data->get_controlled_by_peer() > 0 &&
+				object_data->get_controlled_by_peer() != this_peer) {
 			// This object is controlled by a doll, which simulation / reconcilation
 			// is mostly doll-controller driven.
 			// The dolls are notified at the end of this loop, when the event
@@ -3775,9 +3788,13 @@ void ClientSynchronizer::apply_snapshot(
 		scene_synchronizer->synchronizer_manager->snapshot_set_custom_data(p_snapshot.custom_data);
 	}
 
-	scene_synchronizer->event_snapshot_applied.broadcast(p_snapshot);
+	if (!p_skip_snapshot_applied_event_broadcast) {
+		scene_synchronizer->event_snapshot_applied.broadcast(p_snapshot);
+	}
 
-	scene_synchronizer->change_events_flush();
+	if (!p_skip_change_event) {
+		scene_synchronizer->change_events_flush();
+	}
 }
 
 NS_NAMESPACE_END

scene_synchronizer.h

@@ -284,6 +284,9 @@ class SceneSynchronizerBase {
 		return *synchronizer_manager;
 	}
 
+	const Synchronizer *get_synchronizer_internal() const { return synchronizer; }
+	Synchronizer *get_synchronizer_internal() { return synchronizer; }
+
 	void set_frames_per_seconds(int p_fps);
 	int get_frames_per_seconds() const;
 
@@ -838,11 +841,17 @@ class ClientSynchronizer final : public Synchronizer {
 
 	void update_client_snapshot(Snapshot &p_snapshot);
 	void update_simulated_objects_list(const std::vector<ObjectNetId> &p_simulated_objects);
+
+public:
 	void apply_snapshot(
 			const Snapshot &p_snapshot,
-			int p_flag,
+			const int p_flag,
 			std::vector<std::string> *r_applied_data_info,
-			bool p_skip_custom_data = false);
+			const bool p_skip_custom_data = false,
+			const bool p_skip_simulated_objects_update = false,
+			const bool p_disable_apply_non_doll_controlled_only = false,
+			const bool p_skip_snapshot_applied_event_broadcast = false,
+			const bool p_skip_change_event = false);
 };
 
 /// This is used to make sure we can safely convert any `BaseType` defined by