Zone.cs

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

[SerializeField]
public class ZonePlayer
{
    public int PeerIndex;
    public string PlayerID;
    public PlayerProfile PlayerProfile;
    public GameObject Avatar;
    
    public bool IsLocal
    {
        get { return Sync.IsLocalPeerIndex(PeerIndex); }
    }
}

[RequireComponent(typeof(Sync))]
public class Zone : MonoBehaviour
{
    public const float MusicFadeLength = 1f;

    public static Zone Instance
    {
        get { return _instance; }
    }

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

    public ZonePlayer LocalPlayer
    {
        get { return _localPlayer; }
    }

    public GameObject[] Avatars
    {
        get { return _players.Select(p => p.Avatar).ToArray(); }
    }

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

            return null;
        }
    }

    public int[] PlayerPeerIndices
    {
        get { return _players.Select(p => p.PeerIndex).ToArray(); }
    }

    public string[] PlayerIDs
    {
        get { return _players.Select(p => p.PlayerID).ToArray(); }
    }

    public PlayerProfile[] PlayerProfiles
    {
        get { return _players.Select(p => p.PlayerProfile).ToArray(); }
    }

    public string[] PlayerNicknames
    {
        get { return _players.Select(p => p.PlayerProfile.Basic.Nickname).ToArray(); }
    }

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

    static Zone _instance;

    public GameObject PlayerAvatarPrefab;
    public ZoneCheckpoint DefaultCheckpoint;
    public AudioClip ZoneBGM;
    
    List<ZonePlayer> _players;
    ZonePlayer _localPlayer;

    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 "";
        }
    }

    Timeline<string> _serverStartTime;

    enum ZoneOperationType : byte
    {
        AddPlayer,
        RemovePlayer,
        Shutdown
    }
    
    Timeline<GameMessage> _summaries;
    Timeline<GameMessage> _operations;

    void Awake ()
    {
        _instance = this;

        _players = new List<ZonePlayer>();

        _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;

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

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

    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();
            string playerID = msg.ReadString();
            GameObject avatar = msg.ReadGameObject();
            
            var player = new ZonePlayer()
            {
                PeerIndex = peerIndex,
                PlayerID = playerID,
                Avatar = avatar
            };
            
            if (Sync.IsClientPeerIndex(peerIndex))
                player.PlayerProfile = Game.GetPlayerProfile(peerIndex);

            _players.Add(player);
        }
        
        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 = (ZoneOperationType)msg.ReadByte();
        
        if (opType == ZoneOperationType.AddPlayer)
        {
            int peerIndex = msg.ReadInt32();
            string playerID = msg.ReadString();
            GameObject avatar = msg.ReadGameObject();
            
            var player = new ZonePlayer()
            {
                PeerIndex = peerIndex,
                PlayerID = playerID,
                Avatar = avatar
            };
            
            if (Sync.IsClientPeerIndex(peerIndex))
                player.PlayerProfile = Game.GetPlayerProfile(peerIndex);
            
            _players.Add(player);
            
            if (player.IsLocal)
                _localPlayer = player;
        }
        else if (opType == ZoneOperationType.RemovePlayer)
        {
            int playerIndex = msg.ReadInt32();
            
            _players.RemoveAll(i => i.PeerIndex == playerIndex);
        }
        else if (opType == ZoneOperationType.Shutdown)
        {
            //TODO: Shutdown client, fade out and stuff
        }

        msg.FinishReading();
    }

    public ZonePlayer GetPlayer (int peerIndex)
    {
        var matchingPlayers = _players.Where(p => p.PeerIndex == peerIndex).ToArray();

        if (matchingPlayers.Length != 0)
            return matchingPlayers[0];

        return null;
    }

    public ZonePlayer GetPlayer (string playerId)
    {
        var matchingPlayers = _players.Where(p => p.PlayerID == playerId).ToArray();

        if (matchingPlayers.Length != 0)
            return matchingPlayers[0];

        return null;
    }

    public ZonePlayer GetPlayer (GameObject avatar)
    {
        var matchingPlayers = _players.Where(p => p.Avatar == avatar).ToArray();

        if (matchingPlayers.Length != 0)
            return matchingPlayers[0];

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

        // TODO: Shutdown zone.
    }

    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)
        {           
            summaryMsg.Write(existingPlayer.PeerIndex);
            summaryMsg.Write(existingPlayer.PlayerID);
            summaryMsg.WriteGameObject(existingPlayer.Avatar);
        }
        
        _summaries[0] = summaryMsg;

        var player = new ZonePlayer()
        {
            PeerIndex = peerIndex,
            PlayerID = playerProfile.PlayerID,
            PlayerProfile = playerProfile
        };

        _players.Add(player);

        ZoneCheckpoint checkpoint = null;

        if (!string.IsNullOrEmpty(playerProfile.Location.LastCheckpointID))
        {
            checkpoint = ZoneCheckpoint.Find(playerProfile.Location.LastCheckpointID) ??
                Zone.Instance.DefaultCheckpoint;
        }
        else checkpoint = Zone.Instance.DefaultCheckpoint;

        if (checkpoint == null)
            return;

        var prefabSync = PlayerAvatarPrefab.GetComponent<Sync>();
        Vector3 spawnDirection = Vector3.zero;

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

        var avatar = Sync.Spawn(PlayerAvatarPrefab, checkpoint.transform.position, spawnDirection, peerIndex);
        player.Avatar = avatar;
        
        GameMessage opMessage = new GameMessage();
        
        opMessage.Write((byte)ZoneOperationType.AddPlayer);
        opMessage.Write(player.PeerIndex);
        opMessage.Write(player.PlayerID);
        opMessage.WriteGameObject(player.Avatar);
        
        _operations[0] = opMessage;
    }

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

        var player = GetPlayer(peerIndex);

        if (player == null)
            return;

        _players.Remove(player);

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