Crow Score Updating

Assets/Prefabs/Abilities/VectorFencePrefab.prefab

@@ -136,7 +136,7 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: d5a57f767e5e46a458fc5d3c628d0cbb, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  GlobalObjectIdHash: 3892629208
+  GlobalObjectIdHash: 1554870052
   InScenePlacedSourceGlobalObjectIdHash: 0
   AlwaysReplicateAsRoot: 0
   SynchronizeTransform: 1

Assets/Scenes/BossRoom.unity

@@ -8893,11 +8893,11 @@ PrefabInstance:
       objectReference: {fileID: 0}
     - target: {fileID: 1676734515771252668, guid: 0193228de87741d40a42e561901c9083, type: 3}
       propertyPath: m_LocalRotation.w
-      value: 0.85294455
+      value: 0.8529446
       objectReference: {fileID: 0}
     - target: {fileID: 1676734515771252668, guid: 0193228de87741d40a42e561901c9083, type: 3}
       propertyPath: m_LocalRotation.x
-      value: 0.3943448
+      value: 0.39434478
       objectReference: {fileID: 0}
     - target: {fileID: 1676734515771252668, guid: 0193228de87741d40a42e561901c9083, type: 3}
       propertyPath: m_LocalRotation.y
@@ -8905,7 +8905,7 @@ PrefabInstance:
       objectReference: {fileID: 0}
     - target: {fileID: 1676734515771252668, guid: 0193228de87741d40a42e561901c9083, type: 3}
       propertyPath: m_LocalRotation.z
-      value: -0.14352979
+      value: -0.14352977
       objectReference: {fileID: 0}
     - target: {fileID: 1676734516302391364, guid: 0193228de87741d40a42e561901c9083, type: 3}
       propertyPath: m_UpdateMethod
@@ -9162,15 +9162,15 @@ PrefabInstance:
       objectReference: {fileID: 0}
     - target: {fileID: 203267159508449512, guid: 36b3ee75677a1544191c0ddaaadd8140, type: 3}
       propertyPath: m_LocalRotation.x
-      value: 0.39434484
+      value: 0.3943448
       objectReference: {fileID: 0}
     - target: {fileID: 203267159508449512, guid: 36b3ee75677a1544191c0ddaaadd8140, type: 3}
       propertyPath: m_LocalRotation.y
-      value: 0.3104465
+      value: 0.31044644
       objectReference: {fileID: 0}
     - target: {fileID: 203267159508449512, guid: 36b3ee75677a1544191c0ddaaadd8140, type: 3}
       propertyPath: m_LocalRotation.z
-      value: -0.1435298
+      value: -0.14352976
       objectReference: {fileID: 0}
     - target: {fileID: 203267159508449512, guid: 36b3ee75677a1544191c0ddaaadd8140, type: 3}
       propertyPath: m_LocalEulerAnglesHint.x
@@ -9842,7 +9842,7 @@ MonoBehaviour:
   m_EditorClassIdentifier: 
   timer: {fileID: 1521032483}
   serverAdditiveSceneLoader: {fileID: 3765979715153886893}
-  timeInSeconds: 20
+  timeInSeconds: 120
 --- !u!1 &1527274045
 GameObject:
   m_ObjectHideFlags: 0

Assets/Scripts/Gameplay/PlatformManager.cs

@@ -31,7 +31,6 @@ namespace Unity.Multiplayer.Samples.BossRoom
             {
                 m_Platforms = GetComponentsInChildren<Platform>().ToList();
 
-                // Assign unique IDs to each platform
                 for (int i = 0; i < m_Platforms.Count; i++)
                 {
                     m_Platforms[i].AssignID(i + 1); // IDs start from 1
@@ -43,44 +42,22 @@ namespace Unity.Multiplayer.Samples.BossRoom
         }
         void Starter()
         {
-            numberOfPlayers = PlayerPrefs.GetInt("NumberOfLobbyPlayers");
+            int platformsToSpawn = PlayerPrefs.GetInt("NumberOfLobbyPlayers") - 1;
-            int platformsToSpawn = numberOfPlayers - 1;
+            if (platformsToSpawn <= 0) return;
 
-            if (platformsToSpawn <= 0)
+            m_Platforms.ForEach(platform => platform.gameObject.SetActive(false));
-            {
+            for (int i = 0; i < platformsToSpawn; i++) m_Platforms[i].gameObject.SetActive(true);
-                Debug.LogWarning("Not enough players to spawn platforms.");
+            m_Platforms = m_Platforms.Where(p => p.gameObject.activeInHierarchy).ToList();
-                return;
-            }
-            for(int i=0;i < m_Platforms.Count;i++)
-            {
-                m_Platforms[i].gameObject.SetActive(false);
-            }
-            for(int i=0;i<platformsToSpawn;i++)
-            {
-                m_Platforms[i].gameObject.SetActive(true);
-            }
-            float angleIncrement = 360f / platformsToSpawn; // Divide the circle into equal segments
 
+            float angleIncrement = 360f / platformsToSpawn;
             for (int i = 0; i < platformsToSpawn; i++)
-            {
+                m_Platforms[i].transform.position = new Vector3(
-                // Calculate angle in radians
+                    Mathf.Cos(i * angleIncrement * Mathf.Deg2Rad) * planeRadius,
-                float angle = i * angleIncrement * Mathf.Deg2Rad;
+                    0f,
-
+                    Mathf.Sin(i * angleIncrement * Mathf.Deg2Rad) * planeRadius
-                // Determine the position on the circular plane
-                Vector3 position = new Vector3(
-                    Mathf.Cos(angle) * planeRadius,
-                    0f, // Assume the circular plane is on the XZ plane
-                    Mathf.Sin(angle) * planeRadius
                 );
-
-                // Instantiate the platform
-                m_Platforms[i].transform.position = position;
-                m_Platforms[i].gameObject.SetActive(true);
-                //m_Platforms[i].AnimationStarter();
-
-                //Instantiate(platformPrefab, position, Quaternion.identity);
-            }
         }
+
         public Platform FindNearestUnoccupiedPlatform(Vector3 position)
         {
             if (!IsServer)

Assets/Scripts/Gameplay/PlayerScoreComponent.cs

@@ -35,9 +35,8 @@ public class PlayerScoreComponent : NetworkBehaviour
         // Update the player's score display in the UI.
         Debug.Log($"[PlayerScoreComponent] Updated score UI for Player {OwnerClientId}: {CurrentScore}");
     }
-    private void OnDestroy()
+    //private void OnDestroy()
-    {
+    //{
-        Destroy(playerItem.gameObject);
+    //    Destroy(playerItem.gameObject);
-        Scoreboard.instance.DestroyChecker();
+    //}
-    }
 }

Assets/Scripts/Gameplay/ScoreManager.cs

@@ -25,22 +25,26 @@ public class ScoreManager : NetworkBehaviour
     {
         if (IsServer)
         {
+            //foreach (var clientId in NetworkManager.Singleton.ConnectedClientsIds)
+            //{
+            //    //InitializePlayerScoreServerRpc(clientId, $"Player_{clientId}");
+            //    InitializePlayerScoreServerRpc(clientId, player");
+            //}
             StartCrowPenaltyCoroutineServerRpc();
         }
     }
 
     [ServerRpc(RequireOwnership = false)]
-    public void InitializePlayerScoreServerRpc(ulong ownerClientId,string name)
+    public void InitializePlayerScoreServerRpc(ulong ownerClientId, string name)
     {
         if (!playerScores.ContainsKey(ownerClientId))
         {
             playerScores[ownerClientId] = 200;
-            Debug.Log($"[ScoreManager] Player {ownerClientId} initialized with a starting score of 200.");
+            playerNames[ownerClientId] = name;
-            UpdatePlayerScoreClientRpc(ownerClientId, 200);
-            playerNames[ownerClientId]= name;
-
-            Scoreboard.instance.ScoreBoardItemInitializer(ownerClientId, playerScores[ownerClientId],name);
 
+            Debug.Log($"[ScoreManager] Player {ownerClientId} initialized with a starting score of 200 and name '{name}'.");
+            Scoreboard.instance.ScoreBoardItemInitializer(ownerClientId, playerScores[ownerClientId], name);
+            UpdatePlayerScoreClientRpc(ownerClientId, 200);
         }
         else
         {
@@ -48,13 +52,11 @@ public class ScoreManager : NetworkBehaviour
         }
     }
 
-
     public void UpdatePlayerScore(ulong ownerClientId, int newScore)
     {
         if (playerScores.ContainsKey(ownerClientId))
         {
             playerScores[ownerClientId] = newScore;
-            Scoreboard.instance.ScoreBoardUpdater(ownerClientId, newScore);
             Debug.Log($"[ScoreManager] Updating Player {ownerClientId} score to {newScore}.");
             UpdatePlayerScoreClientRpc(ownerClientId, newScore);
         }
@@ -64,44 +66,37 @@ public class ScoreManager : NetworkBehaviour
         }
     }
 
-    public void AddPlayerScore(ulong ownerClientId, int newScore)
+    [ClientRpc]
+    public void UpdatePlayerScoreClientRpc(ulong ownerClientId, int newScore)
     {
-        if (playerScores.ContainsKey(ownerClientId))
+        if (playerNames.ContainsKey(ownerClientId))
         {
-            playerScores[ownerClientId] += newScore;
+            string playerName = playerNames[ownerClientId];
-            Debug.Log($"[ScoreManager] Updating Player {ownerClientId} score to {playerScores[ownerClientId]}.");
+            Debug.Log($"[ScoreManager] Received score update for Player {ownerClientId} (Name: {playerName}): {newScore}");
-            UpdatePlayerScoreClientRpc(ownerClientId, playerScores[ownerClientId]);
+            Scoreboard.instance.ScoreBoardUpdater(playerName, newScore);
         }
         else
         {
-            Debug.LogError($"[ScoreManager] No entry found for Player {ownerClientId}. Cannot update score.");
+            Debug.LogError($"[ScoreManager] Player name not found for Player {ownerClientId}. Cannot update scoreboard.");
         }
     }
 
-    public void SubtractPlayerScore(ulong ownerClientId, int scoreToSubtract)
+    public void AddPlayerScore(ulong ownerClientId, int scoreToAdd)
     {
         if (playerScores.ContainsKey(ownerClientId))
         {
-            int value = Mathf.Max(0, playerScores[ownerClientId] - scoreToSubtract);
+            playerScores[ownerClientId] += scoreToAdd;
-            playerScores[ownerClientId] = value;
+            UpdatePlayerScore(ownerClientId, playerScores[ownerClientId]);
-            Debug.Log($"[ScoreManager] Updating Player {ownerClientId} score to {playerScores[ownerClientId]}.");
-            UpdatePlayerScoreClientRpc(ownerClientId, playerScores[ownerClientId]);
-        }
-        else
-        {
-            Debug.LogError($"[ScoreManager] No entry found for Player {ownerClientId}. Cannot update score.");
         }
     }
 
-
+    public void SubtractPlayerScore(ulong ownerClientId, int scoreToSubtract)
-    public int GetPlayerScore(ulong ownerClientId)
     {
-        if (playerScores.TryGetValue(ownerClientId, out var score))
+        if (playerScores.ContainsKey(ownerClientId))
         {
-            return score;
+            int newScore = Mathf.Max(0, playerScores[ownerClientId] - scoreToSubtract);
+            UpdatePlayerScore(ownerClientId, newScore);
         }
-        Debug.LogError($"[ScoreManager] No entry found for Player {ownerClientId}.");
-        return 0; // Default score
     }
 
     [ServerRpc]
@@ -113,61 +108,198 @@ public class ScoreManager : NetworkBehaviour
     private IEnumerator ApplyCrowPenaltyCoroutine()
     {
         yield return new WaitUntil(() => PlatformManager.Instance != null && PlatformManager.Instance.AreAllPlatformsOccupied());
+
         while (true)
         {
-            var modifications = new List<KeyValuePair<ulong, int>>();
-
             foreach (var entry in playerScores)
             {
-                var ownerClientId = entry.Key;
+                ulong ownerClientId = entry.Key;
-                var score = entry.Value;
+                int currentScore = entry.Value;
 
-                // Check if the player is the crow
                 if (CrowManager.Instance != null && CrowManager.Instance.GetCurrentCrow().OwnerClientId == ownerClientId)
                 {
-                    var newScore = score - 2;
+                    int newScore = currentScore - 2;
-                    modifications.Add(new KeyValuePair<ulong, int>(ownerClientId, newScore));
+                    SubtractPlayerScore(ownerClientId, 2);
                     Debug.Log($"[ScoreManager] Applied crow penalty to Player {ownerClientId}. New score: {newScore}");
                 }
             }
-
-            // Apply the modifications after the iteration
-            foreach (var modification in modifications)
-            {
-                UpdatePlayerScore(modification.Key, modification.Value);
-            }
-
-            // Wait for the next penalty application
             yield return new WaitForSeconds(5f);
         }
     }
+}
 
-    [ClientRpc]
-    public void UpdatePlayerScoreClientRpc(ulong ownerClientId, int newScore)
-    {
-        Debug.Log($"[ScoreManager] Received score update for Player {ownerClientId}: {newScore}");
-        var playerScoreComponent = FindPlayerScoreComponent(ownerClientId);
-        if (playerScoreComponent != null)
-        {
-            playerScoreComponent.UpdateScore(newScore);
-        }
-        else
-        {
-            Debug.LogError($"[ScoreManager] Could not find PlayerScoreComponent for Player {ownerClientId}");
-        }
-    }
 
+//using System.Collections;
+//using System.Collections.Generic;
+//using Unity.Multiplayer.Samples.BossRoom;
+//using UnityEngine;
+//using Unity.Netcode;
 
-    private PlayerScoreComponent FindPlayerScoreComponent(ulong ownerClientId)
+//public class ScoreManager : NetworkBehaviour
-    {
+//{
-        foreach (var scoreComponent in FindObjectsOfType<PlayerScoreComponent>())
+//    public static ScoreManager Instance { get; private set; }
-        {
+
-            if (scoreComponent.OwnerClientId == ownerClientId)
+//    public Dictionary<ulong, int> playerScores = new Dictionary<ulong, int>();
-            {
+//    public Dictionary<ulong, string> playerNames = new Dictionary<ulong, string>();
-                return scoreComponent;
+
-            }
+//    private void Awake()
-        }
+//    {
-        Debug.LogError($"[ScoreManager] Could not find PlayerScoreComponent for Player {ownerClientId}");
+//        if (Instance != null && Instance != this)
-        return null;
+//        {
-    }
+//            Destroy(gameObject);
-}
+//            return;
+//        }
+//        Instance = this;
+//    }
+
+//    public override void OnNetworkSpawn()
+//    {
+//        if (IsServer)
+//        {
+//            StartCrowPenaltyCoroutineServerRpc();
+//        }
+//    }
+
+//    [ServerRpc(RequireOwnership = false)]
+//    public void InitializePlayerScoreServerRpc(ulong ownerClientId,string name)
+//    {
+//        if (!playerScores.ContainsKey(ownerClientId))
+//        {
+//            playerScores[ownerClientId] = 200;
+//            Debug.Log($"[ScoreManager] Player {ownerClientId} initialized with a starting score of 200.");
+//            UpdatePlayerScoreClientRpc(ownerClientId, 200);
+//            playerNames[ownerClientId]= name;
+
+//            Scoreboard.instance.ScoreBoardItemInitializer(ownerClientId, playerScores[ownerClientId],name);
+
+//        }
+//        else
+//        {
+//            Debug.LogWarning($"[ScoreManager] Player {ownerClientId} already initialized.");
+//        }
+//    }
+
+
+//    public void UpdatePlayerScore(ulong ownerClientId, int newScore)
+//    {
+//        if (playerScores.ContainsKey(ownerClientId))
+//        {
+//            playerScores[ownerClientId] = newScore;
+//            Debug.Log($"[ScoreManager] Updating Player {ownerClientId} score to {newScore}.");
+//            UpdatePlayerScoreClientRpc(ownerClientId, newScore);
+//        }
+//        else
+//        {
+//            Debug.LogError($"[ScoreManager] No entry found for Player {ownerClientId}. Cannot update score.");
+//        }
+//    }
+
+//    public void AddPlayerScore(ulong ownerClientId, int newScore)
+//    {
+//        if (playerScores.ContainsKey(ownerClientId))
+//        {
+//            playerScores[ownerClientId] += newScore;
+//            Debug.Log($"[ScoreManager] Updating Player {ownerClientId} score to {playerScores[ownerClientId]}.");
+//            UpdatePlayerScoreClientRpc(ownerClientId, playerScores[ownerClientId]);
+//        }
+//        else
+//        {
+//            Debug.LogError($"[ScoreManager] No entry found for Player {ownerClientId}. Cannot update score.");
+//        }
+//    }
+
+//    public void SubtractPlayerScore(ulong ownerClientId, int scoreToSubtract)
+//    {
+//        if (playerScores.ContainsKey(ownerClientId))
+//        {
+//            int value = Mathf.Max(0, playerScores[ownerClientId] - scoreToSubtract);
+//            playerScores[ownerClientId] = value;
+//            Debug.Log($"[ScoreManager] Updating Player {ownerClientId} score to {playerScores[ownerClientId]}.");
+//            UpdatePlayerScoreClientRpc(ownerClientId, playerScores[ownerClientId]);
+//        }
+//        else
+//        {
+//            Debug.LogError($"[ScoreManager] No entry found for Player {ownerClientId}. Cannot update score.");
+//        }
+//    }
+
+
+//    public int GetPlayerScore(ulong ownerClientId)
+//    {
+//        if (playerScores.TryGetValue(ownerClientId, out var score))
+//        {
+//            return score;
+//        }
+//        Debug.LogError($"[ScoreManager] No entry found for Player {ownerClientId}.");
+//        return 0; // Default score
+//    }
+
+//    [ServerRpc]
+//    public void StartCrowPenaltyCoroutineServerRpc()
+//    {
+//        StartCoroutine(ApplyCrowPenaltyCoroutine());
+//    }
+
+//    private IEnumerator ApplyCrowPenaltyCoroutine()
+//    {
+//        yield return new WaitUntil(() => PlatformManager.Instance != null && PlatformManager.Instance.AreAllPlatformsOccupied());
+//        while (true)
+//        {
+//            var modifications = new List<KeyValuePair<ulong, int>>();
+
+//            foreach (var entry in playerScores)
+//            {
+//                var ownerClientId = entry.Key;
+//                var score = entry.Value;
+
+//                // Check if the player is the crow
+//                if (CrowManager.Instance != null && CrowManager.Instance.GetCurrentCrow().OwnerClientId == ownerClientId)
+//                {
+//                    var newScore = score - 2;
+//                    modifications.Add(new KeyValuePair<ulong, int>(ownerClientId, newScore));
+//                    Debug.Log($"[ScoreManager] Applied crow penalty to Player {ownerClientId}. New score: {newScore}");
+//                }
+//            }
+
+//            // Apply the modifications after the iteration
+//            foreach (var modification in modifications)
+//            {
+//                UpdatePlayerScore(modification.Key, modification.Value);
+//            }
+
+//            // Wait for the next penalty application
+//            yield return new WaitForSeconds(5f);
+//        }
+//    }
+
+//    [ClientRpc]
+//    public void UpdatePlayerScoreClientRpc(ulong ownerClientId, int newScore)
+//    {
+//        Debug.Log($"[ScoreManager] Received score update for Player {ownerClientId}: {newScore}");
+//        Scoreboard.instance.ScoreBoardUpdater(playerNames[ownerClientId], newScore);
+
+//        var playerScoreComponent = FindPlayerScoreComponent(ownerClientId);
+//        if (playerScoreComponent != null)
+//        {
+//            playerScoreComponent.UpdateScore(newScore);
+//        }
+//        else
+//        {
+//            Debug.LogError($"[ScoreManager] Could not find PlayerScoreComponent for Player {ownerClientId}");
+//        }
+//    }
+
+
+//    private PlayerScoreComponent FindPlayerScoreComponent(ulong ownerClientId)
+//    {
+//        foreach (var scoreComponent in FindObjectsOfType<PlayerScoreComponent>())
+//        {
+//            if (scoreComponent.OwnerClientId == ownerClientId)
+//            {
+//                return scoreComponent;
+//            }
+//        }
+//        Debug.LogError($"[ScoreManager] Could not find PlayerScoreComponent for Player {ownerClientId}");
+//        return null;
+//    }
+//}

Assets/Scripts/Gameplay/Scoreboard.cs

@@ -2,158 +2,77 @@ using System.Collections;
 using System.Collections.Generic;
 using Unity.Multiplayer.Samples.BossRoom;
 using UnityEngine;
-using Unity.BossRoom.Gameplay.GameState;
 using Unity.Netcode;
-using VContainer.Unity;
 
 public class Scoreboard : NetworkBehaviour
 {
-    public List<PlayerScoreComponent> m_PlayerScoreComponents;
+    public List<PlayerItem> playerItems = new();
-    public List<PlayerItem> playerItems;
     public GameObject playerItemPrefab;
-    public Transform Parent;
+    public Transform Parent, FinalParent;
-    public Transform FinalParent;
-    int index = 0;
-    bool coroutineStarter = false;
-    public static Scoreboard instance;
     public GameObject FinalLeaderBoardObj;
+    public static Scoreboard instance;
+    private bool coroutineStarter = false;
 
-    private void Awake()
+    private void Awake() => instance = this;
+    public void ScoreBoardItemInitializer(ulong clientId, int score, string name)
     {
-        instance = this;
+        if (IsServer) ScoreBoardItemInitializerClientRpc(clientId, score, name);
-    }
-
-    public void DestroyChecker()
-    {
-        for (int i = 0; i < m_PlayerScoreComponents.Count; i++)
-        {
-            if (m_PlayerScoreComponents[i] == null)
-            {
-                m_PlayerScoreComponents.RemoveAt(i);
-            }
-        }
-        for (int i = 0; i < playerItems.Count; i++)
-        {
-            if (playerItems[i] == null)
-            {
-                playerItems.RemoveAt(i);
-            }
-        }
-    }
-    public void ScoreBoardListFiller(NetworkObject playerObj)
-    {
-        if (IsServer)
-        {
-            ulong clientId = playerObj.OwnerClientId;
-            int initialScore = ScoreManager.Instance.GetPlayerScore(clientId);
-            m_PlayerScoreComponents.Add(playerObj.GetComponent<PlayerScoreComponent>());
-            m_PlayerScoreComponents[m_PlayerScoreComponents.Count - 1].m_index = index;
-
-            // Synchronize across clients
-            InstantiatePlayerItemClientRpc(index, clientId, initialScore);
-
-            index++;
-        }
     }
     [ClientRpc]
-    public void InstantiatePlayerItemClientRpc(int index, ulong clientId, int currentScore)
+    public void ScoreBoardItemInitializerClientRpc(ulong clientId, int score, string name)
     {
-        GameObject temp = Instantiate(playerItemPrefab, Parent);
+        var item = Instantiate(playerItemPrefab, Parent).GetComponent<PlayerItem>();
-        PlayerItem item = temp.GetComponent<PlayerItem>();
+        item.PlayerName.text = name;
-        item.PlayerName.text = clientId.ToString();
+        item.PlayerScore.text = score.ToString();
-        item.PlayerScore.text = currentScore.ToString();
         playerItems.Add(item);
     }
-    [ClientRpc]
+    public void ScoreBoardUpdater(string playerName, int score)
-    public void ScoreBoardItemInitializerClientRpc(ulong id, int score,string name)
     {
-        playerItems.Add(Instantiate(playerItemPrefab, Parent).GetComponent<PlayerItem>());
+        if (IsServer) ScoreBoardUpdaterClientRpc(playerName, score);
-        playerItems[^1].PlayerName.text = name.ToString();
-        playerItems[^1].PlayerScore.text = score.ToString();
     }
-    public void ScoreBoardItemInitializer(ulong id, int score,string name)
+    [ClientRpc]
-    {
+    public void ScoreBoardUpdaterClientRpc(string playerName, int score, ClientRpcParams clientRpcParams = default)
-        if (IsServer)
-        {
-            ScoreBoardItemInitializerClientRpc(id, score,name); // Send to clients
-        }
-    }
-     [ClientRpc]
-    public void ScoreBoardUpdaterClientRpc(ulong id, int score)
     {
-        for (int i = 0; i < playerItems.Count; i++)
+        foreach (var item in playerItems)
         {
-            if (playerItems[i].PlayerName.text == id.ToString())
+            if (item.PlayerName.text == playerName)
             {
-                playerItems[i].PlayerScore.text = score.ToString();
+                item.PlayerScore.text = score.ToString();
+                break;
             }
         }
+        SortAndUpdateScoreboard();
     }
     public void FinalLeaderBoard()
     {
-        Debug.Log("FinalLeaderBoard");
+        if (IsServer) FinalLeaderBoardClientRPC();
-        if (IsServer)
-        {
-            FinalLeaderBoardClientRPC();
-        }
     }
     [ClientRpc]
     public void FinalLeaderBoardClientRPC()
     {
-        for (int i = 0; i < playerItems.Count; i++)
+        playerItems.ForEach(item => Instantiate(item.gameObject, FinalParent));
-        {
-            Instantiate(playerItems[i], FinalParent);
-        }
         FinalLeaderBoardObj.SetActive(true);
     }
-    public void ScoreBoardUpdater(ulong id, int score)
+    private void SortAndUpdateScoreboard()
-    {
-        if (IsServer)
-        {
-            ScoreBoardUpdaterClientRpc(id, score); // Send to all clients
-        }
-    }
-    public void Starter()
     {
-        // Start the coroutine for updating the scores
+        playerItems.Sort((p1, p2) => int.Parse(p2.PlayerScore.text).CompareTo(int.Parse(p1.PlayerScore.text)));
-        StartCoroutine(ScoreUpdater());
+        for (int i = 0; i < playerItems.Count; i++) playerItems[i].transform.SetSiblingIndex(i);
     }
-
+    public void StartScoreUpdater()
-    public void Instantiator(int index)
     {
-        // Only instantiate UI elements on the client side
+        if (!coroutineStarter)
-        if (!NetworkManager.Singleton.IsClient)
         {
-            Debug.LogError("Instantiator called on server, should be on client");
+            coroutineStarter = true;
-            return;
+            StartCoroutine(ScoreUpdater());
         }
-
-        Debug.Log("Instantiator called on client");
-
-        GameObject temp = Instantiate(playerItemPrefab, Parent);
-        PlayerItem item = temp.GetComponent<PlayerItem>();
-        m_PlayerScoreComponents[m_PlayerScoreComponents.Count - 1].playerItem = item;
-        playerItems.Add(item);
-
-        playerItems[playerItems.Count - 1].PlayerScore.text = m_PlayerScoreComponents[index].CurrentScore.ToString();
-        playerItems[playerItems.Count - 1].PlayerName.text = m_PlayerScoreComponents[index].serverCharacter.uIStateDisplayHandler.m_UIState.playerName.ToString();
     }
-
+    private IEnumerator ScoreUpdater()
-    IEnumerator ScoreUpdater()
     {
-        //yield return new WaitForSeconds(0.5f);
+        yield return new WaitUntil(() => coroutineStarter);
-        Debug.Log("Scoreboard Start - ScoreUpdater started");
-        yield return new WaitUntil(() => coroutineStarter == true);
         while (true)
         {
-            if (IsOwner)
+            SortAndUpdateScoreboard();
-            {
+            yield return new WaitForSeconds(0.5f);
-                yield return new WaitForSeconds(0.1f);
-                //m_PlayerScoreComponents.Sort((p1, p2) => p2.CurrentScore.CompareTo(p1.CurrentScore));
-                playerItems.Sort((p1, p2) => p2.PlayerScore.GetParsedText().CompareTo(p1.PlayerScore.GetParsedText()));
-                for (int i = 0; i < playerItems.Count; i++)
-                    playerItems[i].transform.SetSiblingIndex(m_PlayerScoreComponents[i].m_index);
-            }
         }
     }
 }