Sync.Static.Internal.cs

using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Diagnostics;
using System.Reflection;
using Janus;

public delegate void PropagateSpawnUpHandler (int requestIndex, SpawnInfo spawnInfo);
public delegate void PropagateSpawnDownHandler (int requesterIndex, int requestIndex, int objectIndex, SpawnInfo spawnInfo);
public delegate void PropagateDespawnUpHandler (int objectIndex);
public delegate void PropagateDespawnDownHandler (int requesterIndex, int objectIndex);

public partial class Sync : MonoBehaviour
{
    public static event PropagateSpawnUpHandler PropagateSpawnUp;
    public static event PropagateSpawnDownHandler PropagateSpawnDown;
    public static event PropagateDespawnUpHandler PropagateDespawnUp;
    public static event PropagateDespawnDownHandler PropagateDespawnDown;

    static int _localPeerIndex = -1;
    static bool _isClient;
    static bool _isServer;
    static bool _isMapSynced;
    static bool _isMapUnsyncing;
    static TimelineManager _timelineManager;
    static TimelineSynchronizer _timelineSyncer;
    static Dictionary<string, GameObject> _spawnablePrefabs;
    static Dictionary<string, UJeli> _spawnDetailsTemplates;
    static Dictionary<int, Sync> _syncedObjects;
    static Dictionary<int, Sync> _syncingObjects;
    static Dictionary<int, Sync> _requestedObjects;
    static Dictionary<int, Sync> _syncingMapObjects;
    static int _nextSpawnRequestIndex;
    static int _nextObjectIndex;
    static int _timelineObjectIndex;
    static byte _timelineScriptIndex;
    static byte _nextTimelineIndex;

    internal static void Initialize ()
    {
        _spawnablePrefabs = new Dictionary<string, GameObject>();
        _spawnDetailsTemplates = new Dictionary<string, UJeli>();

        foreach (var prefab in Resources.LoadAll<GameObject>(""))
        {
            _spawnablePrefabs.Add(prefab.name, prefab);
        }

        _syncedObjects = new Dictionary<int, Sync>();
        _syncingObjects = new Dictionary<int, Sync>();
        _requestedObjects = new Dictionary<int, Sync>();
        _syncingMapObjects = new Dictionary<int, Sync>();
    }

    internal static void SetSpawnDetailsTemplate (string prefabId, UJeli spawnDetailsTemplate)
    {
        _spawnDetailsTemplates[prefabId] = spawnDetailsTemplate;
    }

    internal static void SyncServer ()
    {
        _isServer = true;
        _localPeerIndex = 0;

        _timelineManager = new TimelineManager();
        _timelineManager.ClockSyncCorrectionFactor = 50f;
        _timelineManager.MinClockSyncCorrectionRate = 50f;

        _timelineSyncer = new TimelineSynchronizer();
        _timelineSyncer.ClockSyncSamplingRule = ClockSyncSamplingRule.MostRecent;
        _timelineSyncer.ConnectPeer(0, 0);

        AddMapObjects();

        _isMapSynced = true;
    }

    internal static void BeginSyncClient (int peerIndex)
    {
        _isClient = true;
        _localPeerIndex = peerIndex;

        _timelineManager = new TimelineManager();
        _timelineManager.ClockSyncCorrectionFactor = 10f;
        _timelineManager.MinClockSyncCorrectionRate = 10f;
        
        _nextSpawnRequestIndex = 0;

        AddMapObjects();
    }

    internal static void FinishSyncClient ()
    {
        foreach (var sync in _syncingObjects.Values.ToArray())
        {
            if (sync._spawnInfo == null && !_syncingMapObjects.ContainsValue(sync))
            {
                _syncingObjects.Remove(sync._objectIndex);
                Destroy(sync.gameObject);
            }
        }

        _syncingMapObjects.Clear();

        _isMapSynced = true;
    }

    private static void AddMapObjects ()
    {
        var rootSyncsInScene = new List<Sync>(FindObjectsOfType<Sync>().Where(sync => sync.IsRoot));
        rootSyncsInScene.Sort((a, b) => a.name.CompareTo(b.name));

        _nextObjectIndex = -1;

        foreach (var sync in rootSyncsInScene)
        {
            SetObjectOwner(sync, 0);
        }

        foreach (var sync in rootSyncsInScene)
        {
            _nextObjectIndex++;
            SyncObject(sync, _nextObjectIndex, false);
        }
    }

    private static void RemoveMapObjects ()
    {
        var rootSyncsInScene = new List<Sync>(FindObjectsOfType<Sync>().Where(sync => sync.IsRoot));

        foreach (var sync in rootSyncsInScene)
        {
            if (sync._spawnInfo != null)
                continue;

            UnsyncObject(sync);
        }
    }

    internal static void RegisterClient (int peerIndex, float rtt)
    {
        _timelineSyncer.ConnectPeer((ushort)peerIndex, rtt);
    }

    internal static void UnregisterClient (int peerIndex)
    {
        DespawnPeerObjects(peerIndex);
        _timelineSyncer.DisconnectPeer((ushort)peerIndex);
    }

    internal static void Step ()
    {
        if (_isServer)
        {
            foreach (var timelineMsg in _timelineManager.GetOutgoingMessages())
            {
                _timelineSyncer.ProcessIncomingMessage(0, timelineMsg);
            }

            foreach (var timelineMsg in _timelineSyncer.GetOutgoingMessages(0))
            {
                _timelineManager.ProcessIncomingMessage(timelineMsg);
            }

            if (_timelineSyncer != null)
                _timelineSyncer.Step(Time.deltaTime);
        }

        _timelineManager.Step(Time.deltaTime);

        foreach (var sync in _syncingObjects.Values.ToArray())
        {
            bool synced = true;

            foreach (var essentialTimeline in sync._essentialTimelines)
            {
                if (essentialTimeline.NumEntries == 0)
                    synced = false;
            }

            if (synced)
                FinalizeObject(sync, true);
        }
    }

    internal static void UnsyncClient ()
    {   
        _isMapUnsyncing = true;

        foreach (var sync in _syncedObjects.Values.ToArray())
        {
            if (sync == null)
                continue;

            if (sync._spawnInfo != null)
            {
                UnsyncObject(sync);
                Destroy(sync.gameObject);
            }
        }

        RemoveMapObjects();

        _syncingObjects.Clear();
        _syncingMapObjects.Clear();
        _syncedObjects.Clear();
        _requestedObjects.Clear();

        _localPeerIndex = -1;
        _timelineManager = null;
        _isMapSynced = false;
        _isMapUnsyncing = false;
    }

    internal static void ProcessPropagatedUpSpawn (int requesterIndex, int requestIndex, SpawnInfo spawnInfo)
    {
        var sync = SpawnFromInfo(spawnInfo);

        _nextObjectIndex++;
        SyncObject(sync, _nextObjectIndex, true);

        if (PropagateSpawnDown != null)
            PropagateSpawnDown(requesterIndex, requestIndex, sync._objectIndex, spawnInfo);
    }

    internal static void ProcessPropagatedDownSpawn (SpawnInfo spawnInfo, int objectIndex, bool isNew)
    {
        Sync sync = null;
            
        if (spawnInfo != null)
        {
            sync = SpawnFromInfo(spawnInfo);
            SyncObject(sync, objectIndex, isNew);
        }
        else
        {
            _syncingObjects.TryGetValue(objectIndex, out sync);

            if (sync != null)
                _syncingMapObjects.Add(objectIndex, sync);
        }
    }

    internal static void ProcessSpawnRequestResponse (int requestIndex, int objectIndex)
    {
        Sync sync = null;

        if (!_requestedObjects.TryGetValue(requestIndex, out sync))
        {
            // This means that our spawn request was fulfilled, but we have already decided
            // to despawn the object before it was fully propagated to the rest of our peers.
            // Now it is our responsibility to tell the other peers that we have wasted their
            // time and that we're very sorry.
            if (PropagateDespawnUp != null)
                PropagateDespawnUp(objectIndex);

            return;
        }

        SyncObject(sync, objectIndex, true);
    }

    internal static void ProcessPropagatedUpDespawn (int requesterIndex, int objectIndex)
    {
        Sync sync = null;

        if (!_syncedObjects.TryGetValue(objectIndex, out sync))
            return;

        if (PropagateDespawnDown != null)
            PropagateDespawnDown(requesterIndex, objectIndex);

        NotifyDespawn(sync.gameObject);
        UnsyncObject(sync);
        Destroy(sync.gameObject);
    }

    internal static void ProcessPropagatedDownDespawn (int objectIndex)
    {
        Sync sync = null;

        if (!_syncedObjects.TryGetValue(objectIndex, out sync))
        {
            if (!_syncingObjects.TryGetValue(objectIndex, out sync))
                return;
        }

        NotifyDespawn(sync.gameObject);
        UnsyncObject(sync);
        Destroy(sync.gameObject);
    }

    private static GameObject SpawnShell (GameObject prefab, Vector3 position)
    {
        var go = (GameObject)Instantiate(prefab, position, prefab.transform.rotation);
        go.name = prefab.name;
        return go;
    }

    private static Sync SpawnFromInfo (SpawnInfo spawnInfo)
    {
        var go = SpawnShell(spawnInfo.Prefab, spawnInfo.Position);
        var sync = go.GetComponent<Sync>();

        if (spawnInfo.Direction != Vector3.zero)
            go.transform.SetDirection(spawnInfo.Direction);

        SetObjectOwner(sync, spawnInfo.OwnerPeerIndex);
        sync._spawnInfo = spawnInfo;

        return sync;
    }

    private static bool ShouldScriptExecute (Sync sync, ScriptRole scriptRole)
    {
        if (sync == null)
            return true;

        var isOwner = sync._ownerPeerIndex == _localPeerIndex;

        if (scriptRole == ScriptRole.Logic
            || scriptRole == ScriptRole.Owner)
        {
            return isOwner;
        }
        else if (scriptRole == ScriptRole.View
            || scriptRole == ScriptRole.Client)
        {
            return _isClient;
        }
        else if (scriptRole == ScriptRole.Secure
            || scriptRole == ScriptRole.Server)
        {
            return _isServer;
        }
        else if (scriptRole == ScriptRole.HumanBrain
            || scriptRole == ScriptRole.ClientOwner
            || scriptRole == ScriptRole.OwnerView)
        {
            return isOwner && _isClient;
        }
        else if (scriptRole == ScriptRole.BotBrain
            || scriptRole == ScriptRole.ServerOwner)
        {
            return isOwner && _isServer;
        }

        return false;
    }

    private static void SetObjectOwner (Sync sync, int ownerPeerIndex)
    {
        foreach (var childSync in sync.GetComponentsInChildren<Sync>())
        {
            childSync._ownerPeerIndex = ownerPeerIndex;
        }

        foreach (var mb in sync._originalBehaviours)
        {
            var mbType = mb.GetType();

            var scriptAttrs = mbType.GetCustomAttributes(typeof(ScriptAttribute), false);

            if (scriptAttrs.Length != 0)
            {
                var scriptAttr = (ScriptAttribute)scriptAttrs[0];
                mb.enabled = ShouldScriptExecute(sync, scriptAttr.ScriptRole);
            }
            else mb.enabled = true;
        }
    }

    private static void SyncObject (Sync sync, int objectIndex, bool isNew)
    {
        if (_timelineManager == null)
            return;
    
        foreach (var childSync in sync.GetComponentsInChildren<Sync>())
        {
            childSync._objectIndex = objectIndex;
        }
        
        if (Sync.GetObject(objectIndex) != null)
        {
            print (Sync.GetObject(objectIndex).name);
        }
        
        _syncingObjects.Add(objectIndex, sync);

        _timelineObjectIndex = objectIndex;
        _timelineScriptIndex = 0;

        foreach (var mb in sync._originalBehaviours)
        {
            _nextTimelineIndex = 0;

            sync._timelines.AddRange(_timelineManager.AddTimelines(mb, GenerateTimelineID));

            sync._essentialTimelines.AddRange(
                from timeline in sync._timelines
                where timeline.Tags.Contains("Essential")
                select timeline);

            _timelineScriptIndex++;
        }

        if (sync._ownerPeerIndex == _localPeerIndex)
            FinalizeObject(sync, isNew);
        else sync.gameObject.SetActive(false);
    }

    private static byte[] GenerateTimelineID (string s)
    {
        byte[] id = BuildTimelineID(_timelineObjectIndex, _timelineScriptIndex, _nextTimelineIndex);
        _nextTimelineIndex++;
        return id;
    }

    private static byte[] BuildTimelineID (int objectIndex, byte timelineScriptIndex, byte timelineIndex)
    {
        byte[] id = new byte[6];

        Buffer.BlockCopy(BitConverter.GetBytes(objectIndex), 0, id, 0, 4);
        id[4] = timelineScriptIndex;
        id[5] = timelineIndex;

        return id;
    }

    private static void FinalizeObject (Sync sync, bool isNew)
    {
        _syncingObjects.Remove(sync._objectIndex);
        
        try { _syncedObjects.Add(sync._objectIndex, sync); }
        
        catch (Exception e)
        {
            string errorMsg = e.Message;
            errorMsg += "\nAn error occurred while trying to Finalize Object: " + sync.name + ", Object Index: " + sync._objectIndex + ".";
            UnityEngine.Debug.LogError(errorMsg);
            
            if (_isClient)
                GameClient.Instance.DisconnectFromServer();
        }

        if (!sync.gameObject.activeSelf)
            sync.gameObject.SetActive(true);

        if (sync._spawnInfo != null)
        {
            PreAssignValues(sync.gameObject, sync._spawnInfo.Details);
            NotifySpawn(sync.gameObject, sync._spawnInfo.Details, isNew);

            if (isNew
                && sync._ownerPeerIndex == _localPeerIndex
                && sync.rigidbody != null
                && !sync.rigidbody.isKinematic
                && sync._spawnInfo.Details.HasChild("Velocity"))
            {
                sync.rigidbody.velocity = sync._spawnInfo.Details["Velocity"].Vector3Value;
            }
        }
        else
        {
            PreAssignValues(sync.gameObject, new UJeli());
            NotifySpawn(sync.gameObject, new UJeli(), isNew);
        }
    }

    private static void PreAssignValues (GameObject go, UJeli details)
    {
        foreach (var mb in go.GetComponentsInChildren<MonoBehaviour>())
        {
            if (!mb.enabled)
                continue;

            var mbType = mb.GetType();

            foreach (var field in mbType.GetFields(
                BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
            {
                var spawnDetailAttrs = field.GetCustomAttributes(typeof(SpawnDetailAttribute), false);

                if (spawnDetailAttrs.Length != 0)
                {
                    var spawnDetailAttr = spawnDetailAttrs[0] as SpawnDetailAttribute;
                    string detailKey = spawnDetailAttr.DetailKey ?? field.Name;

                    if (details.HasChild(detailKey))
                    {
                        var detail = details[detailKey];
                        SetFieldValueFromJeli(field, mb, detail);
                    }
                }

                var mapSettingAttrs = field.GetCustomAttributes(typeof(MapSettingAttribute), false);

                if (mapSettingAttrs.Length != 0)
                {
                    var mapSettingAttr = mapSettingAttrs[0] as MapSettingAttribute;
                    string settingKey = mapSettingAttr.SettingKey ?? field.Name;

                    if (Game.MapSettings.HasChild(settingKey))
                    {
                        var setting = Game.MapSettings[settingKey];
                        SetFieldValueFromJeli(field, mb, setting);
                    }
                }
            }
        }
    }

    private static void SetFieldValueFromJeli (FieldInfo field, object obj, UJeli jeli)
    {
        var fieldType = field.FieldType;

        try
        {
            if (fieldType == typeof(int))
                field.SetValue(obj, jeli.IntValue);
            else if (fieldType == typeof(uint))
                field.SetValue(obj, jeli.UIntValue);
            else if (fieldType == typeof(long))
                field.SetValue(obj, jeli.LongValue);
            else if (fieldType == typeof(ulong))
                field.SetValue(obj, jeli.ULongValue);
            else if (fieldType == typeof(short))
                field.SetValue(obj, jeli.ShortValue);
            else if (fieldType == typeof(ushort))
                field.SetValue(obj, jeli.UShortValue);
            else if (fieldType == typeof(float))
                field.SetValue(obj, jeli.FloatValue);
            else if (fieldType == typeof(double))
                field.SetValue(obj, jeli.DoubleValue);
            else if (fieldType == typeof(byte))
                field.SetValue(obj, jeli.ByteValue);
            else if (fieldType == typeof(sbyte))
                field.SetValue(obj, jeli.SByteValue);
            else if (fieldType == typeof(bool))
                field.SetValue(obj, jeli.BoolValue);
            else if (fieldType == typeof(string))
                field.SetValue(obj, jeli.Value);
            else if (fieldType == typeof(char))
                field.SetValue(obj, jeli.CharValue);
            else if (fieldType.IsEnum)
                field.SetValue(obj, Enum.Parse(fieldType, jeli.Value));
            else if (fieldType == typeof(DateTime))
                field.SetValue(obj, jeli.TimeValue);
            else if (fieldType == typeof(Vector2))
                field.SetValue(obj, jeli.Vector2Value);
            else if (fieldType == typeof(Vector3))
                field.SetValue(obj, jeli.Vector3Value);
            else if (fieldType == typeof(Vector4))
                field.SetValue(obj, jeli.Vector4Value);
            else if (fieldType == typeof(Quaternion))
                field.SetValue(obj, jeli.QuaternionValue);
            else if (fieldType == typeof(Matrix4x4))
                field.SetValue(obj, jeli.MatrixValue);
            else if (fieldType == typeof(Ray))
                field.SetValue(obj, jeli.RayValue);
            else if (fieldType == typeof(Color))
                field.SetValue(obj, jeli.ColorValue);
            else if (fieldType == typeof(GameObject))
                field.SetValue(obj, jeli.GameObjectValue);
        }
        catch { }
    }

    private static void NotifySpawn (GameObject go, UJeli details, bool isNew)
    {
        SendEnabledMessage(go, "OnSpawn", details, isNew);
    }

    private static void NotifyDespawn (GameObject go)
    {
        SendEnabledMessage(go, "PreDespawn");
        SendEnabledMessage(go, "OnDespawn");
        SendEnabledMessage(go, "PostDespawn");
    }

    private static void UnsyncObject (Sync sync)
    {
        if (!_isMapSynced)
            return;

        if (_timelineManager == null)
            return;

        foreach (var timeline in sync._timelines)
        {
            _timelineManager.Remove(timeline);
        }

        sync._timelines.Clear();
        sync._essentialTimelines.Clear();

        _syncedObjects.Remove(sync._objectIndex);
        _syncingObjects.Remove(sync._objectIndex);

        foreach (var childSync in sync.GetComponentsInChildren<Sync>())
        {
            childSync._objectIndex = -1;
        }
    }
}