Does this library have rewinding back in time on server to check if player did hit server side enemy (pve)?

[xand00]

I added library to my project and player movement works very good, i checked all docs and didn't find or missed part where it says if i can go back in time on server and check if player did hit pve enemy or another player so latency is taken into account

Maybe i got this library wrong and there is lag compensation for player movement, effects, firing, etc, but without rewinding back in time?

[elementbound]

Hi, glad to hear it's working well! Yes, there is absolutely rewind, that's what the NetworkRollback and RollbackSynchronizer classes manage.

Rewinding to check for hits should be doable, although a bit tedious with the current API. You can rewind state to a given tick by emitting NetworkRollback.on_prepare_tick with the target tick as parameter.

After that, you might need to update the physics state directly through PhysicsServer, by calling body_set_state, because Godot only updates physics state before the physics process callback. After that, you can do your raycast or collision check to see if the hit landed. Note that this also needs some fiddling with the physics updates, you either have to manually do the cast ( see example ), or force update on your RayCast or ShapeCast node ( e.g. force_raycast_update ).

This comes from how Godot handles physics updates ( which is reasonable for most use cases ), but I am planning to make this a bit easier in future versions - I'm considering adding a NetworkRollback.rewind method to get back to a specific state, and possibly a config flag to RollbackSynchronizer that will make it do the physics updates automatically on rollback.

[xand00]

Thank you for the answer! I'll try that soon

I have one more question, is there a way to handle many server side enemies (pve) using netfox nodes? I checked examples and didn't see anything about pve

I tried to make it work and i managed to do it but with a workaround:
My enemy has:

1. var empty_input: bool = false in it's script
2. RollbackSynchronizer node with :global_transform in state_properties, :empty_input in input_properties

I did empty_input because RollbackSynchronizer didn't work if input_properties were empty

It seems to work but if i spawn atleast 10 enemies then netfox will throw errors about too late ticks and my movement becomes laggy

[elementbound]

Originally I figured that Godot's MultiplayerSynchronizer should be fine for this kind of thing, since the server is the authority, and the node will just broadcast the state. The difficulty with that is that the MultiplayerSynchronizer is not tied to netfox's tick loop, and does not do interpolation either. I'm still considering what would be the best way to handle this, but for now I have a class that I'll add to netfox in the coming weeks.

I'm already using it in my own game to test it, so I can share here:
EDIT: The node below is available from netfox v1.3.0 and higher, you can grab that instead of copy-pasting the code.

StateSynchronizer

extends Node
class_name StateSynchronizer

# TODO: Custom icon

## Synchronizes state from authority.

@export var root: Node
@export var properties: Array[String]

var _property_cache: PropertyCache
var _props: Array[PropertyEntry]

var _last_received_tick: int = -1
var _last_received_state: Dictionary = {}

## Process settings.
##
## Call this after any change to configuration.
func process_settings():
	_property_cache = PropertyCache.new(root)
	_props = []

	for property in properties:
		var pe = _property_cache.get_entry(property)
		_props.push_back(pe)

func _ready():
	process_settings()
	NetworkTime.after_tick.connect(_after_tick)

func _after_tick(_dt, tick):
	if is_multiplayer_authority():
		# Submit snapshot
		var state = PropertySnapshot.extract(_props)
		rpc("_submit_state", state, tick)
	else:
		# Apply last received state
		PropertySnapshot.apply(_last_received_state, _property_cache)

@rpc("authority", "unreliable", "call_remote")
func _submit_state(state: Dictionary, tick: int):
	if tick <= _last_received_tick:
		return
		
	_last_received_state = state
	_last_received_tick = tick

You can use it similarly to RollbackSynchronizer - add it to your server-side enemy and configure which properties to sync. However, since the server handles the simulation, there's no input properties to worry about. This is compatible with interpolation, so if you also have a TickInterpolator node with the properties configured, it should work just fine.

[xand00]

Thank you!

[xand00]

I just tried StateSynchronizer, it works with :position, but when i add TickInterpolator with :position, then enemies just stand still, i also tried to sync rotation, it syncs, but when i add same property to TickInterpolator, then they stop rotating

[elementbound]

Is the ownership set on all nodes ( StateSynchronizer, TickInterpolator )? Was process_settings called on all of them, after setting ownership?

[xand00]

yes, everywhere owner is 1, i tried to manually call set_multiplayer_authority(1) on every client and call process_settings on StateSynchronizer and TickInterpolator but no effect