WIP checkpoint: Implement Godot dedicated server scene + player spawning

scripts/server.gd

@@ -3,6 +3,7 @@
 ## and runs the simulation tick loop at 20 Hz.
 extends Node
 
+
 ## Maximum number of concurrent players.
 const MAX_PLAYERS := 16
 
@@ -30,13 +31,18 @@ var is_running: bool = false
 ## Accumulated real time for fixed timestep simulation.
 var accumulator: float = 0.0
 
+## Player scene resource (loaded once).
+var _player_scene: PackedScene
+
 
 func _ready() -> void:
-	# Set this node as the multiplayer authority.
-	multiplayer.multiplayer_peer = _create_server_peer()
-	multiplayer.server = self
+	# Preload the player scene once.
+	_player_scene = preload("res://scenes/player.tscn")
 
+	# Create and assign the ENet server peer.
+	network_peer = _create_server_peer()
 	if network_peer:
+		multiplayer.multiplayer_peer = network_peer
 		is_running = true
 		print("[Server] Started on port %d" % SERVER_PORT)
 	else:
@@ -44,23 +50,27 @@ func _ready() -> void:
 		get_tree().quit(1)
 
 
+# ---------------------------------------------------------------------------
+# Server creation
+# ---------------------------------------------------------------------------
+
 func _create_server_peer() -> ENetMultiplayerPeer:
 	var peer := ENetMultiplayerPeer.new()
 	var error := peer.create_server(SERVER_PORT, MAX_PLAYERS)
 	if error != OK:
 		printerr("[Server] create_server error: %d" % error)
-		return ENetMultiplayerPeer()
+		return null
 	return peer
 
 
+# ---------------------------------------------------------------------------
+# Fixed-timestep simulation loop
+# ---------------------------------------------------------------------------
+
 func _process(delta: float) -> void:
 	if not is_running:
 		return
 
-	# Handle disconnect events.
-	if multiplayer.peer_disconnected.is_connected(_on_peer_disconnected):
-		pass  # already connected
-
 	# Fixed timestep accumulator.
 	accumulator += delta
 	while accumulator >= TICK_DURATION:
@@ -74,7 +84,7 @@ func _tick() -> void:
 
 	# Process player inputs and update state.
 	for peer_id in players:
-		var player: Node = players[peer_id]
+		var player: Node3D = players[peer_id]
 		if player and player.has_method("process_server_input"):
 			player.process_server_input(tick)
 
@@ -86,17 +96,19 @@ func _broadcast_snapshot() -> void:
 	"""Broadcast the current authoritative state to all connected clients."""
 	var snapshot_data := {
 		"tick": tick,
-		"players": {}
+		"players": {},
 	}
 
 	for peer_id in players:
-		var player: Node = players[peer_id]
+		var player: Node3D = players[peer_id]
 		if player and player.has_method("get_server_state"):
 			snapshot_data.players[peer_id] = player.get_server_state()
 
-	# Send snapshot to all peers except the server itself.
+	# Send snapshot to all peers except the server itself (peer_id == 1).
 	var peer_ids: Array = multiplayer.get_peers()
 	for pid in peer_ids:
+		if pid == 1:  # 1 is the server itself
+			continue
 		rpc_id(pid, "_receive_snapshot", snapshot_data)
 
 
@@ -106,7 +118,9 @@ func _receive_snapshot(snapshot_data: Dictionary) -> void:
 	pass  # Handled by client scene.
 
 
-# --- Connection lifecycle ---
+# ---------------------------------------------------------------------------
+# Connection lifecycle
+# ---------------------------------------------------------------------------
 
 func _on_peer_connected(peer_id: int) -> void:
 	print("[Server] Peer %d connected." % peer_id)
@@ -117,7 +131,7 @@ func _on_peer_connected(peer_id: int) -> void:
 		return
 
 	# Spawn a Player node for this peer.
-	var player := preload("res://scripts/player.tscn").instantiate()
+	var player: Node3D = _player_scene.instantiate()
 	player.name = "Player_%d" % peer_id
 	player.peer_id = peer_id
 	add_child(player)
@@ -129,18 +143,20 @@ func _on_peer_connected(peer_id: int) -> void:
 func _on_peer_disconnected(peer_id: int) -> void:
 	print("[Server] Peer %d disconnected." % peer_id)
 	if players.has(peer_id):
-		var player: Node = players[peer_id]
+		var player: Node3D = players[peer_id]
 		if player.is_inside_tree():
 			player.queue_free()
 		players.erase(peer_id)
 
 
-# --- RPCs ---
+# ---------------------------------------------------------------------------
+# RPCs
+# ---------------------------------------------------------------------------
 
 @rpc("any_peer", "call_remote", "reliable")
-func _kick(peer_id: int, reason: String) -> void:
-	print("[Server] Kicking peer %d: %s" % [peer_id, reason])
-	rpc_id(peer_id, "_disconnect", reason)
+func _kick(reason: String) -> void:
+	print("[Server] Kicking caller: %s" % reason)
+	rpc_id(get_rpc_sender_id(), "_disconnect", reason)
 
 
 @rpc("call_remote", "reliable")
@@ -149,7 +165,9 @@ func _disconnect(reason: String) -> void:
 	get_tree().quit(0)
 
 
-# --- Signal connections ---
+# ---------------------------------------------------------------------------
+# Signal connections
+# ---------------------------------------------------------------------------
 
 func _enter_tree() -> void:
 	multiplayer.peer_connected.connect(_on_peer_connected)