killbox/scenes_old/server/server.gd

extends Node
class_name GameServer

@export var port: int = 27015
@export var player_limit: int = 30
@export var current_map: String = "lowpoly_tdm_2"
@export var current_player_data := PlayerData.new()

# -- This variable should store all the active players
var players: Dictionary = {}

func _ready() -> void:
	multiplayer.peer_connected.connect(_on_player_connected)
	multiplayer.peer_disconnected.connect(_on_player_disconnected)
	multiplayer.connected_to_server.connect(_on_connected_to_server)
	

func _on_player_disconnected(id) -> void:
	logger.info("player is disconnected with id: " + str(id))
	
	
func _on_player_connected(id) -> void:
	# Send the client information about the server
	if multiplayer.is_server():
		logger.info("player is connected with id: " + str(id))
		_sync_map_from_the_server.rpc_id(id, current_map)
		_sync_players.rpc_id(id, players)

@rpc("authority", "reliable", "call_remote")
func _sync_players(data: Dictionary):
	var player_data_id: EncodedObjectAsID = data[1]
	print(instance_from_id(player_data_id.object_id))

@rpc("authority", "call_remote", "reliable")
func _sync_map_from_the_server(map_name: String):
	var game_root: GameRoot = get_tree().get_root().find_child("GameRoot", true, false)
	game_root.load_map.emit(GameServerAutoload.current_map)
	
func _on_connected_to_server() -> void:
	logger.info("connection is successful, sending info")
	register_player.rpc_id(1, multiplayer.get_unique_id(), current_player_data.username)

func create_server(server_only: bool = false) -> Error:
	var peer := ENetMultiplayerPeer.new()
	logger.info("starting a server the port: " + str(port))
	var err := peer.create_server(port, player_limit)
	multiplayer.multiplayer_peer = peer
	if !server_only:
		var player_data := PlayerData.new()
		player_data.id = 1
		logger.warning("TODO: player name is not yet implemented")
		player_data.username = "dummy"
		players[1] = {
			"id": 1,
			"username": "dummy",
		}
	var game_root: GameRoot = get_tree().get_root().find_child("GameRoot", true, false)
	game_root.load_map.emit(GameServerAutoload.current_map)
	if err:
		return err
	return OK
	
func join_server(ip: String, port: int) -> Error:
	var peer = ENetMultiplayerPeer.new()
	logger.info("trying to connect to: " + ip + ":" + str(port))
	var err = peer.create_client(ip, port)
	if err != OK:
		return err
	multiplayer.multiplayer_peer = peer
	return OK

@rpc("any_peer", "reliable", "call_remote")
func register_player(id: int, name: String):
	if multiplayer.is_server():
		logger.info("registering player: " + str(id))
		var player_data := PlayerData.new()
		player_data.id = id
		player_data.username = name
		players[multiplayer.get_remote_sender_id()] = {
			"id": id,
			"username": "dummy",
		}
		logger.info("player " + str(id) + " is registered")
	else: 
		logger.debug("register player is supposed to be executed on the server")

@rpc("any_peer", "reliable", "call_local")
func select_side(side: String):
	var player_id = multiplayer.get_remote_sender_id()
	if side == "blue":
		players[player_id].side = "blue"
	elif side == "red":
		players[player_id].side = "red"
	else:
		pass
		
# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(delta: float) -> void:
	pass