GameClient.cs

using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Threading;
using Lidgren.Network;
using Janus;
using LiberiNet;

public class GameClient : MonoBehaviour, IActionInfoProvider
{
    private class WorldServerInfo
    {
        public NetConnection Connection;
    }

    private class ServerInfo
    {
        public NetConnection Connection;
        public GameServerType ServerType;
        public string MapID;
    }

    private class ClientInfo
    {
        public int PeerIndex = -1;
        public string PlayerID;
        public PlayerProfile PlayerProfile;
    }

    public delegate void ConnectedToWorldServerHandler ();
    public delegate void ConnectionToWorldServerFailedHandler ();
    public delegate void DisconnectedFromWorldServerHandler ();
    public delegate void ConnectedToServerHandler ();
    public delegate void ConnectionToServerFailedHandler ();
    public delegate void PreDisconnectFromServerHandler ();
    public delegate void DisconnectedFromServerHandler ();
    public delegate void ServersFoundHandler (GameServerType serverType, string mapId, IPEndPoint[] results);
    public delegate void ServerSearchFailedHandler (GameServerType serverType, string mapId);
    public delegate void ServerSummaryReceivedHandler (GameServerSummary serverSummary);
    public delegate void ServerSpawnedHandler (GameServerType serverType, string mapId, IPEndPoint endPoint);
    public delegate void ServerSpawnFailedHandler (GameServerType serverType, string mapId);
    public delegate void PlayerFoundHandler (string playerId, GameServerType serverType, string mapId, IPEndPoint serverEndPoint);
    public delegate void PlayerNotFoundHandler (string playerId);
    public delegate void PlayerJoinedServerHandler (int peerIndex, PlayerProfile playerProfile);
    public delegate void PlayerLeftServerHandler (int peerIndex, PlayerProfile playerProfile);
    public delegate void PlayerJoinedWorldServerHandler (string playerId, string playerNickname);
    public delegate void PlayerLeftWorldServerHandler (string playerId, string playerNickname);
    public delegate void WorldDataReceivedHandler (UJeli worldDataPage);

#pragma warning disable 0067
    public event ConnectedToWorldServerHandler ConnectedToWorldServer = delegate { };
    public event ConnectionToWorldServerFailedHandler ConnectionToWorldServerFailed = delegate { };
    public event DisconnectedFromWorldServerHandler DisconnectedFromWorldServer = delegate { };
    public event ConnectedToServerHandler ConnectedToServer = delegate { };
    public event ConnectionToServerFailedHandler ConnectionToServerFailed = delegate { };
    public event PreDisconnectFromServerHandler PreDisconnectFromServer = delegate { };
    public event DisconnectedFromServerHandler DisconnectedFromServer = delegate { };
    public event ServersFoundHandler ServersFound = delegate { };
    public event ServerSearchFailedHandler ServerSearchFailed = delegate { };
    public event ServerSummaryReceivedHandler ServerSummaryReceived = delegate { };
    public event ServerSpawnedHandler ServerSpawned = delegate { };
    public event ServerSpawnFailedHandler ServerSpawnFailed = delegate { };
    public event PlayerFoundHandler PlayerFound = delegate { };
    public event PlayerNotFoundHandler PlayerNotFound = delegate { };
    public event PlayerJoinedServerHandler OtherPlayerJoinedServer = delegate { };
    public event PlayerLeftServerHandler OtherPlayerLeftServer = delegate { };
    public event PlayerJoinedWorldServerHandler OtherPlayerJoinedWorldServer = delegate{ };
    public event PlayerLeftWorldServerHandler OtherPlayerLeftWorldServer = delegate { };
#pragma warning restore 0067

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

    public string ConfigBase
    {
        get { return _configBase; }
    }

    public string LogsBase
    {
        get { return _logsBase; }
    }

    public string ScreenshotsBase
    {
        get { return _screenshotsBase; }
    }
    
    public string StudyLogsBase
    {
        get { return _studyLogsBase; }
    }

    public ClientConfig Config
    {
        get { return _config; }
    }

    public bool IsConnectedToWorldServer
    {
        get { return _isConnectedToWorldServer; }
    }

    public bool IsConnectedToServer
    {
        get { return _isConnectedToServer; }
    }

    public GameServerType ServerType
    {
        get
        {
            if (_server != null)
                return _server.ServerType;
            else return GameServerType.None;
        }
    }

    public string MapID
    {
        get
        {
            if (_server != null)
                return _server.MapID;
            else return null;
        }
    }

    public UJeli MapSettings
    {
        get { return _mapSettings; }
    }

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

    public string[] PlayerIDs
    {
        get { return _clientsById.Keys.ToArray(); }
    }

    public int[] PlayerPeerIndices
    {
        get { return _clientsByPeerIndex.Keys.ToArray(); }
    }

    public PlayerProfile[] PlayerProfiles
    {
        get
        {
            return (
                from client in _clientsById.Values
                where client.PlayerProfile != null
                select client.PlayerProfile).ToArray();
        }
    }

    public string[] PlayerNicknames
    {
        get
        {
            return (
                from client in _clientsById.Values
                where client.PlayerProfile != null
                select client.PlayerProfile.Basic.Nickname).ToArray();
        }
    }

    public string LocalPlayerID
    {
        get { return (_localClient != null) ? _localClient.PlayerID : _config.Network.PlayerID; }
    }

    public PlayerProfile LocalPlayerProfile
    {
        get { return (_localClient != null) ? _localClient.PlayerProfile : null; }
    }

    static GameClient _instance;

    static Dictionary<NetDeliveryMethod, DeliveryMode> _netToTimelineDeliveryModes
        = new Dictionary<NetDeliveryMethod, DeliveryMode>()
    {
        { NetDeliveryMethod.ReliableOrdered, DeliveryMode.ReliableOrdered },
        { NetDeliveryMethod.ReliableUnordered, DeliveryMode.ReliableUnordered },
        { NetDeliveryMethod.Unreliable, DeliveryMode.Unreliable },
    };

    static Dictionary<DeliveryMode, NetDeliveryMethod> _timelineToNetDeliveryModes
        = new Dictionary<DeliveryMode, NetDeliveryMethod>()
    {
        { DeliveryMode.ReliableOrdered, NetDeliveryMethod.ReliableOrdered },
        { DeliveryMode.ReliableUnordered, NetDeliveryMethod.ReliableUnordered },
        { DeliveryMode.Unreliable, NetDeliveryMethod.Unreliable },
    };

    public float StatsReportInterval = 1f;

    string _configBase;
    string _logsBase;
    string _screenshotsBase;
    string _studyLogsBase;
    ClientConfig _config;
    StreamWriter _logWriter;
    NetPeer _netPeer;
    WorldServerInfo _worldServer;
    bool _isConnectedToWorldServer;
    bool _isServerSearchCrucial;
    ServerInfo _server;
    bool _isServerConnectionCrucial;
    bool _isConnectedToServer;
    UJeli _mapSettings;
    ClientInfo _localClient;
    Dictionary<int, ClientInfo> _clientsByPeerIndex;
    Dictionary<string, ClientInfo> _clientsById;
    Dictionary<string, List<WorldDataReceivedHandler>> _worldDataRequests;
    Dictionary<string, UJeli> _worldDataCache;
    Dictionary<int, DateTime> _serverSummaryRequestTimes;
    int _nextServerSummaryRequestIndex;

    List<ExtendedSpawnInfo> _postSyncObjects = new List<ExtendedSpawnInfo>();

    public struct ExtendedSpawnInfo
    {
        public SpawnInfo Info;
        public int ObjectIndex;
        public bool IsNew;
        
        public ExtendedSpawnInfo (SpawnInfo i, int o, bool n)
        {
            Info = i;
            ObjectIndex = o;
            IsNew = n;
        }
    }
    
    void Awake ()
    {
        _instance = this;

        DontDestroyOnLoad(this);

        _configBase = Path.GetFullPath(Application.dataPath + "/../Config/");
        _logsBase = Path.GetFullPath(Application.dataPath + "/../Logs/");
        _screenshotsBase = Path.GetFullPath(Application.dataPath + "/../Screenshots/");
        _studyLogsBase = Path.GetFullPath(Application.dataPath + "/../Study Logs/");
        
        _config = new ClientConfig();

        var netPeerConfig = new NetPeerConfiguration("Liberi");
        netPeerConfig.AcceptIncomingConnections = false;
        netPeerConfig.EnableMessageType(NetIncomingMessageType.UnconnectedData);

        _netPeer = new NetPeer(netPeerConfig);

        _clientsByPeerIndex = new Dictionary<int, ClientInfo>();
        _clientsById = new Dictionary<string, ClientInfo>();

        _worldDataRequests = new Dictionary<string, List<WorldDataReceivedHandler>>();
        _worldDataCache = new Dictionary<string, UJeli>();

        _serverSummaryRequestTimes = new Dictionary<int, DateTime>();

        TimelineUtils.SetDefaultTimelineFunctions();
        UTimelineUtils.SetDefautTimelineFunctions();

        Sync.PropagateSpawnUp += OnPropagateSpawnUp;
        Sync.PropagateDespawnUp += OnPropagateDespawnUp;

        Sync.Initialize();
    }

    void Start ()
    {
        Directory.CreateDirectory(_configBase);
        Directory.CreateDirectory(_logsBase);
        Directory.CreateDirectory(_screenshotsBase);

        _logWriter = File.CreateText(Path.GetFullPath(
            string.Format("{0}Liberi_{1:yyyy-MM-dd_HH-mm-ss}.log", _logsBase, DateTime.Now)));
        _logWriter.AutoFlush = true;

        Log("Client initializing...");

        _config.Load();

        foreach (var deviceState in _config.Devices.States)
        {
            if (deviceState.Value)
                DeviceManager.Instance.EnableDevice(deviceState.Key);
            else DeviceManager.Instance.DisableDevice(deviceState.Key);
        }

        Controls.RegisterActionInfoProvider(ControlsAction.Back, this);

        var flags = CommandLineUtils.GetCommandLineFlags();

        if (flags.ContainsKey("playerid"))
            _config.Network.PlayerID = flags["playerid"];

        GoToLaunchScreen(flags.ContainsKey("noupdate"));
        
        StartCoroutine(ReportLossyBytes());
    }

    public void Log (string line)
    {
        if (_logWriter != null)
            _logWriter.WriteLine(string.Format("[{0:HH:mm:ss}] {1}", DateTime.Now, line));
    }

    private ClientInfo GetClient (int peerIndex)
    {
        ClientInfo client = null;
        _clientsByPeerIndex.TryGetValue(peerIndex, out client);
        return client;
    }

    private ClientInfo GetClient (string playerId)
    {
        ClientInfo client = null;
        _clientsById.TryGetValue(playerId, out client);
        return client;
    }

    public int GetPlayerPeerIndex (string playerId)
    {
        var client = GetClient(playerId);

        if (client != null)
            return client.PeerIndex;
        else return -1;
    }

    public string GetPlayerID (int peerIndex)
    {
        var client = GetClient(peerIndex);

        if (client != null)
            return client.PlayerID;
        else return null;
    }

    public PlayerProfile GetPlayerProfile (string playerId)
    {
        var client = GetClient(playerId);

        if (client != null)
            return client.PlayerProfile;
        else return null;
    }

    public PlayerProfile GetPlayerProfile (int peerIndex)
    {
        var client = GetClient(peerIndex);

        if (client != null)
            return client.PlayerProfile;
        else return null;
    }

    public void GoToLaunchScreen (bool upToDate)
    {
        LaunchScreen.UpToDate = upToDate;
        Application.LoadLevel("launch");
    }

    public void ConnectToWorldServer ()
    {
        Log("Starting network...");

        try { _netPeer.Start(); }
        catch { }

        if (_netPeer.Status != NetPeerStatus.Running)
        {
            Log("Failed to start network.");
            DisconnectFromWorldServer("error.net_start_fail");
            return;
        }

        Log("Network started.");

        StatusOverlay.ShowStatus(Localizer.GetString("status.searching"));

        IPEndPoint worldEndPoint = null;

        if (string.IsNullOrEmpty(_config.Network.WorldID))
        {
            _config.Network.WorldID = "localhost";
            _config.Network.Save();
        }
        
        IPAddress ipAddress = null; 
        IPAddress.TryParse(_config.Network.WorldID, out ipAddress);

        Log("Searching for world server: " + _config.Network.WorldID);

        if (_config.Network.WorldID == "localhost")
            worldEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 34443);
        else if (ipAddress != null)
            worldEndPoint = new IPEndPoint(ipAddress, 34443);
        else worldEndPoint = WorldNetUtils.GetWorldEndPoint(_config.Network.WorldID);

        if (worldEndPoint == null)
        {
            Log("Failed to find world server.");
            DisconnectFromWorldServer("error.world_not_found");
            return;
        }

        Log("World server found.");

        var localHail = _netPeer.CreateMessage();
        localHail.Write((byte)WorldServerMessageType.RegisterClient);
        localHail.Write(_config.Network.PlayerID);

        StatusOverlay.ShowStatus(Localizer.GetString("status.connecting"));

        Log("Connecting to world server at: " + worldEndPoint);

        _worldServer = new WorldServerInfo();
        _worldServer.Connection = _netPeer.Connect(worldEndPoint, localHail);
        _worldServer.Connection.Tag = _worldServer;
    }

    public void DisconnectFromWorldServer (string error = "")
    {
        if (_isConnectedToServer)
            DisconnectFromServer();

        _localClient = null;
        _isConnectedToWorldServer = false;
        _worldServer = null;

        if (_netPeer.Status != NetPeerStatus.NotRunning && _netPeer.Status != NetPeerStatus.ShutdownRequested)
        {
            Log("Stopping network...");

            _netPeer.Shutdown(error);

            Log("Network stopped.");
        }

        if (error != "")
            StatusOverlay.ShowError(Localizer.GetString(error));

        GoToLaunchScreen(false);
    }

    public void FindServers (GameServerType serverType, string mapId, bool isCrucial)
    {
        Log("Searching for servers. Map: " + mapId);

        StatusOverlay.ShowStatus(Localizer.GetString("status.searching"));

        var searchMsg = _netPeer.CreateMessage();
        searchMsg.Write((byte)WorldServerMessageType.FindServers);
        searchMsg.Write(serverType.ToString().ToLower());
        searchMsg.Write(mapId);

        _isServerSearchCrucial = isCrucial;

        _worldServer.Connection.SendMessage(searchMsg, NetDeliveryMethod.ReliableOrdered, 0);
    }

    public void RequestServerSummary (IPEndPoint serverEndPoint)
    {
        var requestMsg = _netPeer.CreateMessage();
        requestMsg.Write((byte)ServerMessageType.Custom);
        requestMsg.Write((byte)CustomServerMessageType.SummaryRequest);
        requestMsg.Write(_nextServerSummaryRequestIndex);

        _netPeer.SendUnconnectedMessage(requestMsg, serverEndPoint);

        _serverSummaryRequestTimes[_nextServerSummaryRequestIndex] = DateTime.Now;
        _nextServerSummaryRequestIndex++;
    }

    public void RequestServerSpawn (GameServerType serverType, string mapId)
    {
        var requestMsg = _netPeer.CreateMessage();
        requestMsg.Write((byte)WorldServerMessageType.SpawnServer);
        requestMsg.Write(serverType.ToString().ToLower());
        requestMsg.Write(mapId);

        _worldServer.Connection.SendMessage(requestMsg, NetDeliveryMethod.ReliableOrdered, 0);
    }

    public void ConnectToServer (IPEndPoint serverEndPoint, GameServerType serverType, string mapId, bool isCrucial)
    {
        if (_isConnectedToServer)
            DisconnectFromServer();

        var localHail = _netPeer.CreateMessage();
        localHail.Write(_localClient.PlayerProfile.PlayerID);

        _server = new ServerInfo()
        {
            ServerType = serverType,
            MapID = mapId
        };

        _isServerConnectionCrucial = isCrucial;

        Log("Connecting to server at: " + serverEndPoint);

        StatusOverlay.ShowStatus(Localizer.GetString("status.connecting"));

        _server.Connection = _netPeer.Connect(serverEndPoint, localHail);
        _server.Connection.Tag = _server;
    }

    public void DisconnectFromServer ()
    {
        if (_server == null)
            return;

        if (PreDisconnectFromServer != null)
            PreDisconnectFromServer();

        Log("Unsyncing from server...");

        Sync.UnsyncClient();

        Log("Unsynced from server.");

        if (_server.Connection.Status == NetConnectionStatus.Connected)
        {
            Log("Disconnecting from server...");

            _server.Connection.Disconnect("");

            Log("Disconnected from server.");
        }

        _clientsByPeerIndex.Clear();
        _clientsById.Clear();

        _isConnectedToServer = false;
        _server = null;
    }

    public void PullWorldData (string pageName, WorldDataReceivedHandler callback, bool useCache = false)
    {
        if (useCache)
        {
            var cachedDataPage = GetCachedWorldData(pageName);

            if (cachedDataPage != null && callback != null)
            {
                callback(cachedDataPage);
                return;
            }
        }

        Log("Pulling world data page: " + pageName);

        List<WorldDataReceivedHandler> callbacksByPage = null;

        if (!_worldDataRequests.TryGetValue(pageName, out callbacksByPage))
        {
            callbacksByPage = new List<WorldDataReceivedHandler>();
            _worldDataRequests.Add(pageName, callbacksByPage);
        }

        callbacksByPage.Add(callback);

        var worldDataPullMsg = _netPeer.CreateMessage();
        worldDataPullMsg.Write((byte)WorldServerMessageType.PullWorldData);
        worldDataPullMsg.Write(pageName);

        _worldServer.Connection.SendMessage(worldDataPullMsg, NetDeliveryMethod.ReliableOrdered, 0);
    }

    public string GetActionCaption (ControlsAction actionType)
    {
        if (actionType == ControlsAction.Back)
        {
            return Localizer.GetString("caption.quit_game");
        }

        return "";
    }
    
    public bool IsActionEnabled (ControlsAction actionType)
    {
        return true;
    }
    
    private void Quit ()
    {
        DisconnectFromServer();
        
        if (DisconnectedFromServer != null)
            DisconnectedFromServer();
        
        if (_isServerConnectionCrucial)
        {
#if UNITY_EDITOR
            UnityEditor.EditorApplication.isPlaying = false;
#else
            Application.Quit();
#endif
        }
        else FindServers(GameServerType.Zone, _localClient.PlayerProfile.Location.LastZoneMapID, true);
    }
    
    public UJeli GetCachedWorldData (string pageName)
    {
        UJeli dataPage = null;
        _worldDataCache.TryGetValue(pageName, out dataPage);
        return dataPage;
    }

    public bool ToggleFullScreen ()
    {
        bool newFullScreen = !_config.Video.FullScreen;
        Screen.SetResolution(_config.Video.Width, _config.Video.Height, newFullScreen);

        _config.Video.FullScreen = newFullScreen;
        _config.Video.Save();

        return newFullScreen;
    }

    public void SaveScreenshot ()
    {
        int numScreenshotsThisSecond = 1;
        string screenshotPath = null;

        do
        {
            screenshotPath = string.Format("{0}Screenshot_{1:yyyy-MM-dd_HH-mm-ss}_{2:00}.png",
                _screenshotsBase, DateTime.Now, numScreenshotsThisSecond);

            numScreenshotsThisSecond++;
        }
        while (File.Exists(screenshotPath));

        Application.CaptureScreenshot(screenshotPath);
    }

    private void LoadAndSyncMap (string mapId, int peerIndex)
    {
        StopCoroutine("LoadAndSyncMapAsync");
        StartCoroutine(LoadAndSyncMapAsync(mapId, peerIndex));
    }

    private IEnumerator LoadAndSyncMapAsync (string mapId, int peerIndex)
    {
        Log("Pulling map settings...");

        PullWorldData(MapID + "_settings", OnMapSettingsReceived);

        float settingsWaitTime = 0f;

        while (_mapSettings == null)
        {
            settingsWaitTime += .1f;

            if (settingsWaitTime >= 10f)
            {
                DisconnectFromWorldServer("error.map_settings_fail");
                yield break;
            }

            yield return new WaitForSeconds(.1f);
        }

        Log("Map settings received.");
        Log("Loading map: " + mapId);

        StatusOverlay.ShowStatus(Localizer.GetString("status.loading"));

        yield return Application.LoadLevelAsync(mapId);

        Log("Map loaded.");

        if (_server == null || _server.Connection.Status != NetConnectionStatus.Connected)
            yield break;

        StatusOverlay.ShowStatus(Localizer.GetString("status.syncing"));

        Log("Syncing to server...");

        Sync.BeginSyncClient(peerIndex);

        var syncMessage = _netPeer.CreateMessage();
        syncMessage.Write((byte)ServerMessageType.Custom);
        syncMessage.Write((byte)CustomServerMessageType.SyncWithClient);

        _server.Connection.SendMessage(syncMessage, NetDeliveryMethod.ReliableOrdered, 0);

        while (!Sync.IsMapSynced)
        {
            if (_server == null || _server.Connection.Status != NetConnectionStatus.Connected)
                yield break;

            yield return null;
        }

        foreach (var obj in _postSyncObjects)
        {
            if (Sync.GetObject(obj.ObjectIndex) == null)
            {
                try {Sync.ProcessPropagatedDownSpawn(obj.Info, obj.ObjectIndex, obj.IsNew);}
                
                catch (ArgumentException e)
                {
                    Debug.LogWarning(e.Message + "\n" + obj.Info.Prefab.name + ", " + obj.ObjectIndex +
                    " was skipped when spawning postSyncObjects due to it haveing already been spawned in an edge case.");
                }
            }
        }   
        
        _postSyncObjects.Clear();
        
        Log("Synced to server.");

        StatusOverlay.Hide();

        yield break;
    }

    internal void SendPlayerProfileOperation (GameMessage op)
    {
        var opMsg = _netPeer.CreateMessage();
        opMsg.Write((byte)CustomServerMessageType.PlayerProfileOperation);
        opMsg.Write(Game.LocalPeerIndex);
        opMsg.Write(op.Data);

        _worldServer.Connection.SendMessage(opMsg, NetDeliveryMethod.ReliableOrdered, 0);
    }

    void Update ()
    {
        UpdateScreenshot();
        UpdateNetwork();

#if UNITY_EDITOR
        if (Input.GetKey(KeyCode.LeftControl) && Input.GetKeyDown(KeyCode.Q))
        {
            DisconnectFromWorldServer();
            UnityEditor.EditorApplication.isPlaying = false;
        }
#endif
        if (Controls.GetActionHoldTime(ControlsAction.Back) > 3.0f)
        {
            Controls.ResetHoldTime(ControlsAction.Back);
            Quit();
        }
    }

    private void UpdateScreenshot ()
    {
        if (Input.GetKeyDown(_config.Controls.TakeScreenshot))
            SaveScreenshot();
    }

    int _lossyBytes = 0;

    IEnumerator ReportLossyBytes ()
    {
        float t = 0;
    
        while (true)
        {
            yield return new WaitForSeconds(1.0f);
            t += 1.0f;
            
            DebugManager.Log((float)_lossyBytes/t + " bytes/sec of lossy data.");
        }
    }

    private void UpdateNetwork ()
    {
        if (_netPeer.Status != NetPeerStatus.Running)
            return;

        if (Sync.IsMapSynced)
        {
            Sync.Step();
            
            foreach (var timelineMsg in Sync.TimelineManager.GetOutgoingMessages())
            {
                var timelineNetMsg = _netPeer.CreateMessage();
                timelineNetMsg.Write((byte)timelineMsg.MessageType);
                timelineNetMsg.Write(timelineMsg.Data);

                _server.Connection.SendMessage(
                    timelineNetMsg,
                    _timelineToNetDeliveryModes[timelineMsg.DeliveryMode],
                    0);
            }
        }

        var messages = new List<NetIncomingMessage>();
        _netPeer.ReadMessages(messages);

        foreach (var msg in messages)
        {
#if !UNITY_EDITOR
            try
            {
#endif
                if (msg.DeliveryMethod == NetDeliveryMethod.Unreliable)
                    _lossyBytes += msg.LengthBytes;

                ProcessNetMessage(msg);
#if !UNITY_EDITOR
            }
            catch (Exception e)
            {
                Log(string.Format("Network message exception. Message Type: {0}, Exception Type: {1}",
                    msg.MessageType, e.GetType()));
            }
#endif
        }

        _netPeer.Recycle(messages);
    }

    private void ProcessNetMessage (NetIncomingMessage msg)
    {
        if (msg.MessageType == NetIncomingMessageType.StatusChanged)
        {
            var newStatus = (NetConnectionStatus)msg.ReadByte();

            if (newStatus == NetConnectionStatus.Connected)
            {
                if (msg.SenderConnection.Tag == _server && _server != null)
                {
                    var remoteHail = msg.SenderConnection.RemoteHailMessage;

                    _localClient.PeerIndex = remoteHail.ReadInt32();

                    _clientsByPeerIndex.Add(_localClient.PeerIndex, _localClient);
                    _clientsById.Add(_localClient.PlayerID, _localClient);

                    _isConnectedToServer = true;

                    Log(string.Format("Connected to server. Type: {0}, Map: {1}",
                        _server.ServerType, _server.MapID));

                    Log("Peer index assigned: " + _localClient.PeerIndex);

                    if (ConnectedToServer != null)
                        ConnectedToServer();

                    LoadAndSyncMap(_server.MapID, _localClient.PeerIndex);
                }
            }
            else if (newStatus == NetConnectionStatus.Disconnected)
            {
                string reason = msg.ReadString();

                if (msg.SenderConnection.Tag == _worldServer && _worldServer != null)
                {
                    if (_isConnectedToWorldServer)
                    {
                        Log("Disconnected from world server.");
                        DisconnectFromWorldServer("error.world_disconnect");

                        if (DisconnectedFromWorldServer != null)
                            DisconnectedFromWorldServer();
                    }
                    else
                    {
                        Log("Failed to connect to world server.");

                        if (reason == "error.duplicate_player" ||
                            reason == "error.daily_limit_reached")
                        {
                            DisconnectFromWorldServer(reason);
                        }
                        else DisconnectFromWorldServer("error.world_connect_fail");

                        if (ConnectionToWorldServerFailed != null)
                            ConnectionToWorldServerFailed();
                    }
                }
                else if (msg.SenderConnection.Tag == _server && _server != null)
                {
                    if (_isConnectedToServer)
                    {
                        Log("Disconnected from server.");
                        DisconnectFromServer();

                        if (DisconnectedFromServer != null)
                            DisconnectedFromServer();

                        if (_isServerConnectionCrucial)
                        {
                            DisconnectFromWorldServer("error.server_disconnect");
                        }
                        else FindServers(GameServerType.Zone, _localClient.PlayerProfile.Location.LastZoneMapID, true);
                    }
                    else
                    {
                        Log("Failed to connect to server.");
                        DisconnectFromServer();

                        if (ConnectionToServerFailed != null)
                            ConnectionToServerFailed();

                        if (_isServerConnectionCrucial)
                        {
                            if (reason == "error.duplicate_player")
                                DisconnectFromWorldServer(reason);
                            else DisconnectFromWorldServer("error.server_connect_fail");
                        }
                        else FindServers(GameServerType.Zone, _localClient.PlayerProfile.Location.LastZoneMapID, true);
                    }
                }
            }
        }
        else if (msg.MessageType == NetIncomingMessageType.Data)
        {
            byte messageTypeByte = msg.ReadByte();

            if (messageTypeByte >= (byte)TimelineMessageType.ManagerMessageBase)
            {
                if (!_isConnectedToServer)
                    return;

                var timelineMessageType = (TimelineMessageType)messageTypeByte;
                var timelineMsg = new TimelineMessage(
                    timelineMessageType,
                    msg.ReadBytes(msg.LengthBytes - msg.PositionInBytes),
                    _netToTimelineDeliveryModes[msg.DeliveryMethod]);

                Sync.TimelineManager.ProcessIncomingMessage(timelineMsg);
            }
            else
            {
                var clientMessageType = (ClientMessageType)messageTypeByte;

                if (clientMessageType == ClientMessageType.ClientInitialization)
                {
                    _isConnectedToWorldServer = true;

                    Log("Connected to world server.");

                    UJeli profileJeli = UJeli.Parse(msg.ReadString());
                    var localPlayerProfile = new PlayerProfile(_config.Network.PlayerID, profileJeli);

                    _localClient = new ClientInfo()
                    {
                        PlayerID = _config.Network.PlayerID,
                        PlayerProfile = localPlayerProfile
                    };

                    Log(string.Format("Received player profile. ID: {0}, Nickname: {1}",
                        _localClient.PlayerID, localPlayerProfile.Basic.Nickname));

                    if (ConnectedToWorldServer != null)
                        ConnectedToWorldServer();

                    if (!string.IsNullOrEmpty(_localClient.PlayerProfile.Location.LastZoneMapID))
                        FindServers(GameServerType.Zone, _localClient.PlayerProfile.Location.LastZoneMapID, true);
                }
                else if (clientMessageType == ClientMessageType.ServersFound)
                {
                    GameServerType serverType = (GameServerType)Enum.Parse(typeof(GameServerType), msg.ReadString(), true);
                    string mapId = msg.ReadString();
                    int numResults = msg.ReadInt32();

                    Log(string.Format("{0} server(s) found.", numResults));

                    if (numResults != 0)
                    {
                        IPEndPoint[] results = new IPEndPoint[numResults];

                        for (int i = 0; i < numResults; i++)
                        {
                            results[i] = msg.ReadIPEndPoint();
                        }

                        if (_server != null)
                        {
                            if (_server.ServerType == GameServerType.Minigame && serverType == GameServerType.Zone)
                            {
                                // If we're currently in a minigame, and we got a zone server search result,
                                // then this is probably the zone the player needs to return to,
                                // so we disconnect from our minigame server and connect to the zone server.
                                ConnectToServer(results[0], GameServerType.Zone, mapId, true);
                                return;
                            }
                        }
                        else
                        {
                            if (serverType == GameServerType.Zone)
                            {
                                // If we're not connected to a server, and we got a zone server search result,
                                // then this is probably the zone the player needs to spawn in, so we connect to it.
                                ConnectToServer(results[0], GameServerType.Zone, mapId, true);
                                return;
                            }
                        }

                        if (ServersFound != null)
                            ServersFound(serverType, mapId, results);
                    }
                    else
                    {
                        if (ServerSearchFailed != null)
                            ServerSearchFailed(serverType, mapId);

                        if (_isServerSearchCrucial)
                            DisconnectFromWorldServer("error.server_not_found");
                    }
                }
                else if (clientMessageType == ClientMessageType.ServerSpawned)
                {
                    GameServerType serverType = (GameServerType)Enum.Parse(typeof(GameServerType), msg.ReadString(), true);
                    string mapId = msg.ReadString();
                    IPEndPoint endPoint = msg.ReadIPEndPoint();

                    if (ServerSpawned != null)
                        ServerSpawned(serverType, mapId, endPoint);
                }
                else if (clientMessageType == ClientMessageType.ServerSpawnFailed)
                {
                    GameServerType serverType = (GameServerType)msg.ReadByte();
                    string mapId = msg.ReadString();

                    if (ServerSpawnFailed != null)
                        ServerSpawnFailed(serverType, mapId);
                }
                else if (clientMessageType == ClientMessageType.PlayerFound)
                {
                    string playerId = msg.ReadString();
                    bool found = msg.ReadBoolean();

                    if (found)
                    {
                        GameServerType serverType = (GameServerType)msg.ReadByte();
                        string mapId = msg.ReadString();
                        IPEndPoint serverEndPoint = msg.ReadIPEndPoint();

                        if (PlayerFound != null)
                            PlayerFound(playerId, serverType, mapId, serverEndPoint);
                    }
                    else
                    {
                        if (PlayerNotFound != null)
                            PlayerNotFound(playerId);
                    }
                }
                else if (clientMessageType == ClientMessageType.Custom)
                {
                    CustomClientMessageType customClientMessageType = (CustomClientMessageType)msg.ReadByte();

                    if (customClientMessageType == CustomClientMessageType.SyncedToServer)
                    {
                        Sync.FinishSyncClient();
                        UpdateNetwork();
                        
                        var syncFinishedMsg = _netPeer.CreateMessage();
                        syncFinishedMsg.Write((byte)ServerMessageType.Custom);
                        syncFinishedMsg.Write((byte)CustomServerMessageType.ClientFinishedSyncing);
                        
                        _server.Connection.SendMessage(syncFinishedMsg, NetDeliveryMethod.ReliableOrdered, 0);
                    }
                    else if (customClientMessageType == CustomClientMessageType.ExistingPlayers)
                    {
                        int numExistingPlayers = msg.ReadInt32();

                        for (int i = 0; i < numExistingPlayers; i++)
                        {
                            int peerIndex = msg.ReadInt32();
                            string playerId = msg.ReadString();
                            var playerProfile = new PlayerProfile(playerId, UJeli.Parse(msg.ReadString()));

                            if (_clientsByPeerIndex.ContainsKey(peerIndex))
                                return;

                            var otherClient = new ClientInfo()
                            {
                                PeerIndex = peerIndex,
                                PlayerID = playerId,
                                PlayerProfile = playerProfile
                            };

                            _clientsByPeerIndex.Add(peerIndex, otherClient);
                            _clientsById.Add(playerId, otherClient);

                            Log(string.Format("Received existing player info. Index: {0}, ID: {1}, Nickname: {2}",
                                peerIndex, playerId, playerProfile.Basic.Nickname));
                        }
                    }
                    else if (customClientMessageType == CustomClientMessageType.PlayerProfileOperation)
                    {
                        int peerIndex = msg.ReadInt32();

                        var profile = GetPlayerProfile(peerIndex);

                        if (profile == null)
                            return;

                        var profileOperation = new GameMessage();
                        profileOperation.Write(msg.ReadBytes(msg.LengthBytes - msg.PositionInBytes));

                        profile.ProcessIncomingOperation(profileOperation);
                    }
                    else if (customClientMessageType == CustomClientMessageType.SpawnObject)
                    {
                        var spawnInfo = new SpawnInfo();
                        spawnInfo.ReadFrom(msg);
                        int objectIndex = msg.ReadInt32();
                        
                        if (!Sync.IsMapSynced)
                        {
                            _postSyncObjects.Add(new ExtendedSpawnInfo(spawnInfo, objectIndex, true));
                            return;
                        }
                        
                        try {Sync.ProcessPropagatedDownSpawn(spawnInfo, objectIndex, true);}
                        
                        catch (ArgumentException e)
                        {
                            Debug.LogError(e.Message);
                            Debug.Log(spawnInfo.Prefab.name + ", " + objectIndex);
                        }
                    }
                    else if (customClientMessageType == CustomClientMessageType.SpawnExistingObject)
                    {
                        bool hasSpawnInfo = msg.ReadBoolean();
                        SpawnInfo spawnInfo = null;

                        if (hasSpawnInfo)
                        {
                            spawnInfo = new SpawnInfo();
                            spawnInfo.ReadFrom(msg);
                        }

                        int objectIndex = msg.ReadInt32();

                        try {Sync.ProcessPropagatedDownSpawn(spawnInfo, objectIndex, false);}
                        
                        catch (ArgumentException e)
                        {
                            Debug.LogWarning(e.Message);
                            Debug.Log(spawnInfo + ", " + objectIndex);
                        }
                    }
                    else if (customClientMessageType == CustomClientMessageType.ObjectSpawnRequestResponse)
                    {
                        int requestIndex = msg.ReadInt32();
                        int objectIndex = msg.ReadInt32();

                        Sync.ProcessSpawnRequestResponse(requestIndex, objectIndex);
                    }
                    else if (customClientMessageType == CustomClientMessageType.DespawnObject)
                    {
                        int objectIndex = msg.ReadInt32();

                        Sync.ProcessPropagatedDownDespawn(objectIndex);
                    }
                    else if (customClientMessageType == CustomClientMessageType.PlayerJoinedServer)
                    {
                        int peerIndex = msg.ReadInt32();
                        string playerId = msg.ReadString();
                        var playerProfile = new PlayerProfile(playerId, UJeli.Parse(msg.ReadString()));

                        var client = new ClientInfo()
                        {
                            PeerIndex = peerIndex,
                            PlayerID = playerId,
                            PlayerProfile = playerProfile
                        };

                        _clientsByPeerIndex.Add(peerIndex, client);
                        _clientsById.Add(playerId, client);

                        if (OtherPlayerJoinedServer != null)
                            OtherPlayerJoinedServer(peerIndex, playerProfile);
                    }
                    else if (customClientMessageType == CustomClientMessageType.PlayerLeftServer)
                    {
                        int peerIndex = msg.ReadInt32();

                        ClientInfo client = null;
                        _clientsByPeerIndex.TryGetValue(peerIndex, out client);

                        if (client != null)
                        {
                            _clientsByPeerIndex.Remove(peerIndex);
                            _clientsById.Remove(client.PlayerID);
                        }

                        if (OtherPlayerLeftServer != null)
                            OtherPlayerLeftServer(peerIndex, client.PlayerProfile);
                    }
                }
                else if (clientMessageType == ClientMessageType.WorldData)
                {
                    string pageName = msg.ReadString();
                    var worldDataPage = UJeli.Parse(msg.ReadString());
                    worldDataPage.Name = pageName;

                    Log("Received world data page: " + pageName);

                    _worldDataCache[pageName] = worldDataPage;

                    List<WorldDataReceivedHandler> callbacksByPage = null;

                    if (_worldDataRequests.TryGetValue(pageName, out callbacksByPage))
                    {
                        if (callbacksByPage.Count > 0)
                        {
                            callbacksByPage[0](worldDataPage);
                            callbacksByPage.RemoveAt(0);
                        }
                    }
                }
            }
        }
        else if (msg.MessageType == NetIncomingMessageType.UnconnectedData)
        {
            var clientMessageType = (ClientMessageType)msg.ReadByte();

            if (clientMessageType == ClientMessageType.Custom)
            {
                var customClientMessageType = (CustomClientMessageType)msg.ReadByte();

                if (customClientMessageType == CustomClientMessageType.ServerSummary)
                {
                    var serverSummary = new GameServerSummary();

                    int requestIndex = msg.ReadInt32();

                    if (!_serverSummaryRequestTimes.ContainsKey(requestIndex))
                        return;

                    serverSummary.EndPoint = msg.SenderEndPoint;
                    serverSummary.RTT = (float)DateTime.Now.Subtract(_serverSummaryRequestTimes[requestIndex]).TotalSeconds;
                    serverSummary.ServerType = (GameServerType)msg.ReadByte();
                    serverSummary.MapID = msg.ReadString();
                    serverSummary.MaxPlayers = msg.ReadInt32();
                    serverSummary.PlayerProfiles = new PlayerProfile[msg.ReadInt32()];

                    for (int i = 0; i < serverSummary.PlayerProfiles.Length; i++)
                    {
                        // TODO: Server Summaries should include player IDs somehow.
                        serverSummary.PlayerProfiles[i] = new PlayerProfile(msg.ReadString(), UJeli.Parse(msg.ReadString()));
                    }

                    if (ServerSummaryReceived != null)
                        ServerSummaryReceived(serverSummary);

                    _serverSummaryRequestTimes.Remove(requestIndex);
                }
            }
        }
    }

    private void OnMapSettingsReceived (UJeli mapSettings)
    {
        _mapSettings = mapSettings;

        if (_mapSettings.HasChild("SpawnDetailsTemplates"))
        {
            var spawnDetailsTemplatesJeli = _mapSettings["SpawnDetailsTemplates"];

            foreach (var templateJeli in spawnDetailsTemplatesJeli.Children)
            {
                Sync.SetSpawnDetailsTemplate(templateJeli.Name, templateJeli);
            }
        }
    }

    private void OnPropagateSpawnUp (int requestIndex, SpawnInfo spawnInfo)
    {
        var spawnMsg = _netPeer.CreateMessage();
        spawnMsg.Write((byte)ServerMessageType.Custom);
        spawnMsg.Write((byte)CustomServerMessageType.SpawnObject);
        spawnMsg.Write(requestIndex);
        spawnInfo.WriteTo(spawnMsg);

        _server.Connection.SendMessage(spawnMsg, NetDeliveryMethod.ReliableOrdered, 0);
    }

    private void OnPropagateDespawnUp (int objectIndex)
    {
        StartCoroutine(PropagateDespawnUpAsync(objectIndex));
    }

    private IEnumerator PropagateDespawnUpAsync (int objectIndex)
    {
        yield return null;
        yield return null;

        var despawnMsg = _netPeer.CreateMessage();
        despawnMsg.Write((byte)ServerMessageType.Custom);
        despawnMsg.Write((byte)CustomServerMessageType.DespawnObject);
        despawnMsg.Write(objectIndex);

        _server.Connection.SendMessage(despawnMsg, NetDeliveryMethod.ReliableOrdered, 0);
    }

    void OnDestroy ()
    {
        DisconnectFromServer();
        DisconnectFromWorldServer();

        Log("Client shutting down...");

        _logWriter.Dispose();

        _instance = null;
    }
}