You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
332 lines
11 KiB
C#
332 lines
11 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using Unity.Multiplayer.Samples.BossRoom;
|
|
using UnityEngine;
|
|
using Unity.Netcode;
|
|
using Unity.Collections;
|
|
|
|
public class ScoreManager : NetworkBehaviour
|
|
{
|
|
public static ScoreManager Instance { get; private set; }
|
|
|
|
// Use a NetworkList to store PlayerData
|
|
private NetworkList<PlayerData> playerDataList = new NetworkList<PlayerData>();
|
|
|
|
// NetworkVariable to sync scores (key: clientId, value: score)
|
|
private NetworkVariable<SerializableDictionary<ulong, int>> playerScores =
|
|
new NetworkVariable<SerializableDictionary<ulong, int>>(new SerializableDictionary<ulong, int>());
|
|
|
|
[System.Serializable]
|
|
public struct PlayerData : System.IEquatable<PlayerData>
|
|
{
|
|
public ulong ClientId;
|
|
public FixedString64Bytes Name;
|
|
|
|
public bool Equals(PlayerData other)
|
|
{
|
|
return ClientId == other.ClientId && Name.Equals(other.Name);
|
|
}
|
|
|
|
public override bool Equals(object obj)
|
|
{
|
|
return obj is PlayerData other && Equals(other);
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
unchecked
|
|
{
|
|
int hash = 17;
|
|
hash = hash * 31 + ClientId.GetHashCode();
|
|
hash = hash * 31 + Name.GetHashCode();
|
|
return hash;
|
|
}
|
|
}
|
|
|
|
public static bool operator ==(PlayerData left, PlayerData right)
|
|
{
|
|
return left.Equals(right);
|
|
}
|
|
|
|
public static bool operator !=(PlayerData left, PlayerData right)
|
|
{
|
|
return !(left == right);
|
|
}
|
|
}
|
|
|
|
private void Awake()
|
|
{
|
|
if (Instance != null && Instance != this)
|
|
{
|
|
Destroy(gameObject);
|
|
return;
|
|
}
|
|
Instance = this;
|
|
}
|
|
|
|
public override void OnNetworkSpawn()
|
|
{
|
|
if (IsServer)
|
|
{
|
|
StartCrowPenaltyCoroutine();
|
|
}
|
|
|
|
if (IsClient)
|
|
{
|
|
playerDataList.OnListChanged += OnPlayerDataListChanged;
|
|
playerScores.OnValueChanged += OnPlayerScoresChanged;
|
|
}
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
if (IsClient)
|
|
{
|
|
playerDataList.OnListChanged -= OnPlayerDataListChanged;
|
|
playerScores.OnValueChanged -= OnPlayerScoresChanged;
|
|
}
|
|
}
|
|
|
|
[ServerRpc(RequireOwnership = false)]
|
|
public void InitializePlayerScoreServerRpc(ulong ownerClientId, string name)
|
|
{
|
|
if (string.IsNullOrEmpty(name))
|
|
{
|
|
Debug.LogWarning($"[ScoreManager] Player name for Client {ownerClientId} is null or empty. Assigning default name.");
|
|
name = $"Player {ownerClientId}"; // Default name
|
|
}
|
|
|
|
var fixedName = new FixedString64Bytes(name); // Convert to FixedString
|
|
if (!playerScores.Value.ContainsKey(ownerClientId))
|
|
{
|
|
// Add initial score and name to the server-side collections
|
|
playerScores.Value[ownerClientId] = 200;
|
|
playerDataList.Add(new PlayerData { ClientId = ownerClientId, Name = fixedName });
|
|
|
|
Debug.Log($"[ScoreManager] Player {ownerClientId} initialized with a starting score of 200 and name '{fixedName}'.");
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning($"[ScoreManager] Player {ownerClientId} already initialized.");
|
|
}
|
|
}
|
|
|
|
public void AddPlayerScore(ulong ownerClientId, int scoreToAdd)
|
|
{
|
|
if (IsServer && playerScores.Value.ContainsKey(ownerClientId))
|
|
{
|
|
playerScores.Value[ownerClientId] += scoreToAdd;
|
|
Debug.Log($"[ScoreManager] Added {scoreToAdd} points to Player {ownerClientId}. New score: {playerScores.Value[ownerClientId]}.");
|
|
}
|
|
}
|
|
|
|
public void SubtractPlayerScore(ulong ownerClientId, int scoreToSubtract)
|
|
{
|
|
if (IsServer && playerScores.Value.ContainsKey(ownerClientId))
|
|
{
|
|
int currentScore = playerScores.Value[ownerClientId];
|
|
playerScores.Value[ownerClientId] = Mathf.Max(0, currentScore - scoreToSubtract);
|
|
Debug.Log($"[ScoreManager] Subtracted {scoreToSubtract} points from Player {ownerClientId}. New score: {playerScores.Value[ownerClientId]}.");
|
|
}
|
|
}
|
|
|
|
private void StartCrowPenaltyCoroutine()
|
|
{
|
|
StartCoroutine(ApplyCrowPenaltyCoroutine());
|
|
}
|
|
|
|
private IEnumerator ApplyCrowPenaltyCoroutine()
|
|
{
|
|
yield return new WaitUntil(() => PlatformManager.Instance != null && PlatformManager.Instance.AreAllPlatformsOccupied());
|
|
|
|
while (true)
|
|
{
|
|
foreach (var entry in playerScores.Value)
|
|
{
|
|
ulong ownerClientId = entry.Key;
|
|
if (CrowManager.Instance != null && CrowManager.Instance.GetCurrentCrow().OwnerClientId == ownerClientId)
|
|
{
|
|
SubtractPlayerScore(ownerClientId, 2);
|
|
Debug.Log($"[ScoreManager] Applied crow penalty to Player {ownerClientId}. New score: {playerScores.Value[ownerClientId]}.");
|
|
}
|
|
}
|
|
|
|
yield return new WaitForSeconds(5f);
|
|
}
|
|
}
|
|
|
|
private void OnPlayerDataListChanged(NetworkListEvent<PlayerData> changeEvent)
|
|
{
|
|
if (changeEvent.Type == NetworkListEvent<PlayerData>.EventType.Add)
|
|
{
|
|
var newData = changeEvent.Value;
|
|
string playerName = newData.Name.ToString(); // Convert FixedString to string
|
|
|
|
Debug.Log($"[ScoreManager] Player {newData.ClientId} added with name '{playerName}' on client.");
|
|
}
|
|
}
|
|
|
|
private void OnPlayerScoresChanged(SerializableDictionary<ulong, int> oldValue, SerializableDictionary<ulong, int> newValue)
|
|
{
|
|
foreach (var entry in newValue)
|
|
{
|
|
ulong clientId = entry.Key;
|
|
int score = entry.Value;
|
|
|
|
// Manually search for the player entry in playerDataList
|
|
FixedString64Bytes playerName = default;
|
|
foreach (var playerData in playerDataList)
|
|
{
|
|
if (playerData.ClientId == clientId)
|
|
{
|
|
playerName = playerData.Name;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!playerName.IsEmpty)
|
|
{
|
|
Debug.Log($"[ScoreManager] Score updated for Player {clientId} (Name: {playerName}): {score}");
|
|
Scoreboard.instance.ScoreBoardUpdater(playerName.ToString(), score);
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning($"[ScoreManager] Player name not found for Client {clientId}. Cannot update scoreboard.");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//using System.Collections;
|
|
//using System.Collections.Generic;
|
|
//using Unity.Multiplayer.Samples.BossRoom;
|
|
//using UnityEngine;
|
|
//using Unity.Netcode;
|
|
|
|
//public class ScoreManager : NetworkBehaviour
|
|
//{
|
|
// public static ScoreManager Instance { get; private set; }
|
|
|
|
// public Dictionary<ulong, int> playerScores = new Dictionary<ulong, int>();
|
|
// public Dictionary<ulong, string> playerNames = new Dictionary<ulong, string>();
|
|
|
|
// private void Awake()
|
|
// {
|
|
// if (Instance != null && Instance != this)
|
|
// {
|
|
// Destroy(gameObject);
|
|
// return;
|
|
// }
|
|
// Instance = this;
|
|
// }
|
|
|
|
// public override void OnNetworkSpawn()
|
|
// {
|
|
// if (IsServer)
|
|
// {
|
|
// StartCrowPenaltyCoroutine();
|
|
// }
|
|
// }
|
|
|
|
// //[ServerRpc(RequireOwnership = false)]
|
|
// public void InitializePlayerScore(ulong ownerClientId, string name)
|
|
// {
|
|
// if (!playerScores.ContainsKey(ownerClientId))
|
|
// {
|
|
// playerScores[ownerClientId] = 200;
|
|
// playerNames[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
|
|
// {
|
|
// 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.LogWarning($"[ScoreManager] No entry found for Player {ownerClientId}. Cannot update score.");
|
|
// }
|
|
// }
|
|
|
|
// [ClientRpc]
|
|
// public void UpdatePlayerScoreClientRpc(ulong ownerClientId, int newScore)
|
|
// {
|
|
// if (playerNames.ContainsKey(ownerClientId))
|
|
// {
|
|
// string playerName = playerNames[ownerClientId];
|
|
// Debug.Log($"[ScoreManager] Received score update for Player {ownerClientId} (Name: {playerName}): {newScore}");
|
|
// Scoreboard.instance.ScoreBoardUpdater(playerName, newScore);
|
|
// }
|
|
// else
|
|
// {
|
|
// Debug.LogWarning($"[ScoreManager] Player name not found for Player {ownerClientId}. Cannot update scoreboard.");
|
|
// }
|
|
// }
|
|
|
|
// public void AddPlayerScore(ulong ownerClientId, int scoreToAdd)
|
|
// {
|
|
// if (playerScores.ContainsKey(ownerClientId))
|
|
// {
|
|
// playerScores[ownerClientId] += scoreToAdd;
|
|
// UpdatePlayerScore(ownerClientId, playerScores[ownerClientId]);
|
|
// }
|
|
// }
|
|
|
|
// public void SubtractPlayerScore(ulong ownerClientId, int scoreToSubtract)
|
|
// {
|
|
// if (playerScores.ContainsKey(ownerClientId))
|
|
// {
|
|
// int newScore = Mathf.Max(0, playerScores[ownerClientId] - scoreToSubtract);
|
|
// UpdatePlayerScore(ownerClientId, newScore);
|
|
// }
|
|
// }
|
|
|
|
|
|
// public void StartCrowPenaltyCoroutine()
|
|
// {
|
|
// StartCoroutine(ApplyCrowPenaltyCoroutine());
|
|
// }
|
|
|
|
// private IEnumerator ApplyCrowPenaltyCoroutine()
|
|
// {
|
|
// yield return new WaitUntil(() => PlatformManager.Instance != null && PlatformManager.Instance.AreAllPlatformsOccupied());
|
|
|
|
// while (true)
|
|
// {
|
|
// // Create a list to store client IDs whose scores need to be updated
|
|
// List<ulong> clientsToModify = new List<ulong>();
|
|
|
|
// foreach (var entry in playerScores)
|
|
// {
|
|
// ulong ownerClientId = entry.Key;
|
|
|
|
// if (CrowManager.Instance != null && CrowManager.Instance.GetCurrentCrow().OwnerClientId == ownerClientId)
|
|
// {
|
|
// clientsToModify.Add(ownerClientId);
|
|
// }
|
|
// }
|
|
|
|
// // Apply the penalties after the iteration
|
|
// foreach (ulong clientId in clientsToModify)
|
|
// {
|
|
// SubtractPlayerScore(clientId, 2);
|
|
// Debug.Log($"[ScoreManager] Applied crow penalty to Player {clientId}. New score: {playerScores[clientId]}");
|
|
// }
|
|
|
|
// yield return new WaitForSeconds(5f);
|
|
// }
|
|
// }
|
|
//}
|