Refactored the send input. Now it's performed at the end of the frame opposed to the previous implementation that was executed at the end of the sub frame that could cause network saturation.

Author: AndreaCatania

core/peer_networked_controller.cpp

@@ -218,7 +218,7 @@ void PeerNetworkedController::remove_synchronizer() {
 	scene_synchronizer = nullptr;
 }
 
-NS::SceneSynchronizerBase *PeerNetworkedController::get_scene_synchronizer() const {
+SceneSynchronizerBase *PeerNetworkedController::get_scene_synchronizer() const {
 	return scene_synchronizer;
 }
 
@@ -295,7 +295,7 @@ void PeerNetworkedController::encode_inputs(std::deque<FrameInput> &p_frames_inp
 	// |-- First byte the amount of times this input is duplicated in the packet.
 	// |-- Input buffer.
 
-	const size_t inputs_count = std::min(p_frames_input.size(), static_cast<size_t>(get_max_redundant_inputs() + 1));
+	const size_t inputs_count = std::min(p_frames_input.size(), std::max(static_cast<size_t>(1), static_cast<size_t>(get_max_redundant_inputs())));
 	if make_unlikely(inputs_count <= 0) {
 		// Nothing to send.
 		return;
@@ -931,9 +931,15 @@ PlayerController::PlayerController(PeerNetworkedController *p_peer_controller) :
 
 	event_handler_state_validated =
 			peer_controller->scene_synchronizer->event_state_validated.bind(std::bind(&PlayerController::on_state_validated, this, std::placeholders::_1, std::placeholders::_2));
+
+	event_handler_on_end_process =
+			peer_controller->scene_synchronizer->event_app_process_end.bind(std::bind(&PlayerController::on_app_process_end, this, std::placeholders::_1));
 }
 
 PlayerController::~PlayerController() {
+	peer_controller->scene_synchronizer->event_app_process_end.unbind(event_handler_on_end_process);
+	event_handler_on_end_process = NS::NullPHandler;
+
 	peer_controller->scene_synchronizer->event_rewind_frame_begin.unbind(event_handler_rewind_frame_begin);
 	event_handler_rewind_frame_begin = NS::NullPHandler;
 
@@ -1104,7 +1110,7 @@ void PlayerController::process(float p_delta) {
 
 			// Keep sending inputs, despite the server seems not responding properly,
 			// to make sure the server becomes up to date at some point.
-			send_frame_input_buffer_to_server();
+			has_pending_inputs_sent = true;
 		}
 	}
 }
@@ -1113,6 +1119,10 @@ void PlayerController::on_state_validated(FrameIndex p_frame_index, bool p_detec
 	notify_frame_checked(p_frame_index);
 }
 
+void PlayerController::on_app_process_end(float p_delta_seconds) {
+	send_frame_input_buffer_to_server();
+}
+
 FrameIndex PlayerController::get_current_frame_index() const {
 	return current_input_id;
 }
@@ -1146,6 +1156,11 @@ void PlayerController::store_input_buffer(FrameIndex p_frame_index) {
 }
 
 void PlayerController::send_frame_input_buffer_to_server() {
+	if (!has_pending_inputs_sent) {
+		return;
+	}
+	has_pending_inputs_sent = false;
+
 	peer_controller->encode_inputs(frames_input, cached_packet_data);
 
 	peer_controller->scene_synchronizer->call_rpc_receive_inputs(

core/peer_networked_controller.h

@@ -265,15 +265,17 @@ struct AutonomousServerController final : public ServerController {
 };
 
 struct PlayerController final : public Controller {
-	NS::PHandler event_handler_rewind_frame_begin = NS::NullPHandler;
-	NS::PHandler event_handler_state_validated = NS::NullPHandler;
+	PHandler event_handler_rewind_frame_begin = NS::NullPHandler;
+	PHandler event_handler_state_validated = NS::NullPHandler;
+	PHandler event_handler_on_end_process = NullPHandler;
 
 	FrameIndex current_input_id;
 	std::uint32_t input_buffers_counter;
 	bool streaming_paused = false;
 
 	std::deque<FrameInput> frames_input;
 	std::vector<std::uint8_t> cached_packet_data;
+	bool has_pending_inputs_sent = false;
 	int queued_instant_to_process = -1;
 
 	PlayerController(PeerNetworkedController *p_node);
@@ -290,6 +292,7 @@ struct PlayerController final : public Controller {
 	bool has_another_instant_to_process_after(int p_i) const;
 	virtual void process(float p_delta) override;
 	void on_state_validated(FrameIndex p_frame_index, bool p_detected_desync);
+	void on_app_process_end(float p_delta_seconds);
 
 	virtual bool receive_inputs(const std::vector<std::uint8_t> &p_data) override;
 

scene_synchronizer.cpp

@@ -166,6 +166,8 @@ void SceneSynchronizerBase::process(float p_delta) {
 	try_fetch_unnamed_objects_data_names();
 
 	synchronizer->process(p_delta);
+
+	event_app_process_end.broadcast(p_delta);
 }
 
 void SceneSynchronizerBase::on_app_object_removed(ObjectHandle p_app_object_handle) {

scene_synchronizer.h

@@ -341,6 +341,10 @@ class SceneSynchronizerBase {
 	/// Is called when the synchronization is paused.
 	Processor<> event_sync_paused;
 	Processor<const Settings &> event_settings_changed;
+	/// Executed at the end of the processing.
+	/// Notice this is not the sub and fixed time processing which is sync.
+	/// This is emitted by the application processing function and the delta time is frame dependent.
+	Processor<float/*delta seconds*/> event_app_process_end;
 	Processor<int /*p_peer*/, bool /*p_connected*/, bool /*p_enabled*/> event_peer_status_updated;
 	Processor<FrameIndex, bool /*p_desync_detected*/> event_state_validated;
 	Processor<FrameIndex, int /*p_peer*/> event_sent_snapshot;