On new player connect, update game state help

Unity Engine
1

If a game has started for example with 2 players and let’s say they do some damage to eachother. If a new player joins the game, how is that new player supposed to be updated with the current players’ health? Of course, I don’t want to use a buffered rpc call for everytime someone does damage.

I’ve been trying to do it on the “OnNetworkInstantiate()” function: something like:

if (networkView.isMine){
			if (!Network.isServer){
			      // ... setting up which team I'm on ...
			}
			
		}else{
                        //otherwise, if im the remote player, send my current health state to the new player
			networkView.RPC("sendMyHealth", RPCMode.Others, currentHealth);
		}

So, if I’m the instatiated player, it does nothing, otherwise, if I’m a remote player, (e.g. the 2 players that were in the game earlier), send my current health value. But the problem I get is, within my “sendMyHealth()” function, I have this line (which is supposed to show their health above their character):

transform.FindChild("fontBillboard(Clone)").GetComponent<TextMesh>().text = currentHealth + "/100";

Which throws an error on the player that just joined because the remote player’s may have not yet loaded on their screen yet. I get “Object reference not set” on that line.

Would like to know how this is usually done or if I’m on the right track.

2

Why don’t you want to use a buffered RPC ?
It was created for things just like that.

3

What if the game has 10 people, all doing damage to eachother. If I buffer each hit to every player, so that new players know their current health, the overhead for that would be huge would it not?

I’ve been reading quite a bit on buffered RPC call’s also, looks like other people steer away from buffered RPC’s because of problems in the long run.

4

eh no, why would that be ?

5

One of the posts I dug up was this one: http://forum.unity3d.com/threads/61646-Can-I-seriously-not-remove-a-specific-Network.Instantiate-from-the-RPC-buffer

You had also replied to that, but I’m basically in the same situation. I can’t buffer every single bullet for example that a player shoots etc. What I want to achieve is, when a player joins, have all current players already in the game just update their current health/if they’re shooting/any missiles they have shot to that new player.

For example -
A new player joins (player 3 for example), have that player send a request to the server saying “update me with the game state”.
The server replies with a bunch of info, such as:

  1. set player 1’s health to 50/100
  2. set player 2’s health to 80/100
  3. create a missile going in this direction
  4. instantiate a “structure” in this location with this much health

The thing is I don’t know where to start to go about doing this. That’s my question.

Unless I’m wrong in thinking how buffered RPC’s work. I don’t need to update the new player with a bullet that was shot 30minutes ago and is not in the game anymore.

6

You are mixing multiple things and it’s realy complicating your design.
You don’t need to buffer bullets, you only need to buffer things you want joining players to see.
The players health is something that the server can send to the joining clients.
That is the beauty of auth servers, they already have all the info needed for joining clients.
You can also remove rpc’s from the buffer.
For example when a player dies, you can remove his rpc’s from the buffer.

7

Hm, ok, so just to clarify. Everytime a player takes damage (e.g. by a bullet), I’m currently doing this each hit (keeping in mind, each bullet gets sent every 0.1 seconds, I’m only calling the updateHealth() function if the player gets hit):

networkView.RPC("updateHealth", RPCMode.All, currentHealth);

and this is the updateHealth() rpc function.

[RPC]
	void updateHealth(int amount){
		currentHealth = amount;
		
		if (currentHealth <= 0){
			dead = true;
			currentHealth = 0;
		}else{
			if (dead){
				dead = false;	
			}
			if (!isVisible){

				isVisible = true;
				respawnTimer = 0;
			}
		}
		

	}

So you’re saying I should basically change my updateHealth() RPC call to a buffered one, like this?:

networkView.RPC("updateHealth", RPCMode.AllBuffered, currentHealth);

And what about in the case of shooting a missile, if a player shoots a missile, and a new player joins, is that missile RPC instantiation call supposed to be a buffered one also so that the new player will see it mid-flight?

EDIT: just read your above post. I think I need to read up on remove RPC’s from buffer in this case (when a player dies), unless you could provide an example of how to do it.

8

No, that’s just what I said not to do.
The server can update a joining player during the instantiation.
You can make the missile a buffered one and once the missile explodes, it will be removed from the buffer since it won’t excist anymore.

9

Ah, I misread your post. But what I’m not catching on is this part:

This is what I’m not following, how do I get the server to update the joining player with other player’s health? I apologize if I’ve misunderstood you somewhere.

EDIT: also ran into a problem for the missile… unfortunately… if I buffer the instantiation of the missile, sure that’s simple, but when a new player joins, that missile has moved by then, but on the new player’s screen, the missile is instantiated at the position that the buffered RPC call has been set to. This is hard to grasp on how to make this work properly to be honest.

10

Yep, just like a player you need to sync the position and rotation or it will stay in the spot that it has been instanciated.

11

I know this is a really old thread, but if you haven’t already, you should look into StateSynchronization for variables such as health and position… anything that is constantly changing.

Buffered RPCs are good for things that don’t change all that often, for instance, applying a custom material to a newly instantiated network object by sending the name of the material from a string and loading that resource. Also state changes in the object, like when the player/NPC dies.