Implementing the new logic to perform the lag compensation during the reconciliation. Still WIP.

Author: AndreaCatania

core/peer_networked_controller.cpp

@@ -1295,7 +1295,7 @@ DollController::DollController(PeerNetworkedController *p_peer_controller) :
 			peer_controller->scene_synchronizer->event_state_validated.bind(std::bind(&DollController::on_state_validated, this, std::placeholders::_1, std::placeholders::_2));
 
 	event_handler_snapshot_applied =
-			peer_controller->scene_synchronizer->event_snapshot_applied.bind(std::bind(&DollController::on_snapshot_applied, this, std::placeholders::_1));
+			peer_controller->scene_synchronizer->event_snapshot_applied.bind(std::bind(&DollController::on_snapshot_applied, this, std::placeholders::_1, std::placeholders::_2));
 }
 
 DollController::~DollController() {
@@ -1395,16 +1395,6 @@ void DollController::on_rewind_frame_begin(FrameIndex p_frame_index, int p_index
 	return;
 }
 
-int DollController::count_queued_inputs() const {
-	int queued_inputs_count = 0;
-	for (const FrameInput &frame : frames_input) {
-		if (frame.id > current_input_buffer_id) {
-			queued_inputs_count += 1;
-		}
-	}
-	return queued_inputs_count;
-}
-
 int DollController::fetch_optimal_queued_inputs() const {
 	// The optimal virtual delay is a number that refers to the amount of queued
 	// frames the DollController should try to have on each frame to avoid
@@ -1485,7 +1475,7 @@ void DollController::process(double p_delta) {
 			auto server_snap_it = VecFunc::find(server_snapshots, DollSnapshot(frame_index - 1));
 			if (server_snap_it != server_snapshots.end()) {
 				// The snapshot was found, so apply it.
-				static_cast<ClientSynchronizer *>(peer_controller->scene_synchronizer->get_synchronizer_internal())->apply_snapshot(server_snap_it->data, 0, nullptr, true, true, true, true, true);
+				static_cast<ClientSynchronizer *>(peer_controller->scene_synchronizer->get_synchronizer_internal())->apply_snapshot(server_snap_it->data, 0, 0, nullptr, true, true, true, true, true);
 			}
 		}
 	}
@@ -1650,8 +1640,6 @@ void DollController::copy_controlled_objects_snapshot(
 bool DollController::__pcr__fetch_recovery_info(
 		FrameIndex p_checking_frame_index,
 		Snapshot *r_no_rewind_recover,
-		// The frames to process afterward.
-		int p_predicted_frames,
 		std::vector<std::string> *r_differences_info
 #ifdef DEBUG_ENABLED
 		,
@@ -1692,17 +1680,65 @@ bool DollController::__pcr__fetch_recovery_info(
 	);
 }
 
-void DollController::on_snapshot_applied(const Snapshot &p_global_server_snapshot) {
-	// This function can't run on the server.
-	ENSURE(peer_controller->scene_synchronizer->is_client());
+void DollController::on_snapshot_applied(
+		const Snapshot &p_global_server_snapshot,
+		const int p_frame_count_to_rewind) {
+	// The `DollController` is never created on the server, and the below
+	// assertion is always satisfied.
+	ASSERT_COND(peer_controller->scene_synchronizer->is_client());
+
+	// This function handles the reconciliation mechanism.
+	// The reconciliation is implemented in this function because this is the
+	// best moment to manipulate the processing (to consume or build the input
+	// queue) and avoid to make it noticeable.
+
+	// 1. Fetch the optimal queued inputs (how many inputs should be queued based
+	//    on the current connection).
+	const int optimal_queued_inputs = fetch_optimal_queued_inputs();
+
+	// 2. Get the input count.
+	const int input_count = frames_input.size();
+
+	// 3. Fetch the best input to start processing.
+	// TODO consider to scale this dynamically to slowly catchup with the server, as too drastic change may result in a less stable simulation.
+	const int optimal_input_count = p_frame_count_to_rewind + optimal_queued_inputs;
+
+	// The lag compensation algorithm offsets the available
+	// inputs so that the `input_count` equals to `optimal_queued_inputs`
+	// at the end of the reconcilation (rewinding) operation.
+
+	if (input_count < optimal_input_count) {
+		// It has less inputs than the optimal input count defined.
+		// In  this case the offset, mention above, is going to be positive.
+		// It will offset the reconciliation, by the delta difference
+		// `optimal_input_count - input_count`, with frames where the object are
+		// not procesed.
+		const int missing_inputs = optimal_input_count - input_count;
+	} else {
+		// It has more inputs than the optimal input count defined.
+		// In this case the offset is negative, meaning it throws away all the
+		// extra inputs to recatch the server.
+		const int extra_inputs = input_count - optimal_input_count;
+
+		current_input_buffer_id += extra_inputs;
+
+		I need to find a way to define the `current_input_buffer_id` based on the extra inputs and the available frames_input;
+	}
 
-	const FrameIndex doll_frame_index = MapFunc::at(p_global_server_snapshot.peers_frames_index, peer_controller->get_authority_peer(), FrameIndex::NONE);
+	const FrameIndex doll_frame_index =
+			MapFunc::at(
+					p_global_server_snapshot.peers_frames_index,
+					peer_controller->get_authority_peer(),
+					FrameIndex::NONE);
 
 	if (doll_frame_index == FrameIndex::NONE) {
 		// On the server, the doll was not executed so just apply the server snapshot.
-		const auto server_snap_it = VecFunc::find(server_snapshots, DollSnapshot(FrameIndex::NONE));
+		const auto server_snap_it =
+				VecFunc::find(
+						server_snapshots,
+						DollSnapshot(FrameIndex::NONE));
 		ENSURE_MSG(server_snap_it != server_snapshots.end(), "The doll was unable to set the NO-CONTROLLER snapshot because it was unable to find it in the server_snapshots array.");
-		static_cast<ClientSynchronizer *>(peer_controller->scene_synchronizer->get_synchronizer_internal())->apply_snapshot(server_snap_it->data, 0, nullptr, true, true, true, true, true);
+		static_cast<ClientSynchronizer *>(peer_controller->scene_synchronizer->get_synchronizer_internal())->apply_snapshot(server_snap_it->data, 0, 0, nullptr, true, true, true, true, true);
 
 	} else {
 		// At this point it's necessary to mention that due to the fact the doll is
@@ -1714,7 +1750,7 @@ void DollController::on_snapshot_applied(const Snapshot &p_global_server_snapsho
 		const auto client_snap_it = VecFunc::find(client_snapshots, DollSnapshot(doll_frame_index));
 		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: " + doll_frame_index);
 
-		static_cast<ClientSynchronizer *>(peer_controller->scene_synchronizer->get_synchronizer_internal())->apply_snapshot(client_snap_it->data, 0, nullptr, true, true, true, true, true);
+		static_cast<ClientSynchronizer *>(peer_controller->scene_synchronizer->get_synchronizer_internal())->apply_snapshot(client_snap_it->data, 0, 0, nullptr, true, true, true, true, true);
 	}
 }
 

core/peer_networked_controller.h

@@ -399,7 +399,6 @@ struct DollController final : public RemotelyControlledController {
 
 	virtual bool receive_inputs(const Vector<uint8_t> &p_data) override;
 	void on_rewind_frame_begin(FrameIndex p_input_id, int p_index, int p_count);
-	int count_queued_inputs() const;
 	int fetch_optimal_queued_inputs() const;
 	virtual bool fetch_next_input(double p_delta) override;
 	virtual void process(double p_delta) override;
@@ -415,15 +414,14 @@ struct DollController final : public RemotelyControlledController {
 	bool __pcr__fetch_recovery_info(
 			FrameIndex p_checking_frame_index,
 			Snapshot *r_no_rewind_recover,
-			int p_predicted_frames,
 			std::vector<std::string> *r_differences_info
 #ifdef DEBUG_ENABLED
 			,
 			std::vector<ObjectNetId> *r_different_node_data
 #endif
 	) const;
 
-	void on_snapshot_applied(const Snapshot &p_snapshot);
+	void on_snapshot_applied(const Snapshot &p_snapshot, const int p_frame_count_to_rewind);
 
 	DollSnapshot *find_snapshot_by_snapshot_id(std::vector<DollSnapshot> &p_snapshots, FrameIndex p_index) const;
 	const DollSnapshot *find_snapshot_by_snapshot_id(const std::vector<DollSnapshot> &p_snapshots, FrameIndex p_index) const;

scene_synchronizer.cpp

@@ -2644,7 +2644,7 @@ void ClientSynchronizer::process_received_server_state() {
 		// The server last received snapshot is a no input snapshot. Just assume it's the most up-to-date.
 		SceneSynchronizerDebugger::singleton()->debug_print(&scene_synchronizer->get_network_interface(), "The client received a \"no input\" snapshot, so the client is setting it right away assuming is the most updated one.", true);
 
-		apply_snapshot(*last_received_server_snapshot, NetEventFlag::SYNC_RECOVER, nullptr);
+		apply_snapshot(*last_received_server_snapshot, NetEventFlag::SYNC_RECOVER, 0, nullptr);
 		last_received_server_snapshot.reset();
 		return;
 	}
@@ -2726,7 +2726,9 @@ void ClientSynchronizer::process_received_server_state() {
 				scene_synchronizer->get_network_interface().get_owner_name());
 
 		// Sync.
-		__pcr__sync__rewind();
+		__pcr__sync__rewind(
+				last_checked_input,
+				*inner_player_controller);
 
 		// Rewind.
 		__pcr__rewind(
@@ -2774,15 +2776,12 @@ bool ClientSynchronizer::__pcr__fetch_recovery_info(
 	);
 
 	if (is_equal) {
-		const int frames_count_after_input_id = p_local_player_controller.count_frames_after(p_input_id);
-
 		// The snapshots are equals, make sure the dolls doesn't need to be reconciled.
 		for (const auto &[peer, data] : scene_synchronizer->peer_data) {
 			if (data.get_controller() && data.get_controller()->is_doll_controller()) {
 				const bool is_doll_state_valid = data.get_controller()->get_doll_controller()->__pcr__fetch_recovery_info(
 						p_input_id,
 						&r_no_rewind_recover,
-						frames_count_after_input_id,
 						scene_synchronizer->debug_rewindings_enabled ? &differences_info : nullptr
 #ifdef DEBUG_ENABLED
 						,
@@ -2854,17 +2853,22 @@ bool ClientSynchronizer::__pcr__fetch_recovery_info(
 	return !is_equal;
 }
 
-void ClientSynchronizer::__pcr__sync__rewind() {
+void ClientSynchronizer::__pcr__sync__rewind(
+		FrameIndex p_last_checked_input_id,
+		const PlayerController &p_local_player_controller) {
 	NS_PROFILE
 	// Apply the server snapshot so to go back in time till that moment,
 	// so to be able to correctly reply the movements.
 
+	const int frame_count_after_input_id = p_local_player_controller.count_frames_after(p_last_checked_input_id);
+
 	std::vector<std::string> applied_data_info;
 
 	const NS::Snapshot &server_snapshot = *last_received_server_snapshot;
 	apply_snapshot(
 			server_snapshot,
 			NetEventFlag::SYNC_RECOVER | NetEventFlag::SYNC_RESET,
+			frame_count_after_input_id,
 			scene_synchronizer->debug_rewindings_enabled ? &applied_data_info : nullptr);
 
 	if (applied_data_info.size() > 0) {
@@ -2950,6 +2954,7 @@ void ClientSynchronizer::__pcr__sync__no_rewind(const NS::Snapshot &p_no_rewind_
 	apply_snapshot(
 			p_no_rewind_recover,
 			NetEventFlag::SYNC_RECOVER,
+			0,
 			scene_synchronizer->debug_rewindings_enabled ? &applied_data_info : nullptr,
 			// ALWAYS skips custom data because partial snapshots don't contain custom_data.
 			true);
@@ -2986,6 +2991,7 @@ void ClientSynchronizer::process_paused_controller_recovery() {
 	apply_snapshot(
 			*last_received_server_snapshot,
 			NetEventFlag::SYNC_RECOVER,
+			0,
 			&applied_data_info);
 
 	last_received_server_snapshot.reset();
@@ -3738,6 +3744,7 @@ void ClientSynchronizer::update_simulated_objects_list(const std::vector<ObjectN
 void ClientSynchronizer::apply_snapshot(
 		const NS::Snapshot &p_snapshot,
 		const int p_flag,
+		const int p_frame_count_to_rewind,
 		std::vector<std::string> *r_applied_data_info,
 		const bool p_skip_custom_data,
 		const bool p_skip_simulated_objects_update,
@@ -3847,7 +3854,7 @@ void ClientSynchronizer::apply_snapshot(
 	}
 
 	if (!p_skip_snapshot_applied_event_broadcast) {
-		scene_synchronizer->event_snapshot_applied.broadcast(p_snapshot);
+		scene_synchronizer->event_snapshot_applied.broadcast(p_snapshot, p_frame_count_to_rewind);
 	}
 
 	if (!p_skip_change_event) {

scene_synchronizer.h

@@ -226,7 +226,7 @@ class SceneSynchronizerBase {
 	///       the data read through the get functions, at the moment of the event.
 	///       So, you can assume the snapshot contains the result of the last executed input.
 	Processor<const Snapshot & /*p_snapshot*/> event_snapshot_update_finished;
-	Processor<const Snapshot & /*p_snapshot*/> event_snapshot_applied;
+	Processor<const Snapshot & /*p_snapshot*/, int /*p_frame_count_to_rewind*/> event_snapshot_applied;
 	Processor<const Snapshot & /*p_received_snapshot*/> event_received_server_snapshot;
 	Processor<FrameIndex, int /*p_index*/, int /*p_count*/> event_rewind_frame_begin;
 	Processor<FrameIndex, ObjectHandle /*p_app_object_handle*/, const std::vector<std::string> & /*p_var_names*/, const std::vector<VarData> & /*p_client_values*/, const std::vector<VarData> & /*p_server_values*/> event_desync_detected_with_info;
@@ -816,7 +816,7 @@ class ClientSynchronizer final : public Synchronizer {
 			const struct PlayerController &p_local_player_controller,
 			Snapshot &r_no_rewind_recover);
 
-	void __pcr__sync__rewind();
+	void __pcr__sync__rewind(FrameIndex p_last_checked_input_id, const PlayerController &p_local_player_controller);
 
 	void __pcr__rewind(
 			const FrameIndex p_checkable_frame_index,
@@ -847,6 +847,8 @@ class ClientSynchronizer final : public Synchronizer {
 	void apply_snapshot(
 			const Snapshot &p_snapshot,
 			const int p_flag,
+			// The frames rewinded just after this function.
+			const int p_frame_count_to_rewind,
 			std::vector<std::string> *r_applied_data_info,
 			const bool p_skip_custom_data = false,
 			const bool p_skip_simulated_objects_update = false,

tests/test_doll_simulation.cpp

@@ -86,22 +86,25 @@ class TDSControlledObject : public NS::LocalSceneObject {
 		}
 
 		// TODO remove this, is here just for debug.
-		if (authoritative_peer_id != 2) {
-			return;
-		}
-		NS::PeerNetworkedController *controller = scene_owner->scene_sync->get_controller_for_peer(authoritative_peer_id);
-		NS::FrameIndex fi = controller->get_current_frame_index();
-		std::string frame_info;
-		frame_info += "FrameIndex: " + fi;
-		frame_info += " initial X: " + std::to_string(current.data.vec.x) + " Y: " + std::to_string(current.data.vec.y);
-		frame_info += " input: " + std::string(advance_or_turn ? "advance" : "turn");
-
-		if (controller->is_doll_controller()) {
-			NS::SceneSynchronizerBase::__print_line("Doll controller " + frame_info);
-		} else if (controller->is_player_controller()) {
-			NS::SceneSynchronizerBase::__print_line("Player controller " + frame_info);
-		} else if (controller->is_server_controller()) {
-			NS::SceneSynchronizerBase::__print_line("Server controller " + frame_info);
+		const bool debug_procesing = false;
+		if (!debug_procesing) {
+			if (authoritative_peer_id != 2) {
+				return;
+			}
+			NS::PeerNetworkedController *controller = scene_owner->scene_sync->get_controller_for_peer(authoritative_peer_id);
+			NS::FrameIndex fi = controller->get_current_frame_index();
+			std::string frame_info;
+			frame_info += "FrameIndex: " + fi;
+			frame_info += " initial X: " + std::to_string(current.data.vec.x) + " Y: " + std::to_string(current.data.vec.y);
+			frame_info += " input: " + std::string(advance_or_turn ? "advance" : "turn");
+
+			if (controller->is_doll_controller()) {
+				NS::SceneSynchronizerBase::__print_line("Doll controller " + frame_info);
+			} else if (controller->is_player_controller()) {
+				NS::SceneSynchronizerBase::__print_line("Player controller " + frame_info);
+			} else if (controller->is_server_controller()) {
+				NS::SceneSynchronizerBase::__print_line("Server controller " + frame_info);
+			}
 		}
 	}