GameServer.cs

using UnityEngine;
#if UNITY_EDITOR
using UnityEditor;
#endif
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 LiberiNet;
using Janus;

public class GameServer : MonoBehaviour
{
    private class WorldServerInfo
    {
        public NetConnection Connection;
    }

    private class ClientInfo
    {
        public NetConnection Connection;
        public string PlayerID;
        public PlayerProfile PlayerProfile;
        public int PeerIndex;
        public ClientSyncJob SyncJob;
    }

    private class ClientSyncJob
    {
        public ClientInfo Client;
        public List<int> ExistingObjectIndices = new List<int>();
    }

    public delegate void ConnectedToWorldServerHandler ();
    public delegate void PlayerJoinedServerHandler (int peerIndex, string playerId, PlayerProfile playerProfile);
    public delegate void PlayerSyncedHandler (int peerIndex, string playerId, PlayerProfile playerProfile);
    public delegate void PlayerLeftServerHandler (int peerIndex, string playerId, PlayerProfile playerProfile);
    public delegate void PlayerJoinedWorldServerHandler (string playerId, string playerNickname);
    public delegate void PlayerLeftWorldServerHandler (string playerId, string playerNickname);
    public delegate void WorldDataReceivedHandler (UJeli worldDataPage);
    public delegate void ServerSpawnedHandler (GameServerType serverType, string mapId, IPEndPoint endPoint);
    public delegate void ServerSpawnFailedHandler (GameServerType serverType, string mapId);
    public delegate void ServerSyncFinishedHandler ();

#pragma warning disable 0067
    public event ConnectedToWorldServerHandler ConnectedToWorldServer = delegate { };
    public event PlayerJoinedServerHandler PlayerJoinedServer = delegate { };
    public event PlayerSyncedHandler PlayerSynced = delegate { };
    public event PlayerLeftServerHandler PlayerLeftServer = delegate { };
    public event PlayerJoinedWorldServerHandler PlayerJoinedWorldServer = delegate { };
    public event PlayerLeftWorldServerHandler PlayerLeftWorldServer = delegate { };
    public event ServerSpawnedHandler ServerSpawned = delegate { };
    public event ServerSpawnFailedHandler ServerSpawnFailed = delegate { };
    public event ServerSyncFinishedHandler ServerSyncFinished = delegate { };
#pragma warning restore 0067

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

    public int ServerPoolIndex
    {
        get { return _serverPoolIndex; }
    }

    public bool IsPooled
    {
        get { return _serverPoolIndex != -1; }
    }

    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 bool IsConnectedToWorldServer
    {
        get { return _isConnectedToWorldServer; }
    }

    static GameServer _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 int Width;
    public int Height;
    public string WorldID;
    public GameServerType ServerType;
    public string MapID;

    string _logsBase;
    StreamWriter _logWriter;
    int _serverPoolIndex;
    int _requestIndex;
    NetPeer _netPeer;
    WorldServerInfo _worldServer;
    bool _isConnectedToWorldServer;
    UJeli _mapSettings;
    Dictionary<int, ClientInfo> _clientsByPeerIndex;
    Dictionary<string, ClientInfo> _clientsById;
    int _nextClientPeerIndex;
    Dictionary<string, List<WorldDataReceivedHandler>> _worldDataRequests;
    Dictionary<string, UJeli> _worldDataCache;
#if UNITY_EDITOR
    List<string> _availableZoneMaps;
    List<string> _availableMinigameMaps;
#endif

    void Awake ()
    {
        _instance = this;

        DontDestroyOnLoad(this);

        if (Application.platform == RuntimePlatform.OSXPlayer)
        {
            _logsBase = Path.GetFullPath(Application.dataPath + "/Logs/");
        }
        else
        {
            _logsBase = Path.GetFullPath("Logs/");
        }

        var flags = CommandLineUtils.GetCommandLineFlags();

        if (flags.ContainsKey("zone"))
        {
            ServerType = GameServerType.Zone;
            MapID = flags["zone"];
        }
        else if (flags.ContainsKey("minigame"))
        {
            ServerType = GameServerType.Minigame;
            MapID = flags["minigame"];
        }

        if (flags.ContainsKey("world"))
            WorldID = flags["world"];

        _serverPoolIndex = -1;
        _requestIndex = -1;

        if (flags.ContainsKey("pool"))
        {
            try { _serverPoolIndex = int.Parse(flags["pool"]); }
            catch { }

            if (flags.ContainsKey("request"))
            {
                try { _requestIndex = int.Parse(flags["request"]); }
                catch { }
            }
        }

        var netPeerConfig = new NetPeerConfiguration("Liberi");
        netPeerConfig.AcceptIncomingConnections = true;
        netPeerConfig.MaximumConnections = 32;
        netPeerConfig.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
        netPeerConfig.EnableMessageType(NetIncomingMessageType.UnconnectedData);

        if (flags.ContainsKey("port"))
        {
            try { netPeerConfig.Port = int.Parse(flags["port"]); }
            catch { netPeerConfig.Port = WorldNetUtils.GetFirstFreePort(34444); }
        }
        else netPeerConfig.Port = WorldNetUtils.GetFirstFreePort(34444);

        if (flags.ContainsKey("maxplayers"))
        {
            try { netPeerConfig.MaximumConnections = int.Parse(flags["maxplayers"]); }
            catch { }
        }

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

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

        Sync.PropagateSpawnDown += OnPropagateSpawnDown;
        Sync.PropagateDespawnDown += OnPropagateDespawnDown;

        Sync.Initialize();

#if UNITY_EDITOR

        _availableZoneMaps = new List<string>();
        _availableMinigameMaps = new List<string>();

        foreach (var scene in EditorBuildSettings.scenes)
        {
            if (scene.enabled)
            {
                if (scene.path.Contains("/Zones/"))
                    _availableZoneMaps.Add(Path.GetFileNameWithoutExtension(scene.path));
                else if (scene.path.Contains("/Minigames/"))
                    _availableMinigameMaps.Add(Path.GetFileNameWithoutExtension(scene.path));
            }
        }
#endif
    }

    void OnGUI ()
    {
#if UNITY_EDITOR
        if (_isConnectedToWorldServer)
            return;

        GUILayout.BeginArea(new Rect(5, 5, 200, Screen.height - 10), "Zones:", GUI.skin.box);
        {
            GUILayout.Space(20);

            foreach (var map in _availableZoneMaps)
            {
                if (GUILayout.Button(map))
                {
                    ServerType = GameServerType.Zone;
                    MapID = map;
                    Initialize();
                    return;
                }
            }
        }
        GUILayout.EndArea();

        GUILayout.BeginArea(new Rect(210, 5, 200, Screen.height - 10), "Minigames:", GUI.skin.box);
        {
            GUILayout.Space(20);

            foreach (var map in _availableMinigameMaps)
            {
                if (GUILayout.Button(map))
                {
                    ServerType = GameServerType.Minigame;
                    MapID = map;
                    Initialize();
                    return;
                }
            }
        }
        GUILayout.EndArea();
#endif
    }

    void Start ()
    {
        Screen.SetResolution(Width, Height, false);
        Screen.showCursor = true;

        Directory.CreateDirectory(_logsBase);

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

#if !UNITY_EDITOR
        Initialize();
#endif
    }

    void Initialize ()
    {
        Log(string.Format("Server initializing... Type: {0}, Map: {1}, Pooled: {2}",
            ServerType, MapID, IsPooled ? "Yes" : "No"));

        ConnectToWorldServer();
    }

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

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

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

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

        Log("Network started. Port: " + _netPeer.Configuration.Port);

        IPEndPoint worldEndPoint = null;

        if (string.IsNullOrEmpty(WorldID))
            WorldID = "localhost";
        
        IPAddress ipAddress = null; 
        IPAddress.TryParse(WorldID, out ipAddress);

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

        if (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(WorldID);

        if (worldEndPoint == null)
        {
            Log("Failed to find world server.");
            Application.Quit();
            return;
        }

        Log("World server found.");

        var localHail = _netPeer.CreateMessage();
        localHail.Write((byte)WorldServerMessageType.RegisterServer);
        localHail.Write(ServerType.ToString().ToLower());
        localHail.Write(MapID);
        localHail.Write(_netPeer.Configuration.MaximumConnections);
        localHail.Write(_serverPoolIndex);

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

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

    private void NotifyWorldServerReady ()
    {
        var readyMsg = _netPeer.CreateMessage();
        readyMsg.Write((byte)WorldServerMessageType.ServerReady);
        readyMsg.Write(_serverPoolIndex);

        if (IsPooled)
            readyMsg.Write(_requestIndex);

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

    private IEnumerator LoadAndSyncMapAsync ()
    {
        Log("Pulling map settings...");

        PullWorldData(MapID + "_settings", OnMapSettingsReceived);

        float settingsWaitTime = 0f;

        while (_mapSettings == null)
        {
            settingsWaitTime += Time.deltaTime;

            if (settingsWaitTime >= 10f)
            {
                Abort("Failed to load map settings.");
                yield break;
            }

            yield return new WaitForSeconds(.1f);
        }

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

        yield return Application.LoadLevelAsync(MapID);

        Log("Map loaded.");
        Log("Syncing...");

        Sync.SyncServer();

        Log("Synced.");

        ServerSyncFinished();

        _nextClientPeerIndex = 1;

        NotifyWorldServerReady();

        yield break;
    }

    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 UJeli GetCachedWorldData (string pageName)
    {
        UJeli dataPage = null;
        _worldDataCache.TryGetValue(pageName, out dataPage);
        return dataPage;
    }

    public void PushWorldData (string pageName, UJeli pageContents)
    {
        Log("Pushing world data page: " + pageName);

        _worldDataCache[pageName] = pageContents;

        var pushMsg = _netPeer.CreateMessage();
        pushMsg.Write((byte)WorldServerMessageType.PushWorldData);
        pushMsg.Write(pageName);
        pushMsg.Write(pageContents.ToString());

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

    public void PushPlayerData (string playerid, string tablePath, string propertyName, string propertyValue)
    {
        PushPlayerData(
            new PlayerDataChange() {
                PlayerID = playerid,
                TablePath = tablePath,
                PropertyName = propertyName,
                PropertyValue = propertyValue
                });
    }

    public void PushPlayerData (params PlayerDataChange[] changes)
    {
        var pushMsg = _netPeer.CreateMessage();
        pushMsg.Write((byte)WorldServerMessageType.PushPlayerData);
        pushMsg.Write(changes.Length);

        foreach (var change in changes)
        {
            pushMsg.Write(change.PlayerID);
            pushMsg.Write(change.TablePath);
            pushMsg.Write(change.PropertyName);
            pushMsg.Write(change.PropertyValue);
        }

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

    internal void SendPlayerProfileOperation (PlayerProfile profile, GameMessage op, bool sendToAllClients = false)
    {
        ClientInfo client = null;

        if (!_clientsById.TryGetValue(profile.PlayerID, out client))
            return;

        var opMsg = _netPeer.CreateMessage();
        opMsg.Write((byte)ClientMessageType.Custom);
        opMsg.Write((byte)CustomClientMessageType.PlayerProfileOperation);
        opMsg.Write(client.PeerIndex);
        opMsg.Write(op.Data);

        if (sendToAllClients)
        {
            var recipients = _clientsByPeerIndex.Values.Select(c => c.Connection).ToList();

            if (recipients.Count > 0)
                _netPeer.SendMessage(opMsg, recipients, NetDeliveryMethod.ReliableOrdered, 0);
        }
        else client.Connection.SendMessage(opMsg, NetDeliveryMethod.ReliableOrdered, 0);
    }

    private void AddClient (ClientInfo client)
    {
        _clientsByPeerIndex[client.PeerIndex] = client;
        _clientsById[client.PlayerID] = client;

        Log(string.Format("Client added. Index: {0}, ID: {1}", client.PeerIndex, client.PlayerID));
    }

    private void RemoveClient (ClientInfo client)
    {
        _clientsByPeerIndex.Remove(client.PeerIndex);
        _clientsById.Remove(client.PlayerID);

        Log("Client " + client.PeerIndex + " removed.");
    }

    void Update ()
    {
        UpdateNetwork();

#if UNITY_EDITOR
        if (Input.GetKey(KeyCode.LeftControl) && Input.GetKeyDown(KeyCode.Q))
        {
            DisconnectFromWorldServer();
            UnityEditor.EditorApplication.isPlaying = false;
        }
#endif
    }

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

        if (Sync.IsMapSynced)
        {
            Sync.Step();

            foreach (var client in _clientsByPeerIndex.Values)
            {
                foreach (var timelineMsg in Sync.TimelineSynchronizer.GetOutgoingMessages((ushort)client.PeerIndex))
                {
                    var timelineNetMsg = _netPeer.CreateMessage();
                    timelineNetMsg.Write((byte)timelineMsg.MessageType);
                    timelineNetMsg.Write(timelineMsg.Data);

                    client.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
                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.ConnectionApproval)
        {
            Log("Client connecting from: " + msg.SenderConnection.RemoteEndPoint);

            ClientInfo client = new ClientInfo()
            {
                Connection = msg.SenderConnection,
                PlayerID = msg.ReadString(),
                PeerIndex = _nextClientPeerIndex
            };

            if (_clientsById.ContainsKey(client.PlayerID))
            {
                Log("Duplicate client kicked. ID: " + client.PlayerID);
                msg.SenderConnection.Deny("error.duplicate_player");
                return;
            }

            AddClient(client);

            var localHail = _netPeer.CreateMessage();
            localHail.Write(client.PeerIndex);

            msg.SenderConnection.Tag = client;
            msg.SenderConnection.Approve(localHail);

            var worldNotification = _netPeer.CreateMessage();
            worldNotification.Write((byte)WorldServerMessageType.PlayerJoinedServer);
            worldNotification.Write(client.PlayerID);

            _worldServer.Connection.SendMessage(worldNotification, NetDeliveryMethod.ReliableOrdered, 0);

            _nextClientPeerIndex++;
        }
        else if (msg.MessageType == NetIncomingMessageType.StatusChanged)
        {
            var newStatus = (NetConnectionStatus)msg.ReadByte();

            if (newStatus == NetConnectionStatus.Connected)
            {
                var remoteHail = msg.SenderConnection.RemoteHailMessage;

                var serverMessageType = (ServerMessageType)remoteHail.ReadByte();

                if (serverMessageType == ServerMessageType.ServerInitialization)
                {
                    if (msg.SenderConnection.Tag == _worldServer && _worldServer != null)
                    {
                        _isConnectedToWorldServer = true;

                        if (ConnectedToWorldServer != null)
                            ConnectedToWorldServer();

                        Log("Connected to world server.");

                        StartCoroutine(LoadAndSyncMapAsync());
                    }
                }
            }
            else if (newStatus == NetConnectionStatus.Disconnected)
            {
                if (msg.SenderConnection.Tag == _worldServer && _worldServer != null)
                {
                    if (_isConnectedToWorldServer)
                        Abort("Disconnected from world server.");
                    else Abort("Failed to connect to world server.");
                }
                else if (msg.SenderConnection.Tag is ClientInfo)
                {
                    var client = (ClientInfo)msg.SenderConnection.Tag;

                    Sync.UnregisterClient(client.PeerIndex);

                    RemoveClient(client);

                    var worldNotification = _netPeer.CreateMessage();
                    worldNotification.Write((byte)WorldServerMessageType.PlayerLeftServer);
                    worldNotification.Write(client.PlayerID);

                    _worldServer.Connection.SendMessage(worldNotification, NetDeliveryMethod.ReliableOrdered, 0);

                    if (PlayerLeftServer != null)
                        PlayerLeftServer(client.PeerIndex, client.PlayerID, client.PlayerProfile);

                    var otherClientConnections = new List<NetConnection>();

                    foreach (var otherClient in _clientsByPeerIndex.Values)
                    {
                        if (otherClient != client)
                            otherClientConnections.Add(otherClient.Connection);
                    }

                    if (otherClientConnections.Count > 0)
                    {
                        var clientNotification = _netPeer.CreateMessage();
                        clientNotification.Write((byte)ClientMessageType.Custom);
                        clientNotification.Write((byte)CustomClientMessageType.PlayerLeftServer);
                        clientNotification.Write(client.PeerIndex);

                        _netPeer.SendMessage(clientNotification, otherClientConnections, NetDeliveryMethod.ReliableOrdered, 0);
                    }

                    if (ServerType == GameServerType.Minigame && _clientsById.Count == 0)
                    {
#if UNITY_EDITOR
                        UnityEditor.EditorApplication.isPlaying = false;
#else
                        Application.Quit();
#endif
                    }
                }
            }
        }
        else if (msg.MessageType == NetIncomingMessageType.Data)
        {
            byte messageTypeByte = msg.ReadByte();

            if (messageTypeByte >= (byte)TimelineMessageType.SyncerMessageBase)
            {
                var timelineMessageType = (TimelineMessageType)messageTypeByte;

                int peerIndex = ((ClientInfo)msg.SenderConnection.Tag).PeerIndex;

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

                Sync.TimelineSynchronizer.ProcessIncomingMessage((ushort)peerIndex, timelineMsg);
            }
            else
            {
                var serverMessageType = (ServerMessageType)messageTypeByte;

                if (serverMessageType == ServerMessageType.PlayerData)
                {
                    string playerId = msg.ReadString();
                    var playerProfile = new PlayerProfile(playerId, UJeli.Parse(msg.ReadString()));
                    var client = _clientsById[playerId];
                    client.PlayerProfile = playerProfile;

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

                    if (PlayerJoinedServer != null)
                        PlayerJoinedServer(client.PeerIndex, client.PlayerID, playerProfile);

                    var otherClientConnections = new List<NetConnection>();

                    foreach (var otherClient in _clientsByPeerIndex.Values)
                    {
                        if (otherClient != client)
                            otherClientConnections.Add(otherClient.Connection);
                    }

                    if (otherClientConnections.Count > 0)
                    {
                        var clientNotification = _netPeer.CreateMessage();
                        clientNotification.Write((byte)ClientMessageType.Custom);
                        clientNotification.Write((byte)CustomClientMessageType.PlayerJoinedServer);
                        clientNotification.Write(client.PeerIndex);
                        clientNotification.Write(client.PlayerID);
                        
                        clientNotification.Write(playerProfile.ToString());

                        _netPeer.SendMessage(clientNotification, otherClientConnections, NetDeliveryMethod.ReliableOrdered, 0);
                    }
                }
                else if (serverMessageType == ServerMessageType.PlayerJoinedWorldServer)
                {
                    // TODO: Handle player joined world server event.
                }
                else if (serverMessageType == ServerMessageType.PlayerLeftWorldServer)
                {
                    // TODO: Handle player left world server event.
                }
                else if (serverMessageType == ServerMessageType.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 (serverMessageType == ServerMessageType.ServerSpawnFailed)
                {
                    GameServerType serverType = (GameServerType)msg.ReadByte();
                    string mapId = msg.ReadString();
                    
                    if (ServerSpawnFailed != null)
                        ServerSpawnFailed(serverType, mapId);
                }
                else if (serverMessageType == ServerMessageType.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))
                    {
                        while (callbacksByPage.Count > 0)
                        {
                            callbacksByPage[0](worldDataPage);
                            callbacksByPage.RemoveAt(0);
                        }
                    }
                }
                else if (serverMessageType == ServerMessageType.Custom)
                {
                    var customServerMessageType = (CustomServerMessageType)msg.ReadByte();

                    if (customServerMessageType == CustomServerMessageType.SyncWithClient)
                    {
                        var client = (ClientInfo)msg.SenderConnection.Tag;

                        var syncJob = new ClientSyncJob()
                        {
                            Client = client
                        };

                        client.SyncJob = syncJob;

                        Sync.RegisterClient(client.PeerIndex, msg.SenderConnection.AverageRoundtripTime);

                        StartCoroutine(SyncWithClientAsync(syncJob));
                    }
                    else if (customServerMessageType == CustomServerMessageType.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 (customServerMessageType == CustomServerMessageType.SpawnObject)
                    {
                        int requesterIndex = ((ClientInfo)msg.SenderConnection.Tag).PeerIndex;
                        int requestIndex = msg.ReadInt32();
                        var spawnInfo = new SpawnInfo();
                        spawnInfo.ReadFrom(msg);

                        Sync.ProcessPropagatedUpSpawn(requesterIndex, requestIndex, spawnInfo);
                    }
                    else if (customServerMessageType == CustomServerMessageType.DespawnObject)
                    {
                        int requesterIndex = ((ClientInfo)msg.SenderConnection.Tag).PeerIndex;
                        int objectIndex = msg.ReadInt32();

                        Sync.ProcessPropagatedUpDespawn(requesterIndex, objectIndex);
                    }
                    else if (customServerMessageType == CustomServerMessageType.ClientFinishedSyncing)
                    {
                        var client = (ClientInfo)msg.SenderConnection.Tag;
                        
                        Log("Client " + client.PeerIndex + " synced.");
                        
                        if (PlayerSynced != null)
                            PlayerSynced(client.PeerIndex, client.PlayerID, client.PlayerProfile);
                    }
                }
            }
        }
        else if (msg.MessageType == NetIncomingMessageType.UnconnectedData)
        {
            var serverMessageType = (ServerMessageType)msg.ReadByte();
            
            if (serverMessageType == ServerMessageType.Custom)
            {       
                var customServerMessageType = (CustomServerMessageType)msg.ReadByte();
    
                if (customServerMessageType == CustomServerMessageType.SummaryRequest)
                {
                    int requestIndex = msg.ReadInt32();
    
                    var summaryMsg = _netPeer.CreateMessage();
    
                    summaryMsg.Write((byte)ClientMessageType.Custom);
                    summaryMsg.Write((byte)CustomClientMessageType.ServerSummary);
                    summaryMsg.Write(requestIndex);
                    summaryMsg.Write((byte)ServerType);
                    summaryMsg.Write(MapID);
    
                    if (ServerType == GameServerType.Minigame)
                        summaryMsg.Write(Minigame.Instance.MaxPlayers);
                    else summaryMsg.Write(_netPeer.Configuration.MaximumConnections);
    
                    var playerClients = _clientsById.Values.Where(
                                            c => c != null &&
                                            c.PlayerProfile != null &&
                                            !c.PlayerProfile.Basic.IsMonitor)
                                            .ToArray();
    
                    summaryMsg.Write(playerClients.Length);
    
                    foreach (var client in playerClients)
                    {
                        summaryMsg.Write(client.PlayerID);
                        summaryMsg.Write(client.PlayerProfile.Basic.ToString());
                    }
    
                    _netPeer.SendUnconnectedMessage(summaryMsg, msg.SenderEndPoint);
                }
            }
        }
    }

    private IEnumerator SyncWithClientAsync (ClientSyncJob syncJob)
    {
        ClientInfo client = syncJob.Client;

        Log("Syncing client " + client.PeerIndex + "...");

        if (_clientsByPeerIndex.Count > 1)
        {
            var existingPlayersMsg = _netPeer.CreateMessage();
            existingPlayersMsg.Write((byte)ClientMessageType.Custom);
            existingPlayersMsg.Write((byte)CustomClientMessageType.ExistingPlayers);
            existingPlayersMsg.Write(_clientsByPeerIndex.Count - 1);

            foreach (var otherClient in _clientsByPeerIndex.Values)
            {
                if (otherClient == client)
                    continue;

                existingPlayersMsg.Write(otherClient.PeerIndex);
                existingPlayersMsg.Write(otherClient.PlayerID);
                existingPlayersMsg.Write(otherClient.PlayerProfile.ToString());
            }

            client.Connection.SendMessage(existingPlayersMsg, NetDeliveryMethod.ReliableOrdered, 0);
        }

        yield return null;

        syncJob.ExistingObjectIndices = new List<int>(Sync.ObjectIndices);

        while (syncJob.ExistingObjectIndices.Count > 0)
        {
            if (client.Connection.Status != NetConnectionStatus.Connected)
                yield break;

            int objectIndex = syncJob.ExistingObjectIndices[0];
            syncJob.ExistingObjectIndices.RemoveAt(0);
            
            GameObject existingObject = Sync.GetObject(objectIndex);

            if (existingObject == null)
                continue;

            var spawnInfo = Sync.GetSpawnInfo(existingObject);

            var spawnMsg = _netPeer.CreateMessage();
            spawnMsg.Write((byte)ClientMessageType.Custom);
            spawnMsg.Write((byte)CustomClientMessageType.SpawnExistingObject);
            spawnMsg.Write(spawnInfo != null);

            if (spawnInfo != null)
                spawnInfo.WriteTo(spawnMsg);
            
            spawnMsg.Write(objectIndex);

            client.Connection.SendMessage(spawnMsg, NetDeliveryMethod.ReliableOrdered, 0);

            yield return null;
        }

        client.SyncJob = null;

        if (client.Connection.Status == NetConnectionStatus.Connected)
        {
            var syncFinishedMsg = _netPeer.CreateMessage();
            syncFinishedMsg.Write((byte)ClientMessageType.Custom);
            syncFinishedMsg.Write((byte)CustomClientMessageType.SyncedToServer);

            client.Connection.SendMessage(syncFinishedMsg, NetDeliveryMethod.ReliableOrdered, 0);
        }

        yield break;
    }

    public void Abort (string error)
    {
        Log(error);

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

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

    void OnPropagateSpawnDown (int requesterIndex, int requestIndex, int objectIndex, SpawnInfo spawnInfo)
    {
        var responseMsg = _netPeer.CreateMessage();
        responseMsg.Write((byte)ClientMessageType.Custom);
        responseMsg.Write((byte)CustomClientMessageType.ObjectSpawnRequestResponse);
        responseMsg.Write(requestIndex);
        responseMsg.Write(objectIndex);

        var spawnMsg = _netPeer.CreateMessage();
        spawnMsg.Write((byte)ClientMessageType.Custom);
        spawnMsg.Write((byte)CustomClientMessageType.SpawnObject);
        spawnInfo.WriteTo(spawnMsg);
        spawnMsg.Write(objectIndex);

        NetConnection requesterConnection = null;
        
        if (requesterIndex > 0)
            requesterConnection = _clientsByPeerIndex[requesterIndex].Connection;

        List<NetConnection> otherConnections = new List<NetConnection>();

        foreach (var client in _clientsByPeerIndex.Values)
        {
            if (client.Connection != requesterConnection)
                otherConnections.Add(client.Connection);
        }

        if (requesterConnection != null)
            _netPeer.SendMessage(responseMsg, requesterConnection, NetDeliveryMethod.ReliableOrdered, 0);

        if (otherConnections.Count > 0)
            _netPeer.SendMessage(spawnMsg, otherConnections, NetDeliveryMethod.ReliableOrdered, 0);
    }

    private void OnPropagateDespawnDown (int requesterIndex, int objectIndex)
    {
        StartCoroutine(PropagateDespawnDownAsync(requesterIndex, objectIndex));
    }

    private IEnumerator PropagateDespawnDownAsync (int requesterIndex, int objectIndex)
    {
        yield return null;
        yield return null;

        var despawnMsg = _netPeer.CreateMessage();
        despawnMsg.Write((byte)ClientMessageType.Custom);
        despawnMsg.Write((byte)CustomClientMessageType.DespawnObject);
        despawnMsg.Write(objectIndex);

        NetConnection requesterConnection = null;

        if (requesterIndex > 0)
            requesterConnection = _clientsByPeerIndex[requesterIndex].Connection;

        List<NetConnection> otherConnections = new List<NetConnection>();

        foreach (var client in _clientsByPeerIndex.Values)
        {
            if (client.Connection != requesterConnection)
                otherConnections.Add(client.Connection);
        }

        if (otherConnections.Count > 0)
            _netPeer.SendMessage(despawnMsg, otherConnections, NetDeliveryMethod.ReliableOrdered, 0);
    }

    public void DisconnectFromWorldServer ()
    {
        _isConnectedToWorldServer = false;

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

            _netPeer.Shutdown("");

            Log("Network stopped.");
        }
    }

    void OnDestroy ()
    {
        DisconnectFromWorldServer();

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

        _logWriter.Dispose();

        _instance = null;
    }
}