fix: Record inputs after gathering in after_tick (#614)

One off inputs are recorded on NetworkTİme.after_tick.
Before that* commit rollback inputs were recorded from rbs after_tick.
After that commit rollback inputs are recorded from network-rollback
after_tick.

Godot calls signals based on their connected order.
Before server update rbs's were connecting their signals with a deferred
call. This was resulting in one off input node winning the race. But
after the server update, since servers are initialized before anything
else, input nodes are always losing the race.

This pr fixes the race condition by explicitly calling NetworkRollback methods, instead of relying on signal connection order.

---------

Co-authored-by: Tamás Gálffy <ezittgtx@gmail.com>

Author: TuysuzTavsan

addons/netfox.extras/plugin.cfg

@@ -3,5 +3,5 @@
 name="netfox.extras"
 description="Game-specific utilities for Netfox"
 author="Tamas Galffy and contributors"
-version="1.46.4"
+version="1.46.5"
 script="netfox-extras.gd"

addons/netfox.internals/plugin.cfg

@@ -3,5 +3,5 @@
 name="netfox.internals"
 description="Shared internals for netfox addons"
 author="Tamas Galffy and contributors"
-version="1.46.4"
+version="1.46.5"
 script="plugin.gd"

addons/netfox.noray/plugin.cfg

@@ -3,5 +3,5 @@
 name="netfox.noray"
 description="Bulletproof your connectivity with noray integration for netfox"
 author="Tamas Galffy and contributors"
-version="1.46.4"
+version="1.46.5"
 script="netfox-noray.gd"

addons/netfox/network-time.gd

@@ -562,15 +562,16 @@ func _loop() -> void:
 	_last_process_time = _clock.get_time()
 	while _next_tick_time < _last_process_time and ticks_in_loop < max_ticks_per_frame:
 		if ticks_in_loop == 0:
-			InterpolationServer._clear_teleports()
-			InterpolationServer._apply_target_state()
-			before_tick_loop.emit()
+			_before_tick_loop()
 
 		before_tick.emit(ticktime, tick)
-
 		on_tick.emit(ticktime, tick)
-
 		after_tick.emit(ticktime, tick)
+
+		# Record data for rollback
+		NetworkRollback._after_tick(tick)
+
+		# Record data for StateSynchronizer
 		NetworkHistoryServer._record_sync_state(tick + 1)
 		NetworkSynchronizationServer._synchronize_sync_state(tick + 1)
 
@@ -579,12 +580,27 @@ func _loop() -> void:
 		_next_tick_time += ticktime
 
 	if ticks_in_loop > 0:
-		after_tick_loop.emit()
-		NetworkHistoryServer._restore_synchronizer_state(tick)
-		InterpolationServer._record_next_state()
+		_after_tick_loop()
 
+	# Send queued network identities
 	NetworkIdentityServer.flush_queue()
 
+func _before_tick_loop() -> void:
+	InterpolationServer._clear_teleports()
+	InterpolationServer._apply_target_state()
+	before_tick_loop.emit()
+
+func _after_tick_loop() -> void:
+	# Run rollback loop
+	NetworkRollback._rollback()
+
+	# Emit signal
+	after_tick_loop.emit()
+
+	# Restore state for StateSynchronizer
+	NetworkHistoryServer._restore_synchronizer_state(tick)
+	InterpolationServer._record_next_state()
+
 func _process(delta: float) -> void:
 	_process_delta = delta
 

addons/netfox/plugin.cfg

@@ -3,5 +3,5 @@
 name="netfox"
 description="Shared internals for netfox addons"
 author="Tamas Galffy and contributors"
-version="1.46.4"
+version="1.46.5"
 script="netfox.gd"

addons/netfox/rollback/network-rollback.gd

@@ -341,11 +341,6 @@ func _get_rollback_destroy_method(object: Object) -> Callable:
 
 func _ready():
 	NetfoxLogger.register_tag(_get_rollback_tag)
-	NetworkTime.after_tick_loop.connect(_rollback)
-	NetworkTime.after_tick.connect(func(_dt, tick):
-		NetworkHistoryServer._record_rollback_input(tick + input_delay)
-		NetworkSynchronizationServer._synchronize_input(tick + input_delay)
-	)
 
 	NetworkSynchronizationServer._on_input.connect(_handle_input)
 	NetworkSynchronizationServer._on_state.connect(_handle_state)
@@ -446,6 +441,10 @@ func _rollback() -> void:
 	_mutated_nodes.clear()
 	_is_rollback = false
 
+func _after_tick(tick: int) -> void:
+	NetworkHistoryServer._record_rollback_input(tick + input_delay)
+	NetworkSynchronizationServer._synchronize_input(tick + input_delay)
+
 func _handle_input(snapshot: _Snapshot):
 	if snapshot.is_empty():
 		return

test/network-mocks.gd

@@ -23,9 +23,9 @@ static func in_rollback(callback: Callable) -> void:
 
 ## Runs [param callback] in the network tick loop
 static func in_network_tick_loop(callback: Callable) -> void:
-	NetworkTime.before_tick_loop.emit()
+	NetworkTime._before_tick_loop()
 	callback.call()
-	NetworkTime.after_tick_loop.emit()
+	NetworkTime._after_tick_loop()
 
 ## Runs [param callback] as part of a network tick
 static func in_network_tick(callback: Callable) -> void: