Shared variables between clients in a multiplayer game.

MikeCL

Hello everyone!

I've been diving into some netcode (for the first time) in Godot. It's been quite a journey so far, but I'm slowly starting to get the hang of it.

What I'm trying to figure out now is how to set variables/states that can be accessed with all clients. I know about rpc to trigger functions and the MutliplayerSpawner and MutliplayerSynchronizer, but none of them store actual values to be accessed, as I understand?

So to give a scenario:

server is created
client #1 joins - Here I want to store the id to refference this player as first to join. (not counting the server host)
client #2 joins - I want this player to know what other player first joined the server.

My initial thought is to store a variable on the server-side that could be accessed. So the question is, how do I accomplish this? And also, is there a better way of doing this? Is there a built-in function that makes this easy?

Still trying to wrap my head around how multiplayer networking works in Godot.

JusTiCe8

MikeCL if you have not already have prior experience with networking, I strongly advise you to play a bit with the basic, ie: TCP client/server code in any language, there are tons of samples tutorials online.

That say, I think you can get your answer with Godot network demo codes.

And my take on that, for what its worth would be to let the server dealing with this, because it's the only one which (suppose to) knows everything, and clients can get access to some functions like get_other_players or get_first_player which return a unique id and when a player first connect to the server, it will get its own unique id when connect is successful (fully authenticated and allowed.)

Addition: these IDs could be even just linked to a session, so they will be assigned accordingly to players joined and reset after disconnection OR associated once and for all to a player's account, and in such case, maybe using backend like LootLocker may things easier as you can manage player's accounts and authentication with various auth provider like google, steam, epic, ...

kuligs2

What you need is serialization of data. Ive asked on this forums half a year or more ago, and i think with godot 4.3 or 4.2 they updated the serialization of data so that it is easy to pass data to other multiplayer players.

You could also do it with multiplayer synchronizer. I havent played much with it but some tests i did were successfull.

With serialization i was successfull (project is now broken):

	var bytes = var_to_bytes_with_objects(GameManager.player_list) # var player_list: Dictionary
	add_local_players.rpc_id(id,bytes)

and then

@rpc
func add_local_players(player_list_bytes):
	var player_list = bytes_to_var_with_objects(player_list_bytes)
	for id in player_list:
		var player_obj = player_list[id]
		add_player(player_obj.id,player_obj.name)
	pass

func create_player(_id, _name):
	var new_player_data:PlayerData = PlayerData.new()
	new_player_data.id=_id
	new_player_data.player_name=_name
	new_player_data.score = 0.0
	if multiplayer.is_server(): 
		new_player_data.is_server=true
	GameManager.player_list[_id]=new_player_data

PlayerData

extends Resource
class_name PlayerData

var id: int
var player_name:String
var is_server:bool
var score: float

Cant post minimal project because its broken.. need time to investigate and fix it but am lazy.. 😃

YOu can send simple strings without serialization using rpc's. If you want lists or heavy data then you need to serialize into bytes.

Here i was exploring: https://godotforums.org/d/40153-help-with-byteobject-conversion-sent-over-rpc/4

MikeCL

It took a while, but the entire RPC workflow finally started to click.

I've dealt with a lot of server/client communication over my career. But having both server and client code mixed in the same project really messed with my head. I'm so used to having a clear separation between server and client.

Maybe there's better way of doing this, but what I've learned that works for me is to make sure only the server runs the specific logic that saves the data (simple sample code with my current understanding):

var some_data: Dictionary = {} #Data to only be stored and handled on server-side

func save_data(my_data) -> void:
    request_save_data.rpc_id(1, my_data)

func get_data() -> void:
    request_get_data.rpc_id(1)

@rpc("any_peer", "call_remote", "reliable")
func request_save_data(data) -> void:
    if !multiplayer.is_server(): return #making sure this only runs on server
    some_data = data

@rpc("any_peer", "call_remote", "reliable")
func request_get_data() -> void:
    if !multiplayer.is_server(): return #making sure this only runs on server
    
    var sender_id: int = multiplayer.get_remote_sender_id()
    data_to_client.rpc_id(sender_id, some_data) #sends data back to client

@rpc("authority", "call_remote", "reliable") #Authority as the only allowed "invoker". 
func data_to_client(data) -> void:
    {...handle data on client...}

It gets a bit messy with the extra function calls to loop back the data, which is needed since you can't return values between peers (in my current understanding, please correct me on this if I'm wrong, still learning). This could probably be cleaned up with Getter and Setters.

DaveTheCoder

MikeCL server runs the logic only

Can you explain that further?

MikeCL

DaveTheCoder I mean that the server is the only one running the logic that saves the data. Like with rpc functions you can invoke functions on other peers (and server) in the network (and pass on data with parameters if needed). So, like in the example, I can make the client trigger a function that would only run on the server. I do realize that my sentence was poorly written. 😅

update: I tweaked the sentence, hope it makes more sense now 🙂