SyncList not initialized

Kesarium · July 21, 2017, 1:08am

I’m facing a problem with my multiplayer game. I’m using a SyncListStruct for each treasure chest, which holds all the items inside the chest, and these items are shared between all players. The code seems to work fine when you’re playing the game but when script debugging is enabled or you look in the logs you can see 6 ‘SyncList not initialized’ errors. These are from the inactive treasure chests in the scene, and by inactive I mean their collision and renderer are inactive, all of their scripts and their game objects are still active.

Now here’s the weird part. When I run either the host or the client in the editor and connect the other with the .exe these errors show up in the host and client logs. When I run both the host and client from the .exe the errors only show on the client.

I stumbled upon these errors in the log when trying to figure out why the client is always getting disconnected from the host after approximately 25 minutes of playing the game. I’ve been looking at forum posts of similar issues and anything from those posts that I try just doesn’t solve the problem.

Here is the error in the client’s log that occurs 6 times when both the host and client are run from an .exe:

SyncList not initialized
0x00007FF6E34C1A24 (Quest)
0x00007FF6E34C5122 (Quest)
0x00007FF6E37F56A1 (Quest)
0x00007FF6E3B2B274 (Quest)
0x00007FF6E3B2B70C (Quest)
0x00007FF6E4044718 (Quest)
0x0000000006D97E33 (Mono JIT Code) (wrapper managed-to-native) UnityEngine.DebugLogHandler:Internal_Log (UnityEngine.LogType,string,UnityEngine.Object)
0x0000000006D97C94 (Mono JIT Code) [DebugLogHandler.cs:9] UnityEngine.DebugLogHandler:LogFormat (UnityEngine.LogType,UnityEngine.Object,string,object[ ])
0x0000000006D97595 (Mono JIT Code) [Logger.cs:47] UnityEngine.Logger:Log (UnityEngine.LogType,object)
0x000000004F74B8B3 (Mono JIT Code) [DebugBindings.gen.cs:124] UnityEngine.Debug:LogError (object)
0x000000004F74AE44 (Mono JIT Code) [SyncList.cs:295] UnityEngine.Networking.SyncList1<LootShared/SharedItem>:SendMsg (UnityEngine.Networking.SyncList1/Operation<LootShared/SharedItem>,int,LootShared/SharedItem)
0x000000004F74AC79 (Mono JIT Code) [SyncList.cs:338] UnityEngine.Networking.SyncList1<LootShared/SharedItem>:SendMsg (UnityEngine.Networking.SyncList1/Operation<LootShared/SharedItem>,int)
0x000000004F74A99C (Mono JIT Code) [SyncList.cs:395] UnityEngine.Networking.SyncList`1<LootShared/SharedItem>:Clear ()
0x000000004F74A6F9 (Mono JIT Code) Unity.GeneratedNetworkCode:_ReadStructSyncListSharedItem_LootShared (UnityEngine.Networking.NetworkReader,LootShared/SyncListSharedItem)
0x000000004F74A265 (Mono JIT Code) LootShared:OnDeserialize (UnityEngine.Networking.NetworkReader,bool)
0x000000004F743C60 (Mono JIT Code) [NetworkIdentity.cs:750] UnityEngine.Networking.NetworkIdentity:OnUpdateVars (UnityEngine.Networking.NetworkReader,bool)
0x000000004F74375F (Mono JIT Code) [ClientScene.cs:491] UnityEngine.Networking.ClientScene:ApplySpawnPayload (UnityEngine.Networking.NetworkIdentity,UnityEngine.Vector3,byte[ ],UnityEngine.Networking.NetworkInstanceId,UnityEngine.GameObject)
0x000000004F740568 (Mono JIT Code) [ClientScene.cs:608] UnityEngine.Networking.ClientScene:OnObjectSpawnScene (UnityEngine.Networking.NetworkMessage)
0x000000004F7372CC (Mono JIT Code) [NetworkConnection.cs:469] UnityEngine.Networking.NetworkConnection:HandleReader (UnityEngine.Networking.NetworkReader,int,int)
0x000000004F73689B (Mono JIT Code) [NetworkConnection.cs:425] UnityEngine.Networking.NetworkConnection:HandleBytes (byte[ ],int,int)
0x000000004F73673F (Mono JIT Code) [NetworkConnection.cs:576] UnityEngine.Networking.NetworkConnection:TransportReceive (byte[ ],int,int)
0x000000002D62A13F (Mono JIT Code) [NetworkClient.cs:753] UnityEngine.Networking.NetworkClient:Update ()
0x000000002D6293DD (Mono JIT Code) [NetworkClient.cs:965] UnityEngine.Networking.NetworkClient:UpdateClients ()
0x000000002D628FB4 (Mono JIT Code) [NetworkIdentity.cs:1091] UnityEngine.Networking.NetworkIdentity:UNetStaticUpdate ()
0x0000000006D00ADE (Mono JIT Code) (wrapper runtime-invoke) object:runtime_invoke_void (object,intptr,intptr,intptr)
0x00007FFDFFCC5B63 (mono) mono_set_defaults
0x00007FFDFFC1872D (mono) mono_runtime_invoke
0x00007FF6E3DAB3F4 (Quest)
0x00007FF6E3DA6101 (Quest)
0x00007FF6E3C2FD60 (Quest)
0x00007FF6E3BA90A1 (Quest)
0x00007FF6E34EBCF0 (Quest)
0x00007FF6E34EBE9A (Quest)
0x00007FF6E34FA454 (Quest)
0x00007FF6E48907D0 (Quest)
0x00007FFE37DC2774 (KERNEL32) BaseThreadInitThunk
0x00007FFE386C0D51 (ntdll) RtlUserThreadStart
(Filename: C:/buildslave/unity/build/artifacts/generated/common/runtime/DebugBindings.gen.cpp Line: 51)

I’m using Unity 2017.1.0f3 and building for Windows x86_64. The computer I’m using has Windows 10 (64-bit) on it. I’ve been working on this project since 2015 and have been upgrading it alongside Unity version updates as they come out. I’m just curious if this might be a bug with Unity or if its something on my end. Its a big project but I can try to provide more information if needed.

xVergilx · July 21, 2017, 6:20am

I think you’re trying to use SyncLists from somewhere when it’s not yet ready. E.g. Start or Awake, or something in that scope.

Since SyncLists cannot be used before server/client is ready you’re receiving this message;
On the disconnect topic - make sure you’re not running into 4kb/s Unet cap, that there isn’t memory leak somewhere, and message don’t get stuck in queue.

Kesarium · July 21, 2017, 1:13pm

My code for the client doesn’t do anything with the SyncListStruct if it is null, nor does the client try to read the variable further after the null reference check if its null. The client never tries to modify the SyncListStruct either, it only sends a command if the client wants to take an item out of the chest, which it doesn’t right at the joining of the client and server.

The server will populate that sharedItems SyncListStruct only when the network is set up and the host player has spawned in the game. The client never tries to add anything to that list and it never tries to clear it.

xVergilx · July 21, 2017, 1:37pm

You could, and should remove those checks, since in theory it’s never null. If you’re initializing it properly.

Kesarium · July 21, 2017, 2:04pm

This is the code from the LootShared.cs file, which is where I declare the Struct and initialize and use the SyncListStruct. The declaration has been moved around and modified different ways when working from some other forum search results but none of the proposed solutions solved this. The whole file might not be necessary but here it is anyway.

public class LootShared : NetworkBehaviour
{
    public struct SharedItem
    {
        public int ID;
        public string Title;
        public string Type;
        public string SubType;
        public string MaterialType;
        public int MaterialAmount;
        public int DurabilityMax;
        public int Durability;
        public int Value;
        public int ShopValue;
        public int Damage;
        public float AttackSpeed;
        public int Armor;
        public int Vitality;
        public int Stamina;
        public int Wisdom;
        public int Strength;
        public int Dexterity;
        public int Intelligence;
        public int HealthRegen;
        public int EnergyRegen;
        public int ManaRegen;
        public string Description;
        public string[] Special;
        public bool Stackable;
        public bool Consumable;
        public int Rarity;
        public bool RandomQuality;
        public string Slug;
        public int Quantity;
    };



    public class SyncListSharedItem : SyncListStruct<SharedItem> {}

    public SyncListSharedItem sharedItems = new SyncListSharedItem ();



    [SyncVar] public bool decaying;
    [SyncVar] public float decayTime;
    [SyncVar] public float decayTimer;



    public NetworkIdentity myNetworkIdentity;



    void Start()
    {
        if (this.transform.GetComponent<Enemy>() != null)
        {
            StartCoroutine(Countdown_Decay(1f));
        }
        else
        {
            if (this.transform.GetComponent<StaticChestHolder>() == null)
            {
                StartCoroutine (Countdown_Decay (decayTime));
            }
        }
    }



    IEnumerator Countdown_Decay(float DELAY)
    {
        yield return new WaitForSeconds(DELAY);

        if(this.transform.GetComponent<Enemy>() != null)
        {
            if(this.transform.GetComponent<Enemy>().isDead())
            {
                Decay();
            }
            else
            {
                StartCoroutine(Countdown_Decay(1f));
            }
        }
        else
        {
            Decay();
        }
    }



	public void Decay()
	{
		if (this != null)
		{
			if (this.gameObject.GetComponent<Enemy>() != null)
			{
				if (ClickToMove.myInventory.lootWindow.lootGameObject != null &&
					ClickToMove.myInventory.lootWindow.lootGameObject.GetInstanceID() == this.gameObject.GetInstanceID())
				{
					ClickToMove.myInventory.lootWindow.Close();
				}

				if (isServer)
				{
					decaying = false;
					decayTimer = 0f;

					if (sharedItems != null && sharedItems.Count > 0)
					{
						sharedItems.Clear ();
					}
				}
			}
			else if (this.gameObject.GetComponent<StaticResource>() != null)
			{

			}
			else
			{
				if (ClickToMove.myInventory.lootWindow.lootGameObject != null &&
					ClickToMove.myInventory.lootWindow.lootGameObject.GetInstanceID() == this.gameObject.GetInstanceID())
				{
					ClickToMove.myInventory.lootWindow.Close();
				}

				if (isServer)
				{
					NetworkServer.Destroy(this.gameObject);
					//Destroy(this.gameObject);
				}
			}
		}
	}



	void OnMouseOver()
	{
		if (Input.GetMouseButtonDown(1))
		{
			if (decaying)
			{
				if (this.gameObject.GetComponent<StaticResource>() == null && this.gameObject.GetComponent<Enemy>() == null)
				{
					if (!ClickToMove.mouseOverInventory && !ClickToMove.mouseOverEquipment && !ClickToMove.mouseOverStats && !ClickToMove.mouseOverSkills && !ClickToMove.mouseOverAbilities &&
						!ClickToMove.mouseOverInstructions && !ClickToMove.mouseOverTalents && !ClickToMove.mouseOverLoot && !ClickToMove.mouseOverShop &&
						!ClickToMove.mouseOverInventoryBar && !ClickToMove.mouseOverEquipmentBar && !ClickToMove.mouseOverStatsBar && !ClickToMove.mouseOverSkillsBar && !ClickToMove.mouseOverAbilitiesBar &&
						!ClickToMove.mouseOverInstructionsBar && !ClickToMove.mouseOverTalentsBar && !ClickToMove.mouseOverLootBar && !ClickToMove.mouseOverShopBar && !ClickToMove.openLoot && !ClickToMove.openShop)
					{
						Open_Loot_Window();
					}
				}
			}
		}
	}

	public void Open_Loot_Window()
	{
		if (!ClickToMove.myPlayer.isDead())
		{
			if(sharedItems != null && sharedItems.Count > 0)
			{
				if (Vector3.Distance(this.transform.position, ClickToMove.myPlayerGameObject.transform.position) <= 2f)
				{
					if (!ClickToMove.openLoot)
					{
						ClickToMove.myInventory.lootWindow.OpenWindow(this.gameObject);
						ClickToMove.mouseRightClickedLootSack = true;
					}
				}
			}
		}
	}



	public bool LootSelected(int index)
	{
		if(sharedItems != null && sharedItems.Count > 0)
		{
			if (ClickToMove.myInventory.AddNewItem(sharedItems[index]))
			{
				ClickToMove.myLootTextManager.Gain_Text_Item("PICKED UP:  ", sharedItems[index].Slug, sharedItems[index].Quantity, sharedItems[index].Title, sharedItems[index].Rarity);

				sharedItems.RemoveAt(index);



				if (sharedItems.Count == 0)
				{
					ClickToMove.myPlayer.DestroyDroppedItem(myNetworkIdentity.netId);
				}



				return true;
			}
		}



		return false;
	}

	public void LootAll()
	{
		ClickToMove.myPlayer.DestroyDroppedItem(myNetworkIdentity.netId);
	}



	public bool Looted()
	{
		if (sharedItems != null && sharedItems.Count > 0)
		{
			if (Vector3.Distance(this.transform.position, ClickToMove.myPlayerGameObject.transform.position) <= 1.5f)
			{
				if (!ClickToMove.openLoot)
				{
					ClickToMove.myInventory.lootWindow.OpenWindow(this.gameObject);

					return true;
				}
			}
		}

		return false;
	}



	public void Create_Item(Item ITEM)
	{
		SharedItem newItem = new SharedItem();

		newItem.ID = ITEM.ID;
		newItem.Title = ITEM.Title;
		newItem.Type = ITEM.Type;
		newItem.SubType = ITEM.SubType;
		newItem.MaterialType = ITEM.MaterialType;
		newItem.MaterialAmount = ITEM.MaterialAmount;
		newItem.DurabilityMax = ITEM.DurabilityMax;
		newItem.Durability = ITEM.Durability;
		newItem.Value = ITEM.Value;
		newItem.ShopValue = ITEM.ShopValue;
		newItem.Damage = ITEM.Damage;
		newItem.AttackSpeed = ITEM.AttackSpeed;
		newItem.Armor = ITEM.Armor;
		newItem.Vitality = ITEM.Vitality;
		newItem.Stamina = ITEM.Stamina;
		newItem.Wisdom = ITEM.Wisdom;
		newItem.Strength = ITEM.Strength;
		newItem.Dexterity = ITEM.Dexterity;
		newItem.Intelligence = ITEM.Intelligence;
		newItem.HealthRegen = ITEM.HealthRegen;
		newItem.EnergyRegen = ITEM.EnergyRegen;
		newItem.ManaRegen = ITEM.ManaRegen;
		newItem.Description = ITEM.Description;
		newItem.Special = ITEM.Special;
		newItem.Stackable = ITEM.Stackable;
		newItem.Consumable = ITEM.Consumable;
		newItem.Rarity = ITEM.Rarity;
		newItem.RandomQuality = ITEM.RandomQuality;
		newItem.Slug = ITEM.Slug;
		newItem.Quantity = ITEM.Quantity;

		sharedItems.Add (newItem);
	}

	public void Create_Item(ItemDrop ITEM)
	{
		SharedItem newItem = new SharedItem();

		newItem.ID = ITEM.ID;
		newItem.Title = ITEM.Title;
		newItem.Type = ITEM.Type;
		newItem.SubType = ITEM.SubType;
		newItem.MaterialType = ITEM.MaterialType;
		newItem.MaterialAmount = ITEM.MaterialAmount;
		newItem.DurabilityMax = ITEM.DurabilityMax;
		newItem.Durability = ITEM.Durability;
		newItem.Value = ITEM.Value;
		newItem.ShopValue = ITEM.ShopValue;
		newItem.Damage = ITEM.Damage;
		newItem.AttackSpeed = ITEM.AttackSpeed;
		newItem.Armor = ITEM.Armor;
		newItem.Vitality = ITEM.Vitality;
		newItem.Stamina = ITEM.Stamina;
		newItem.Wisdom = ITEM.Wisdom;
		newItem.Strength = ITEM.Strength;
		newItem.Dexterity = ITEM.Dexterity;
		newItem.Intelligence = ITEM.Intelligence;
		newItem.HealthRegen = ITEM.HealthRegen;
		newItem.EnergyRegen = ITEM.EnergyRegen;
		newItem.ManaRegen = ITEM.ManaRegen;
		newItem.Description = ITEM.Description;
		newItem.Special = ITEM.Special;
		newItem.Stackable = ITEM.Stackable;
		newItem.Consumable = ITEM.Consumable;
		newItem.Rarity = ITEM.Rarity;
		newItem.RandomQuality = ITEM.RandomQuality;
		newItem.Slug = ITEM.Slug;
		newItem.Quantity = ITEM.Quantity;

		sharedItems.Add (newItem);
	}

	public void Create_Item(SharedItem ITEM)
	{
		SharedItem newItem = new SharedItem();

		newItem.ID = ITEM.ID;
		newItem.Title = ITEM.Title;
		newItem.Type = ITEM.Type;
		newItem.SubType = ITEM.SubType;
		newItem.MaterialType = ITEM.MaterialType;
		newItem.MaterialAmount = ITEM.MaterialAmount;
		newItem.DurabilityMax = ITEM.DurabilityMax;
		newItem.Durability = ITEM.Durability;
		newItem.Value = ITEM.Value;
		newItem.ShopValue = ITEM.ShopValue;
		newItem.Damage = ITEM.Damage;
		newItem.AttackSpeed = ITEM.AttackSpeed;
		newItem.Armor = ITEM.Armor;
		newItem.Vitality = ITEM.Vitality;
		newItem.Stamina = ITEM.Stamina;
		newItem.Wisdom = ITEM.Wisdom;
		newItem.Strength = ITEM.Strength;
		newItem.Dexterity = ITEM.Dexterity;
		newItem.Intelligence = ITEM.Intelligence;
		newItem.HealthRegen = ITEM.HealthRegen;
		newItem.EnergyRegen = ITEM.EnergyRegen;
		newItem.ManaRegen = ITEM.ManaRegen;
		newItem.Description = ITEM.Description;
		newItem.Special = ITEM.Special;
		newItem.Stackable = ITEM.Stackable;
		newItem.Consumable = ITEM.Consumable;
		newItem.Rarity = ITEM.Rarity;
		newItem.RandomQuality = ITEM.RandomQuality;
		newItem.Slug = ITEM.Slug;
		newItem.Quantity = ITEM.Quantity;

		sharedItems.Add (newItem);
	}

Here is the code for another related .cs file, the ‘Spawner’ for the treasure chests, its really just the manager of the treasure chests. In here is where the treasure chests are ‘initialized’ and synchronized. The chests aren’t spawned over the network because I couldn’t get a custom OnSpawn method to get called when something was spawned. So I just use RPCs to enable or disable a chest from a pool of chests for clients.

public class StaticChestSpawner : NetworkBehaviour
{
    public GameObject[] pool;
    public StaticChestHolder[] pool_StaticChestHolders;

    public float[] pool_Timers;

    public int spawnPoints;

    private bool readyToInitialize;
    private bool initialized = false;
    private bool initializedPool = false;

    public NetworkIdentity myNetworkIdentity;



    public void Initialize()
    {
        if (!readyToInitialize)
        {
            if (ClickToMove.myPlayer != null)
            {
                readyToInitialize = true;
            }
        }

        if (!initialized && readyToInitialize)
        {
            pool_StaticChestHolders = new StaticChestHolder[pool.Length];
            for (int a = 0; a < pool.Length; a++)
            {
                pool_StaticChestHolders[a] = pool[a].GetComponent<StaticChestHolder>();
				pool_StaticChestHolders[a].myBoxCollider = pool_StaticChestHolders[a].myStaticChestGameObject.transform.GetComponent<BoxCollider> ();
            }

            

            if (isServer)
            {
                pool_Timers = new float[pool.Length];
                for (int a = 0; a < pool_Timers.Length; a++)
                {
                    pool_Timers[a] = 0f;
                }



                for (int a = 0; a < pool.Length; a++)
                {
                    pool_StaticChestHolders[a].myStaticChestScript.spawnPoolID = a;

                    if (spawnPoints >= pool_StaticChestHolders[a].myStaticChestScript.spawnPoints && Random.Range(0, 100) <= pool_StaticChestHolders[a].myStaticChestScript.spawnChance)
                    {
                        spawnPoints -= pool_StaticChestHolders[a].myStaticChestScript.spawnPoints;

                        pool_StaticChestHolders[a].Spawn();
						pool_StaticChestHolders[a].chestEnabled = true;
						pool_StaticChestHolders[a].myMeshRendererBox.enabled = true;
						pool_StaticChestHolders[a].myMeshRendererLid.enabled = true;
						pool_StaticChestHolders[a].myNavMeshObstacle.enabled = true;
						pool_StaticChestHolders[a].myBoxCollider.enabled = true;
                        CmdEnableChest(pool_StaticChestHolders[a].myStaticChestScript.spawnPoolID);
                    }
                    else
                    {
						//pool_StaticChestHolders[a].Spawn();
						pool_StaticChestHolders[a].chestEnabled = false;
						pool_StaticChestHolders[a].myMeshRendererBox.enabled = false;
						pool_StaticChestHolders[a].myMeshRendererLid.enabled = false;
						pool_StaticChestHolders[a].myNavMeshObstacle.enabled = false;
						pool_StaticChestHolders[a].myBoxCollider.enabled = false;
                        CmdDisableChest(pool_StaticChestHolders[a].myStaticChestScript.spawnPoolID);
                    }
                }
                


                initialized = true;
                initializedPool = true;
            }
            else
            {
				pool_Timers = new float[pool.Length];
				for (int a = 0; a < pool_Timers.Length; a++)
				{
					pool_Timers[a] = 0f;
				}

                for (int a = 0; a < pool.Length; a++)
                {
                    pool_StaticChestHolders[a].myStaticChestScript.spawnPoolID = a;
					pool_StaticChestHolders[a].myNavMeshObstacle.enabled = false;
                }

                initialized = true;
                initializedPool = true;

				GetPoolFromServer();
            }
        }

        if (!initialized)
        {
            StartCoroutine(Countdown_Loop_Initialize(1f));
        }
        else
        {
            if (isServer)
            {
                StartCoroutine(Countdown_Loop_UpdateSpawner(1f));
            }
        }
    }



    IEnumerator Countdown_Loop_Initialize(float DELAY)
    {
        yield return new WaitForSeconds(DELAY);

        Initialize();

        if (!initialized)
        {
            StartCoroutine(Countdown_Loop_UpdateSpawner(1f));
        }
    }

    IEnumerator Countdown_Loop_UpdateSpawner(float DELAY)
    {
        yield return new WaitForSeconds(DELAY);

        UpdateSpawner();

        StartCoroutine(Countdown_Loop_UpdateSpawner(1f));
    }



    private void UpdateSpawner ()
    {
        if(initialized)
        {
            for (int a = 0; a < pool.Length; a++)
            {
				if (pool_StaticChestHolders[a].chestEnabled)
                {
                    if (pool_StaticChestHolders[a].myStaticChestScript.lootings <= 0 &&
                        pool_StaticChestHolders[a].myStaticChestScript.fcMain.m_Lid.m_LidStatus == FCLid.eState.Close &&
                        !pool_StaticChestHolders[a].myStaticChestScript.fcMain.m_Lid.m_ChangingState)
                    {
                        spawnPoints += pool_StaticChestHolders[a].myStaticChestScript.spawnPoints;
                        pool_Timers[pool_StaticChestHolders[a].myStaticChestScript.spawnPoolID] = 0f;

                        CmdDisableChest(pool_StaticChestHolders[a].myStaticChestScript.spawnPoolID);
						pool_StaticChestHolders[a].chestEnabled = false;
						pool_StaticChestHolders[a].myMeshRendererBox.enabled = false;
						pool_StaticChestHolders[a].myMeshRendererLid.enabled = false;
						pool_StaticChestHolders[a].myNavMeshObstacle.enabled = false;
						pool_StaticChestHolders[a].myBoxCollider.enabled = false;
                    }
                }
            }



            for (int a = 0; a < pool_Timers.Length; a++)
            {
				if (!pool_StaticChestHolders[a].chestEnabled)
                {
                    pool_Timers[a] += 1f;
                }
            }



            if (spawnPoints > 0)
            {
                for (int a = 0; a < spawnPoints; a++)
                {
                    for (int b = 0; b < pool.Length; b++)
                    {
						if (!pool_StaticChestHolders[b].chestEnabled)
                        {
                            if (pool_Timers[b] >= pool_StaticChestHolders[b].myStaticChestScript.respawnTime)
                            {
                                if (spawnPoints >= pool_StaticChestHolders[b].myStaticChestScript.spawnPoints)
                                {
                                    if (Random.Range(0, 100) <= pool_StaticChestHolders[b].myStaticChestScript.spawnChance)
                                    {
                                        spawnPoints -= pool_StaticChestHolders[b].myStaticChestScript.spawnPoints;
										pool_StaticChestHolders[b].chestEnabled = true;
										pool_StaticChestHolders[b].myMeshRendererBox.enabled = true;
										pool_StaticChestHolders[b].myMeshRendererLid.enabled = true;
										pool_StaticChestHolders[b].myNavMeshObstacle.enabled = true;
										pool_StaticChestHolders[b].myBoxCollider.enabled = true;
                                        pool_StaticChestHolders[b].myStaticChestScript.Reset_Chest();
                                        CmdResetChest(pool_StaticChestHolders[b].myStaticChestScript.spawnPoolID);
                                        CmdEnableChest(pool_StaticChestHolders[b].myStaticChestScript.spawnPoolID);
                                        pool_Timers[b] = 0f;
                                        pool_StaticChestHolders[b].Respawn();
                                    }
                                    else
                                    {
                                        pool_Timers[b] = 0f;
                                    }
                                }
                                else
                                {
                                    pool_Timers[b] = 0f;
                                }
                            }
                        }
                    }
                }
            }
        }
	}



    void GetPoolFromServer()
    {
        ClickToMove.myPlayer.ClientRequestInitialStaticChestPool(myNetworkIdentity.netId, ClickToMove.myPlayer.myNetworkIdentity.netId);
    }

    public void SendPoolToClients()
    {
        for (int a = 0; a < pool.Length; a++)
        {
			if(pool_StaticChestHolders[a].chestEnabled)
            {
                //CmdEnableChest(pool[a].GetComponent<StaticChest>().spawnPoolID);
                Cmd_UpdateChest_Locked(pool_StaticChestHolders[a].myStaticChestScript.spawnPoolID, pool_StaticChestHolders[a].myStaticChestScript.locked);

                if(pool_StaticChestHolders[a].myStaticChestScript.fcMain.m_Lid.m_LidStatus == FCLid.eState.Open)
                {
                    Cmd_UpdateChest_Opened(pool_StaticChestHolders[a].myStaticChestScript.spawnPoolID, true);
                }
            }
            else
            {
                CmdDisableChest(pool_StaticChestHolders[a].myStaticChestScript.spawnPoolID);
            }
        }
    }

    [Command]
    public void CmdEnableChest(int INDEX)
    {
        RpcEnableChest(INDEX);
    }

    [Command]
    public void CmdDisableChest(int INDEX)
    {
        RpcDisableChest(INDEX);
    }

    [ClientRpc]
    void RpcEnableChest(int INDEX)
    {
        if (!isServer)
        {
            if (INDEX < pool.Length)
            {
				if(pool_StaticChestHolders[INDEX].myBoxCollider == null)
				{
					pool_StaticChestHolders[INDEX].myBoxCollider = pool_StaticChestHolders[INDEX].myStaticChestGameObject.transform.GetComponent<BoxCollider> ();
				}

				pool_StaticChestHolders[INDEX].chestEnabled = true;
				pool_StaticChestHolders[INDEX].myMeshRendererBox.enabled = true;
				pool_StaticChestHolders[INDEX].myMeshRendererLid.enabled = true;
				pool_StaticChestHolders[INDEX].myBoxCollider.enabled = true;
            }
            else
            {
                //Debug.Log("enable pool index: " + INDEX + " is out of bounds for pool: " + transform.name + "(" + pool.Length + ")");
            }
        }
    }

    [ClientRpc]
    void RpcDisableChest(int INDEX)
    {
        if (!isServer)
        {
            if (INDEX < pool.Length)
            {
				if(pool_StaticChestHolders[INDEX].myBoxCollider == null)
				{
					pool_StaticChestHolders[INDEX].myBoxCollider = pool_StaticChestHolders[INDEX].myStaticChestGameObject.transform.GetComponent<BoxCollider> ();
				}

				pool_StaticChestHolders[INDEX].chestEnabled = false;
				pool_StaticChestHolders[INDEX].myMeshRendererBox.enabled = false;
				pool_StaticChestHolders[INDEX].myMeshRendererLid.enabled = false;
				pool_StaticChestHolders[INDEX].myBoxCollider.enabled = false;
            }
            else
            {
                //Debug.Log("disable pool index: " + INDEX + " is out of bounds for pool: " + transform.name + "(" + pool.Length + ")");
            }
        }
    }

    [Command]
    public void CmdResetChest(int INDEX)
    {
        RpcResetChest(INDEX);
    }

    [ClientRpc]
    void RpcResetChest(int INDEX)
    {
        if (!isServer && initializedPool)
        {
            if (INDEX < pool.Length)
            {
                pool_StaticChestHolders[INDEX].myStaticChestScript.Reset_Chest();
            }
            else
            {
                //Debug.Log("enable pool index: " + INDEX + " is out of bounds for pool: " + transform.name + "(" + pool.Length + ")");
            }
        }
    }



    [Command]
    public void Cmd_UpdateChest_Opened(int INDEX, bool OPEN)
    {
        Rpc_UpdateChest_Opened(INDEX, OPEN);
    }

    [ClientRpc]
    void Rpc_UpdateChest_Opened(int INDEX, bool OPEN)
    {
        if (!isServer && initializedPool)
        {
            if (INDEX < pool.Length)
            {
                if (OPEN)
                {
                    pool_StaticChestHolders[INDEX].myStaticChestScript.fcMain.m_Lid.m_LidStatusOld = FCLid.eState.Open;
                    pool_StaticChestHolders[INDEX].myStaticChestScript.fcMain.m_Lid.Open();
                    pool_StaticChestHolders[INDEX].myStaticChestScript.fcMain.m_Lid.m_OpenValue = 1f;
                    pool_StaticChestHolders[INDEX].myStaticChestScript.fcMain.m_Lid.OpenLid();
                }
            }
            else
            {

            }
        }
    }



    [Command]
    public void Cmd_UpdateChest_Locked(int INDEX, bool LOCKED)
    {
        Rpc_UpdateChest_Locked(INDEX, LOCKED);
    }

    [ClientRpc]
    void Rpc_UpdateChest_Locked(int INDEX, bool LOCKED)
    {
        if (!isServer && initializedPool)
        {
            if (INDEX < pool.Length)
            {
                if (pool_StaticChestHolders[INDEX].myStaticChestScript.locked != LOCKED)
                {
                    pool_StaticChestHolders[INDEX].myStaticChestScript.locked = LOCKED;

                    if(!LOCKED)
                    {
                        pool_StaticChestHolders[INDEX].myStaticChestScript.fcMain.m_Lid.m_LockStatusOld = FCLid.eLockStatus.Free;
                        pool_StaticChestHolders[INDEX].myStaticChestScript.fcMain.Unlock();
                    }
                }
            }
            else
            {

            }
        }
    }



    [ClientRpc]
    public void Rpc_Unlock_Chest(int INDEX)
    {
        if (initializedPool)
        {
            if (INDEX < pool.Length)
            {
                pool_StaticChestHolders[INDEX].myStaticChestScript.locked = false;
                pool_StaticChestHolders[INDEX].myStaticChestScript.fcMain.Unlock();
            }
            else
            {

            }
        }
    }



    [ClientRpc]
    public void Rpc_Open_Chest(int INDEX)
    {
        if (initializedPool)
        {
            if (INDEX < pool.Length)
            {
                if (pool_StaticChestHolders[INDEX].myStaticChestScript.fcMain.m_Lid.m_LidStatus == FCLid.eState.Close)
                {
                    pool_StaticChestHolders[INDEX].myStaticChestScript.fcMain.Open();
                }
            }
            else
            {

            }
        }
    }



    [ClientRpc]
    public void Rpc_Close_Chest(int INDEX)
    {
        if (initializedPool)
        {
            if (INDEX < pool.Length)
            {
                if (pool_StaticChestHolders[INDEX].myStaticChestScript.fcMain.m_Lid.m_LidStatus == FCLid.eState.Open)
                {
                    pool_StaticChestHolders[INDEX].myStaticChestScript.fcMain.Close();

                    if (ClickToMove.myInventory.lootWindow.lootGameObject != null && ClickToMove.myInventory.lootWindow.lootGameObject == pool_StaticChestHolders[INDEX].myStaticChestGameObject)
                    {
                        ClickToMove.myInventory.lootWindow.Close();
                    }
                }
            }
            else
            {

            }
        }
    }



    [ClientRpc]
    public void Rpc_Update_LootWindow(int INDEX)
    {
        if (initializedPool)
        {
            if (INDEX < pool.Length)
            {
                if (ClickToMove.openLoot)
                {
                    if (ClickToMove.myInventory.lootWindow.lootGameObject != null && ClickToMove.myInventory.lootWindow.lootGameObject == pool_StaticChestHolders[INDEX].gameObject)
                    {
                        ClickToMove.myInventory.lootWindow.Update_Chest_Content();
                    }
                }
            }
            else
            {

            }
        }
    }
}

There is also a TreasureChest.cs file and a TreasureChestHolder.cs file where other things happen regarding the treasure chests.

Topic		Replies	Views
SyncListStruct: SyncList not initialized Unity Engine Multiplayer	22	11086	August 30, 2019
[Solved] Unity 2017.1.0f1 SyncListStruct fails to sync lists Unity Engine Multiplayer	5	2083	June 29, 2017
synclist not initialized Unity Engine Multiplayer	1	844	July 8, 2020
OnServerAddPlayer SyncList not initialized Unity Engine Multiplayer	3	1935	April 25, 2017
SyncLists are initialized, but I get Error message: "SyncList not initialized." Unity Engine Multiplayer	8	3619	November 21, 2015

SyncList not initialized

Related topics