evershade/Assets/Scripts/Managers/GameManager.cs

using System.Collections.Generic;
using Data.ScriptableObjects;
using FishNet.Connection;
using FishNet.Object;
using FishNet.Object.Synchronizing;
using Types;
using UnityEngine;

namespace Managers
{
    public class GameManager : NetworkBehaviour
    {
        public enum GameState
        {
            WaitingForPlayers,
            Playing,
            Paused,
            GameOver
        }


        [SerializeField] private SaveManager saveManager;
        [SerializeField] private HotkeyManager hotkeyManager;
        [SerializeField] private AudioManager audioManager;
        [SerializeField] private UIManager uiManager;

        public GameState currentState = GameState.WaitingForPlayers;

        // person who's running the game, owner.
        [SerializeField] private PlayerManager gameManagerPlayer;
        [SerializeField] private List<PlayerManager> gameManagerPlayerData;


        [SerializeField] public ItemDatabase itemDatabase;
        private readonly SyncList<GamePlayer> _players = new();

        public static GameManager Instance { get; set; }

        private void Awake()
        {
            // uiManager = GetComponent<UIManager>();
            Debug.Log("Starting GameManager");
            itemDatabase = Resources.Load<ItemDatabase>("GameItems/ItemDatabase");

            _players.OnChange += OnPlayersChange;

            if (Instance != null) Destroy(this);
            Instance = this;
        }

        private void OnDestroy()
        {
            if (Instance == this)
                Instance = null;

            Debug.Log("GameManager destroyed");
        }

        private void OnPlayersChange(SyncListOperation op, int index, GamePlayer olditem, GamePlayer newitem,
            bool asserver)
        {
            // log changes 
            Debug.Log($"Players changed: {op} {index} {olditem} {newitem} {asserver}");
        }


        [ServerRpc(RequireOwnership = false)]
        public void RegisterPlayerServerRpc(NetworkConnection conn, GamePlayer player)
        {
            Debug.Log("Registering player...");
            if (player != null && !_players.Contains(player))
            {
                _players.Add(player);
                Debug.Log($"Player registered: {conn.ClientId}");
                OnPlayerRegisteredObserversRpc(conn.ClientId);
            }
        }

        [ObserversRpc]
        private void OnPlayerRegisteredObserversRpc(int clientId)
        {
            Debug.Log($"Player with ID {clientId} has joined the game!");
            // You can add any client-side logic here when a new player joins
        }

        public List<GamePlayer> GetPlayers()
        {
            return new List<GamePlayer>(_players);
        } // ReSharper disable Unity.PerformanceAnalysis
        public override void OnStartNetwork()
        {
            base.OnStartNetwork();
            Debug.Log("Network started");
        }

        // method to handle player connections
        // ReSharper disable Unity.PerformanceAnalysis
        public override void OnStartClient()
        {
            Debug.Log("Client connected to server");
            base.OnStartClient();
            if (IsServerInitialized)
            {
                // Server logic for new player connections 
            }
            // client logic for new player connections 
        }

        public override void OnStopClient()
        {
            base.OnStopClient();
            // client specific cleanup code?

            if (IsServerInitialized)
            {
                // server logic for disconnection
            }
            // client logic for disconnection
        }

        [ServerRpc(RequireOwnership = false)]
        public void StartGameServerRpc()
        {
            UIManager.ShowMainMenuScreen(false);
            // AudioManager.PlayMusic("MainTheme");
        }

        [ObserversRpc]
        public void StartGameObserversRpc()
        {
            UIManager.ShowMainMenuScreen(false);
        }

        [ServerRpc(RequireOwnership = false)]
        // client ot server comm? i.e client is telling the server to run this code
        public void EndGameServerRpc()
        {
            Debug.Log("ServerRPC Game Over");
            UIManager.ShowGameOverScreen(true);
            // AudioManager.PlayMusic("GameOverTheme");
        }

        [ObserversRpc]
        // server to client communication i.e server is telling the client to run this code  
        public void EndGameObserversRpc()
        {
            Debug.Log("ObserverRPC Game Over");
            UIManager.ShowGameOverScreen(true);
        }

        public void StartGame()
        {
            if (IsServerInitialized)
                StartGameServerRpc();
            else
                StartGameObserversRpc();
        }

        // add player


        public void AddPlayer(GamePlayer gamePlayer)
        {
            _players.Add(gamePlayer);
        }

        public GamePlayer GetCurrentPlayerManager(int id)
        {
            return _players[id];
        }

        public GamePlayer GetLastPlayer()
        {
            return _players[^1];
        }
    }
}