Minigame.cs

using UnityEngine;
using System;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
using LiberiNet;
using Janus;

public class Minigame : MonoBehaviour
{
    enum MinigameOperationType : byte
    {
        AddPlayer,
        RemovePlayer,
        AssignPlayer,
        UnassignPlayer,
        Shutdown
    }

    public delegate void LocalPlayerAssignedHandler (MinigamePlayer localPlayer);
    public event LocalPlayerAssignedHandler LocalPlayerAssigned = delegate {};

    public static Minigame Instance
    {
        get
        {
            _instance = _instance ?? FindObjectOfType<Minigame>();
            return _instance;
        }
    }

    public MinigameTeam DefaultTeam
    {
        get
        {
            if (Teams.Length > 0)
                return Teams[0];
            else return null;
        }
    }

    public MinigamePlayer[] Players
    {
        get { return _players.ToArray(); }
    }

    public MinigamePlayer[] HumanPlayers
    {
        get { return _humanPlayers.ToArray(); }
    }

    public MinigamePlayer[] BotPlayers
    {
        get { return _botPlayers.ToArray(); }
    }

    public GameObject[] PlayerAvatars
    {
        get { return (from player in Players where player.Avatar != null select player.Avatar).ToArray(); }
    }

    public GameObject[] HumanAvatars
    {
        get { return (from player in HumanPlayers where player.Avatar != null select player.Avatar).ToArray(); }
    }

    public GameObject[] BotAvatars
    {
        get { return (from player in BotPlayers where player.Avatar != null select player.Avatar).ToArray(); }
    }

    public int NumPlayers
    {
        get { return _players.Count; }
    }

    public int NumHumanPlayers
    {
        get { return _humanPlayers.Count; }
    }

    public int NumBotPlayers
    {
        get { return _botPlayers.Count; }
    }

    public int[] HumanPlayerPeerIndices
    {
        get { return _humanPlayers.Select(player => player.PeerIndex).ToArray(); }
    }

    public string[] HumanPlayerIDs
    {
        get { return _humanPlayers.Select(player => player.PlayerID).ToArray(); }
    }

    public PlayerProfile[] HumanPlayerProfiles
    {
        get { return _humanPlayers.Select(player => player.PlayerProfile).ToArray(); }
    }

    public string[] HumanPlayerNicknames
    {
        get { return _humanPlayers.Select(player => player.PlayerProfile.Basic.Nickname).ToArray(); }
    }

    public int MaxPlayers
    {
        get { return _maxPlayers; }
    }

    public bool IsFull
    {
        get { return NumPlayers >= _maxPlayers; }
    }

    public bool IsFullOfHumans
    {
        get { return NumHumanPlayers >= _maxPlayers; }
    }

    public MinigamePlayer LocalPlayer
    {
        get { return _localPlayer; }
    }

    public GameObject LocalAvatar
    {
        get
        {
            if (_localPlayer == null)
                return null;

            return _localPlayer.Avatar;
        }
    }

    public static float ShutdownDelay = 2f;

    static Minigame _instance;

    public MinigameTeam[] Teams = new MinigameTeam[]
    {
        new MinigameTeam()
    };

    public String ServerTime
    {
        get
        {
            if (!_serverStartTime.IsEmpty)
                return DateTime.ParseExact(_serverStartTime.LastValue, "yyyy-MM-dd HH:mm:ss", System.Globalization.CultureInfo.InvariantCulture).AddSeconds(_serverStartTime.Now).ToString("HH:mm:ss");
            else
                return "";
        }
    }

    int _maxPlayers;
    List<MinigamePlayer> _players;
    List<MinigamePlayer> _humanPlayers;
    List<MinigamePlayer> _botPlayers;
    MinigamePlayer _localPlayer;
    Timeline<GameMessage> _teamRequests;
    Timeline<GameMessage> _summaries;
    Timeline<GameMessage> _operations;
    Timeline<string> _serverStartTime;

    void Awake ()
    {
        _instance = _instance ?? this;
        
        _players = new List<MinigamePlayer>();
        _humanPlayers = new List<MinigamePlayer>();
        _botPlayers = new List<MinigamePlayer>();

        foreach (var team in Teams)
        {
            team.Initialize();
            _maxPlayers += team.MaxPlayers;
        }

        _teamRequests = Sync.CreateEvent<GameMessage>();
        _summaries = Sync.CreateEvent<GameMessage>();
        _operations = Sync.CreateEvent<GameMessage>();
        _serverStartTime = Sync.CreateDiscreteState<string>();
    }

    void OnSpawn ()
    {
        if (Game.IsServer)
        {
            GameServer.Instance.PlayerSynced += OnPlayerSynced;
            GameServer.Instance.PlayerLeftServer += OnPlayerLeftServer;

            _teamRequests.EntryPassed += OnTeamRequestMessage;
            _serverStartTime[0] = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
        }
        else if (Game.IsClient)
        {
            _summaries.EntryPassed += OnSummaryMessage;
        }
    }

    public MinigamePlayer GetPlayer (string playerId)
    {
        var matchingPlayers = _humanPlayers.Where(player => player.PlayerID == playerId).ToArray();

        if (matchingPlayers.Length > 0)
            return matchingPlayers[0];

        return null;
    }

    public MinigamePlayer GetPlayer (int peerIndex)
    {
        var matchingPlayers = _humanPlayers.Where(player => player.PeerIndex == peerIndex).ToArray();

        if (matchingPlayers.Length > 0)
            return matchingPlayers[0];

        return null;
    }

    public MinigamePlayer GetPlayer (GameObject avatar)
    {
        foreach (var team in Teams)
        {
            foreach (var player in team.Players)
            {
                if (player.Avatar == avatar)
                    return player;
            }
        }
        
        return null;
    }
    
    public MinigamePlayer GetPlayer (Component component)
    {
        foreach (var team in Teams)
        {
            foreach (var player in team.Players)
            {
                if (player.Avatar == component.gameObject)
                    return player;
            }
        }
        
        return null;
    }

    public T[] GetPlayerAvatarComponents<T> () where T : Component
    {
        return PlayerAvatars.Select(a => a.GetComponent<T>()).ToArray();
    }

    public T[] GetHumanAvatarComponents<T> () where T : Component
    {
        return HumanAvatars.Select(a => a.GetComponent<T>()).ToArray();
    }

    public T[] GetBotAvatarComponents<T> () where T : Component
    {
        return BotAvatars.Select(a => a.GetComponent<T>()).ToArray();
    }

    public MinigameTeam GetTeam (string teamId)
    {
        var matchingTeams = Teams.Where(team => team.ID == teamId).ToArray();

        if (matchingTeams.Length > 0)
            return matchingTeams[0];

        return null;
    }

    public void RequestPlayerAssign (string teamId)
    {
        if (!Game.IsClient)
            return;

        var requestMsg = new GameMessage();
        requestMsg.Write(Game.LocalPeerIndex);
        requestMsg.Write(teamId);

        _teamRequests[0] = requestMsg;
    }

    public void RequestPlayerUnassign ()
    {
        RequestPlayerAssign("");
    }

    public GameObject AssignPlayer (MinigamePlayer player, string teamId)
    {
        if (!Game.IsServer)
            return null;

        if (player == null)
            return null;

        var team = GetTeam(teamId);

        if (team == null)
            return null;

        if (player.IsBot)
        {
            if (team.IsFull)
                return null;
        }
        else if (player.IsHuman)
        {
            if (team.IsFull)
            {
                if (team.IsFullOfHumans)
                    return null;

                RemoveBotPlayer(_botPlayers[0]);
            }
        }

        AssignPlayerLocally(player, team.TeamIndex, delayNotification: true);

        var spawnPoint = team.GetSpawnPoint(player.SlotIndex);

        Vector3 spawnDirection = Vector3.zero;

        var avatarDirectionMode = team.AvatarPrefab.GetComponent<Sync>().DirectionMode;

        if (avatarDirectionMode == DirectionMode.Radial)
            spawnDirection = spawnPoint.up;
        else if (avatarDirectionMode == DirectionMode.Flip)
            spawnDirection = new Vector3(Mathf.Sign(spawnPoint.localScale.x), 0f, 0f);

        var avatarDetails = new UJeli();

        Sync.SendEnabledMessage(this, "SetMinigameAvatarDetails", player, avatarDetails);

        var avatar = Sync.Spawn(team.AvatarPrefab, spawnPoint.position, spawnDirection, player.PeerIndex, avatarDetails);
        player.Avatar = avatar;

        var opMsg = new GameMessage();
        opMsg.Write((byte)MinigameOperationType.AssignPlayer);
        opMsg.Write(_players.IndexOf(player));
        opMsg.Write(team.TeamIndex);
        opMsg.Write(player.SlotIndex);
        opMsg.WriteGameObject(avatar);

        _operations[0] = opMsg;
    
        Sync.SendEnabledMessage(this, "OnMinigamePlayerAssigned", player);

        return avatar;
    }

    public void UnassignPlayer (MinigamePlayer player)
    {
        if (!Game.IsServer)
            return;

        if (player == null)
            return;

        UnassignPlayerLocally(player);

        var opMsg = new GameMessage();
        opMsg.Write((byte)MinigameOperationType.UnassignPlayer);
        opMsg.Write(_players.IndexOf(player));

        _operations[0] = opMsg;

        if (player.Avatar != null)
            Sync.Despawn(player.Avatar);
    }

    public MinigamePlayer AddBotPlayer (string teamId = null)
    {
        if (!Game.IsServer)
            return null;

        var player = new MinigamePlayer();

        AddPlayerLocally(player);

        var opMsg = new GameMessage();
        opMsg.Write((byte)MinigameOperationType.AddPlayer);
        opMsg.Write(0);

        _operations[0] = opMsg;

        if (teamId != null)
        {
            AssignPlayer(player, teamId);
        }
        else
        {
            if (DefaultTeam != null)
                AssignPlayer(player, DefaultTeam.ID);
        }

        return player;
    }

    public void RemoveBotPlayer (MinigamePlayer player)
    {
        if (!Game.IsServer)
            return;

        if (player == null)
            return;

        if (!player.IsBot)
            return;

        UnassignPlayer(player);

        var opMsg = new GameMessage();
        opMsg.Write((byte)MinigameOperationType.RemovePlayer);
        opMsg.Write(_players.IndexOf(player));

        _operations[0] = opMsg;

        RemovePlayerLocally(player);
    }

    public void Shutdown ()
    {
        if (!Game.IsServer)
            return;

        var opMsg = new GameMessage();
        opMsg.Write((byte)MinigameOperationType.Shutdown);

        _operations[0] = opMsg;
        
        StartCoroutine(ShutdownAsync());
    }

    IEnumerator ShutdownAsync ()
    {
        yield return new WaitForSeconds(ShutdownDelay);

#if UNITY_EDITOR
        UnityEditor.EditorApplication.isPlaying = false;
#else
        Application.Quit();
#endif
    }

    private void AddPlayerLocally (MinigamePlayer player)
    {
        if (player == null)
            return;

        _players.Add(player);

        if (player.IsHuman)
        {
            _humanPlayers.Add(player);

            if (player.IsLocal)
                _localPlayer = player;
        }
        else if (player.IsBot)
        {
            _botPlayers.Add(player);
        }
    }

    private void RemovePlayerLocally (int playerIndex)
    {
        if (playerIndex < 0 || _players.Count <= playerIndex)
            return;

        RemovePlayerLocally(_players[playerIndex]);
    }

    private void RemovePlayerLocally (MinigamePlayer player)
    {
        if (player == null)
            return;

        if (player.Team != null)
            UnassignPlayerLocally(player);

        _players.Remove(player);
        _humanPlayers.Remove(player);
        _botPlayers.Remove(player);

        if (player == _localPlayer)
            _localPlayer = null;
    }

    private void AssignPlayerLocally (MinigamePlayer player, int teamIndex, int slotIndex = -1,
        GameObject avatar = null, bool delayNotification = false)
    {
        if (player == null)
            return;

        if (teamIndex == -1)
            return;

        var team = Teams[teamIndex];

        if (team == null)
            return;

        if (player.Team != null)
            UnassignPlayerLocally(player);

        if (slotIndex == -1)
            slotIndex = team.FirstEmptySlotIndex;

        team.InsertPlayer(slotIndex, player);

        if (avatar != null)
            player.Avatar = avatar;

        if (!delayNotification)
            Sync.SendEnabledMessage(this, "OnMinigamePlayerAssigned", player);
            
        if (player.IsLocal)
            LocalPlayerAssigned(player);
    }

    private void UnassignPlayerLocally (MinigamePlayer player)
    {
        if (player == null)
            return;

        if (player.Team == null)
            return;

        player.Team.RemovePlayer(player);

        Sync.SendEnabledMessage(this, "OnMinigamePlayerUnassigned", player);
    }

    void OnTeamRequestMessage (Timeline<GameMessage> timeline, TimelineEntry<GameMessage> entry)
    {
        var msg = entry.Value;

        int peerIndex = msg.ReadInt32();
        string teamId = msg.ReadString();
        msg.FinishReading();

        var player = GetPlayer(peerIndex);

        if (player == null)
            return;

        AssignPlayer(player, teamId);
    }

    void OnPlayerSynced (int peerIndex, string playerId, PlayerProfile playerProfile)
    {
        if (playerProfile.Basic.IsMonitor)
        {
            var monitorSpawnPos = Camera.main.transform.position;
            monitorSpawnPos.z = 0f;

            Sync.Spawn("monitor", monitorSpawnPos, Vector3.zero, peerIndex);

            return;
        }

        var summaryMsg = new GameMessage();
        summaryMsg.Write(_players.Count);

        foreach (var existingPlayer in _players)
        {
            int teamIndex = -1;

            if (existingPlayer.Team != null)
                teamIndex = existingPlayer.Team.TeamIndex;

            summaryMsg.Write(existingPlayer.PeerIndex);
            summaryMsg.Write(teamIndex);

            if (teamIndex != -1)
            {
                summaryMsg.Write(existingPlayer.SlotIndex);
                summaryMsg.WriteGameObject(existingPlayer.Avatar);
            }
        }

        _summaries[0] = summaryMsg;

        var player = new MinigamePlayer()
        {
            PeerIndex = peerIndex,
            PlayerProfile = playerProfile
        };

        AddPlayerLocally(player);

        var opMsg = new GameMessage();
        opMsg.Write((byte)MinigameOperationType.AddPlayer);
        opMsg.Write(peerIndex);

        _operations[0] = opMsg;

        if (DefaultTeam != null)
            AssignPlayer(player, DefaultTeam.ID);
    }

    void OnPlayerLeftServer (int peerIndex, string playerId, PlayerProfile playerProfile)
    {
        if (playerProfile.Basic.IsMonitor)
            return;

        var player = GetPlayer(peerIndex);

        if (player == null)
            return;

        UnassignPlayer(player);

        RemovePlayerLocally(player);

        var opMsg = new GameMessage();
        opMsg.Write((byte)MinigameOperationType.RemovePlayer);
        opMsg.Write(_players.IndexOf(player));

        if (_humanPlayers.Count == 0)
            Shutdown();
    }

    void OnSummaryMessage (Timeline<GameMessage> timeline, TimelineEntry<GameMessage> entry)
    {
        var msg = entry.Value;

        int numPlayers = msg.ReadInt32();

        for (int i = 0; i < numPlayers; i++)
        {
            int peerIndex = msg.ReadInt32();
            int teamIndex = msg.ReadInt32();

            var player = new MinigamePlayer()
            {
                PeerIndex = peerIndex
            };

            if (Sync.IsClientPeerIndex(peerIndex))
                player.PlayerProfile = Game.GetPlayerProfile(peerIndex);

            AddPlayerLocally(player);

            if (teamIndex != -1)
            {
                int slotIndex = msg.ReadInt32();
                var avatar = msg.ReadGameObject();

                AssignPlayerLocally(player, teamIndex, slotIndex, avatar);
            }
        }

        msg.FinishReading();

        // We only need to ever receive one summary message at the beginning, so unsubscribe from future summaries.
        // As well, subscribe to operations to allow future incoming updates to the teams and players.
        _summaries.EntryPassed -= OnSummaryMessage;
        _operations.EntryPassed += OnOperationMessage;
    }

    void OnOperationMessage (Timeline<GameMessage> timeline, TimelineEntry<GameMessage> entry)
    {
        var msg = entry.Value;

        var opType = (MinigameOperationType)msg.ReadByte();

        if (opType == MinigameOperationType.AddPlayer)
        {
            int peerIndex = msg.ReadInt32();
            msg.FinishReading();

            var player = new MinigamePlayer()
            {
                PeerIndex = peerIndex,
            };

            AddPlayerLocally(player);
        }
        else if (opType == MinigameOperationType.RemovePlayer)
        {
            int playerIndex = msg.ReadInt32();

            RemovePlayerLocally(playerIndex);
        }
        else if (opType == MinigameOperationType.AssignPlayer)
        {
            int playerIndex = msg.ReadInt32();
            int teamIndex = msg.ReadInt32();
            int slotIndex = msg.ReadInt32();
            var avatar = msg.ReadGameObject();
            msg.FinishReading();

            if (playerIndex == -1 || _players.Count <= playerIndex)
                return;

            var player = _players[playerIndex];

            if (player == null)
                return;

            AssignPlayerLocally(player, teamIndex, slotIndex, avatar);
        }
        else if (opType == MinigameOperationType.UnassignPlayer)
        {
            int playerIndex = msg.ReadInt32();
            msg.FinishReading();

            if (playerIndex == -1 || _players.Count <= playerIndex)
                return;

            var player = _players[playerIndex];

            if (player == null)
                return;

            UnassignPlayerLocally(player);
        }
        else if (opType == MinigameOperationType.Shutdown)
        {
            //TODO: Shutdown client, fade out and stuff
        }
    }

    void OnDespawn ()
    {
        if (Game.IsServer)
        {
            GameServer.Instance.PlayerSynced -= OnPlayerSynced;
            GameServer.Instance.PlayerLeftServer -= OnPlayerLeftServer;
        }
    }

    void OnDestroy ()
    {
        if (this == _instance)
            _instance = null;
    }
}