Safe to modify a Network Variable before NetworkObject is spawned ?

Hey Goreduc, thanks for trying this out. I asked this internally and will come back to you when I have an answer.

 

This has indeed been a question and there are definitively some improvements needed in this area of NGO. Some things to contemplate about setting a NetworkVariable prior to spawn:

• You will not know which relative instance does or does not have authority to set this value
  • i.e. If it is owner write permissions, then every relative instance (owners and non-owners) will apply some value to it (this might be "ok" and the warning is a pesky thing to have to see each time you enter play mode).
• Since in-scene placed NetworkObjects are instantiated (Awake) and started prior to spawning (done while the scene is loaded) and dynamically spawned NetworkObjects are instantiated, spawned, and then started, there is an opportunity with dynamically spawned NetworkObjects during Start to know who can and cannot write and you can set the value at that time without the warning.
  • However, if you use the same component on in-scene placed NetworkObjects you will still get this warning.

With that said, there is a way to "have your cake and eat it too" with NetworkVariable<T> (haven't tested this approach with NetworkList). Below is an example script that provides you with a way to work around the warning issue when assigning a value prior to the associated NetworkObject being spawned and works with both in-scene placed and dynamically spawned NetworkObjects:

Code (CSharp):

1. using UnityEngine;
2. using Unity.Netcode;
3.  
4. public class PreSpawnNetworkVariable<T> : NetworkVariable<T>
5. {
6.     /// <summary>
7.     /// Handles setting the value when used in a NetworkBehaviour attached
8.     /// to an in-scene placed and dynamically spawned NetworkObject
9.     /// </summary>
10.     public void SetValuePreSpawn(T value)
11.     {
12.         var networkBehaviour = GetBehaviour();
13.         if (networkBehaviour != null && networkBehaviour.IsSpawned)
14.         {
15.             if (WritePerm == NetworkVariableWritePermission.Server && !networkBehaviour.NetworkManager.IsServer)
16.             {
17.                 // Ignore the attempted change
18.                 return;
19.             }
20.             if (WritePerm == NetworkVariableWritePermission.Owner && !networkBehaviour.IsOwner)
21.             {
22.                 // Ignore the attempted change
23.                 return;
24.             }
25.         }
26.         Value = value;
27.     }
28.  
29.     public override void SetDirty(bool isDirty)
30.     {
31.         if (GetBehaviour() != null)
32.         {
33.             base.SetDirty(isDirty);
34.         }
35.     }
36.  
37.     public PreSpawnNetworkVariable(T value = default,
38.         NetworkVariableReadPermission readPerm = DefaultReadPerm,
39.         NetworkVariableWritePermission writePerm = DefaultWritePerm)
40.         : base(value, readPerm, writePerm)
41.     {
42.     }
43. }
44.  
45. public class NetworkVarTest : NetworkBehaviour
46. {
47.     private PreSpawnNetworkVariable<int> m_PreSpawnSetNoWarnings = new PreSpawnNetworkVariable<int>(0, NetworkVariableReadPermission.Everyone, NetworkVariableWritePermission.Owner);
48.  
49.     private void PreSpawnSetNoWarningsValueChanged(int oldValue, int newValue)
50.     {
51.         Debug.Log($"Updated m_PreSpawnSetNoWarnings's value to {m_PreSpawnSetNoWarnings.Value}!");
52.     }
53.  
54.     private void Awake()
55.     {
56.         m_PreSpawnSetNoWarnings.OnValueChanged += PreSpawnSetNoWarningsValueChanged;
57.         m_PreSpawnSetNoWarnings.Value = 5;
58.     }
59.  
60.     private void Start()
61.     {
62.         // Avoids issue with in scene placed and dynamically spawned NetworkObjects
63.         m_PreSpawnSetNoWarnings.SetValuePreSpawn(10);
64.     }
65.  
66.     public override void OnNetworkSpawn()
67.     {
68.         if (IsOwner)
69.         {
70.             m_PreSpawnSetNoWarnings.Value = 20;
71.         }
72.         Debug.Log($"[Client-{NetworkManager.LocalClientId}] m_PreSpawnSetNoWarnings's value is: {m_PreSpawnSetNoWarnings.Value}!");
73.         base.OnNetworkSpawn();
74.     }
75. }
76.  

Attaching this to an in-scene placed NetworkObject and running a host as a stand alone build and a client in the editor you would see this console output:

Some things to note (these points are written client-side relative when I was testing this component attached to an in-scene placed NetworkObject...so the server is the default owner of in-scene placed NetworkObject):

• You will see that subscribers to the OnValueChanged will be notified (prior to spawn) that the value was updated.
  • You should note that you will get no notification when a non-owner spawns as authority has taken over and the object is spawned with the owner's value set. (intentionally set the script this way to point this aspect out)
• You will notice that setting the value directly does not generate any warnings, this is handled in the overridden "SetDirty" method where I just don't mark it dirty if there is no assigned NetworkBehaviour.
• To handle the issue with in-scene placed and dynamically spawned NetworkObjects, I made an ancillary SetValuePreSpawn method that will not try to set the value if the instance does not have authority and the associated NetworkObject is spawned (to avoid the errors you would get otherwise).

Either case, this small code snippet should provide you with an alternative way to handle setting NetworkVariable<T> prior to spawn and might also provide additional insight behind the question as to when it is or is not "ok" to set a NetworkVariable. The answer is that it should be "ok" at any time, but there are some on-going internal (pending) discussions as to the best way to handle resolving this issue.
(For the time being, you can use the above PreSpawnNetworkVariable<T> derived class that provides a work around and allows you to set it at any point without any warnings)

 

@Goreduc
*yikes!*
I apologize. I was using the develop branch and that method is not available in NGO v1.1 or v1.2, but it will be available in the up-and-coming update (I believe it will be v1.3). So, I provided a solution to something you don't have access to at this time.

Of course, if you wanted to test this approach (until the update is released) you can replace your com.unity.netcode.gameobjects entry in your project's manifest.json file to look like this:

Code (CSharp):

1. "com.unity.netcode.gameobjects": "https://github.com/Unity-Technologies/com.unity.netcode.gameobjects.git?path=com.unity.netcode.gameobjects#develop"

I would backup your manifest file, make the change, and if you want to switch it back just use the original backed up manifest file (or you can keep it until the updated package is available).

Regarding the dirty flag, if your NetworkVariable does not have an assigned NetworkBehaviour then it is not yet initialized which means the associated NetworkObject is not spawned... so the dirty flag really has no "relevance" until the associated NetworkObject is spawned (i.e. no need to worry about synchronization since you are just setting its initial value prior to being spawned).

 

Yeah, we are much closer to the next release so it might be easier to use that.