Thanks for the help, I have some more questions

[MathyFey]

Hey thanks a lot for helping me out really, you're awesome o/
I stopped getting the crashes after setting up a proper RPC and rebuilding with the fix.

I'm still having some trouble so, I'll rapid fire some questions

(sorry if they're a bit silly, not used to this e.e)

• At first I thought all I had to do was setup the MultiplayerSpawner node with the player scene added to it, so that's not the right way then?
• As far as I understood, the _controller_process is the equivalent to physics process for the module right?
• When you say deterministic you were referring to that random float I had on a comment right, I did that just to check if I wasn't spawning more than one player on top of the other, that's gonna cause a de-sync for sure now that I think about it e.e But is that de-sync going to cause a crash right away or is the state just going to be super wrong?
• Godot's multiplayer confuses me a bit regarding the IDs, is this correct? The server's ID is always 1, the client is random, multiplayer.get_unique_id() is going to return 1 in the server and the client's id on the client, it's not something like, the id is 1 for the local player and stuff like that right? (This is a weird thing I've had on my head for a while now, I used to use unreal, so there's some weird things like that that stuck with me...)
• I hope it's okay if I ask these questions from time to time...

I think I misunderstood something basic, because of the peer ids I'm getting from my tests:
https://www.youtube.com/watch?v=ji0zdZT8eKw

Thanks again for the help, I appreciate it, and sorry if I'm being a bit too high maintenance. e.e

---

On the output log of the server I'm getting these errors:

Here's how my files are looking like now:

game_sync.gd

extends GdSceneSynchronizer

const IP_ADDRESS: String = "127.0.0.1"
const PORT: int = 9999

@onready var player_scene := preload("res://character.tscn")

func _ready():
	multiplayer.peer_connected.connect(peer_connected)
	multiplayer.peer_disconnected.connect(peer_disconnected)
	multiplayer.connected_to_server.connect(connected_to_server)
	multiplayer.connection_failed.connect(connection_failed)

func start_server():
	var peer = ENetMultiplayerPeer.new()
	peer.create_server(PORT, 99)
	multiplayer.multiplayer_peer = peer

	clear()
	reset_synchronizer_mode()

func start_client():
	var peer = ENetMultiplayerPeer.new()
	peer.create_client(IP_ADDRESS, PORT)
	multiplayer.multiplayer_peer = peer

	clear()
	reset_synchronizer_mode()

func peer_connected(id: int):
	print("[", multiplayer.get_unique_id(), "]", " ++ New player connected: ", id)
	spawn_player.rpc_id(id, id)

func peer_disconnected(id: int):
	print("[", multiplayer.get_unique_id(), "]", " -- Player disconnected: ", id)

func connected_to_server():
	print("[", multiplayer.get_unique_id(), "]", " Connection established!")

func connection_failed():
	print("[", multiplayer.get_unique_id(), "]", "[ERROR] ID= ", multiplayer.get_unique_id(), " connection failed!")

@rpc("any_peer", "reliable")
func spawn_player(id: int):
	var player = player_scene.instantiate()
	player.set_multiplayer_authority(id)
	player.name = str(id)
	print(multiplayer.get_remote_sender_id())
	get_tree().root.get_node("Dev").add_child(player)

character.gd

extends CharacterBody3D

func _ready() -> void:

	# Register the node as synchronized. This will create a NetId and call `_setup_synchronizer`.
	# set_multiplayer_authority(multiplayer.get_unique_id())
	GameSync.register_node(self)

func _setup_synchronizer(local_id) -> void:

	# This function is called by the NetworkSynchronizer to setup the node synchronization model.
	# The function `setup_controller` is used to specify the functions that will control the character.
	GameSync.setup_controller(self, get_multiplayer_authority(), _collect_inputs, _count_input_size, _are_inputs_different, _controller_process)

	# Register all the variables to keep in sync that the function `_controller_process` modifies.
	GameSync.register_variable(self, "velocity")
	GameSync.register_variable(self, "transform")

# Networking
func _collect_inputs(delta: float, buffer: DataBuffer) -> void:

	# This function is called by the NetworkSynchronizer each frame, only on the client side, to collect the player`s input into the buffer.
	var input_direction := Vector2()
	var wants_to_jump: bool = false

	input_direction = Input.get_vector("left", "right", "forward", "backward")

	if Input.is_action_pressed("jump"):
		wants_to_jump = true

	buffer.add_vector2(input_direction)
	buffer.add_bool(wants_to_jump)

func _count_input_size(inputs: DataBuffer) -> int:

	# This function is called by the NetworkSynchronizer to read the buffer size.
	# To keep the buffer as small as possible, to save bandwidth, the buffer size isa never stored.
	var size = 0
	size += inputs.get_vector2_size()
	size += inputs.get_bool_size()

	return size

func _are_inputs_different(inputs_A: DataBuffer, inputs_B: DataBuffer) -> bool:

	# The NetworkSynchronizer will call this function to compare two input buffers.
	if inputs_A.size != inputs_B.size:
		return true

	var input_direction_A = inputs_A.read_vector2()
	var input_direction_B = inputs_B.read_vector2()

	if input_direction_A != input_direction_B:
		return true

	var jump_A: bool = inputs_A.read_bool()
	var jump_B: bool = inputs_B.read_bool()

	if jump_A != jump_B:
		return true

	return false

func _controller_process(delta: float, buffer: DataBuffer) -> void:

	# This function is executed by the NetworkSynchronizer each frame, on the clients and the server, to advance the simulation.
	# The buffer contains the player`s input that you can read as follows.
	var input_direction: Vector2 = buffer.read_vector2()
	var wants_to_jump: bool = buffer.read_bool()

	move_the_character(delta, input_direction, wants_to_jump)

func move_the_character(delta, input_direction, wants_to_jump):

	var horizontal_velocity: Vector3 = Vector3(input_direction.x, velocity.y, input_direction.y) * delta
	velocity = horizontal_velocity

	if wants_to_jump:
		velocity.y += 200.0

	velocity.y -= 11.4

	# print(velocity)

	move_and_slide()

[AndreaCatania]

• At first I thought all I had to do was setup the MultiplayerSpawner node with the player scene added to it, so that's not the right way then?

The NetSync doesn't handle the object spawning, so you can use the MultiplayerSpawner, just make sure the register the node with GameSync.register_node(self)

• As far as I understood, the _controller_process is the equivalent to physics process for the module right?

Yes, you are right.

• When you say deterministic you were referring to that random float I had on a comment right, I did that just to check if I wasn't spawning more than one player on top of the other, that's gonna cause a de-sync for sure now that I think about it e.e But is that de-sync going to cause a crash right away or is the state just going to be super wrong?

Yes but there is more, it can't be fully covered here since it's too big topic. For now just assume your processing function is deterministic. If it's not you will experience some rubber banding.

• Godot's multiplayer confuses me a bit regarding the IDs, is this correct? The server's ID is always 1, the client is random, multiplayer.get_unique_id() is going to return 1 in the server and the client's id on the client, it's not something like, the id is 1 for the local player and stuff like that right? (This is a weird thing I've had on my head for a while now, I used to use unreal, so there's some weird things like that that stuck with me...)

Yes, in godot the ID 1 is always assigned to the server. The clients ID changes and looks like a random number.

• I hope it's okay if I ask these questions from time to time...

Yes, np!

---

Regarding your code, everything seems right, I should try it. Can you please create a sample project (without addons) to easily run it and reproduce the issue?

[MathyFey]

Thanks a lot for the answers!

Here's the repo, I made a commit removing all the addons and unused stuff
/~https://github.com/MathyFey/NetworkSyncTest

Regarding asking more questions. In the future should I make more posts in discussions or just ask them here?
To keep everything in one place

[AndreaCatania]

Regarding asking more questions. In the future should I make more posts in discussions or just ask them here?
To keep everything in one place

Better to open a new discussion for each question, so we keep things organized!