Sync.Static.cs

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

public partial class Sync : MonoBehaviour
{
    public static TimelineManager TimelineManager
    {
        get { return _timelineManager; }
    }

    public static TimelineSynchronizer TimelineSynchronizer
    {
        get { return _timelineSyncer; }
    }

    public static int LocalPeerIndex
    {
        get { return _localPeerIndex; }
    }

    public static int ServerPeerIndex
    {
        get { return 0; }
    }

    public static bool IsServer
    {
        get { return _isServer; }
    }

    public static bool IsClient
    {
        get { return _isClient; }
    }

    public static bool IsMapSynced
    {
        get { return _isMapSynced; }
    }

    public static int[] ObjectIndices
    {
        get { return _syncedObjects.Keys.ToArray(); }
    }

    public static GameObject[] Objects
    {
        get { return (from sync in _syncedObjects.Values select sync.gameObject).ToArray(); }
    }

    public static string[] SpawnablePrefabIDs
    {
        get { return _spawnablePrefabs.Keys.ToArray(); }
    }

    public static GameObject[] SpawnablePrefabs
    {
        get { return _spawnablePrefabs.Values.ToArray(); }
    }

    public static float MaxSmoothDistance = 5f;
    public static float MinSmoothDistance = .01f;
    public static float ErrorDistance = 1f;
    public static float MaxErrorTime = 2f;

    public static GameObject GetSpawnablePrefab (string prefabId)
    {
        GameObject prefab = null;
        _spawnablePrefabs.TryGetValue(prefabId, out prefab);
        return prefab;
    }

    public static GameObject GetObject (int objectIndex)
    {
        Sync sync = null;

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

        return null;
    }

    public static bool ObjectExists (int objectIndex)
    {
        return _syncedObjects.ContainsKey(objectIndex) ||
            _syncingObjects.ContainsKey(objectIndex);
    }

    public static bool ObjectExists (GameObject go)
    {
        if (go == null)
            return false;

        var sync = go.GetComponent<Sync>();

        if (sync != null)
            return ObjectExists(sync._objectIndex);

        return false;
    }

    public static int GetObjectIndex (GameObject go)
    {
        if (go == null)
            return -1;

        Sync sync = go.GetComponent<Sync>();

        if (sync != null)
            return sync.ObjectIndex;

        return -1;
    }

    public static int GetObjectIndex (Component component)
    {
        return GetObjectIndex(component.gameObject);
    }

    public static SpawnInfo GetSpawnInfo (GameObject go)
    {
        if (go == null)
            return null;

        Sync sync = go.GetComponent<Sync>();

        if (sync != null)
            return sync.SpawnInfo;

        return null;
    }

    public static SpawnInfo GetSpawnInfo (Component component)
    {
        return GetSpawnInfo(component.gameObject);
    }

    public static UJeli GetSpawnDetails (GameObject go)
    {
        var spawnInfo = GetSpawnInfo(go);

        if (spawnInfo != null)
            return spawnInfo.Details;

        return null;
    }

    public static UJeli GetSpawnDetails (Component component)
    {
        return GetSpawnDetails(component.gameObject);
    }

    public static int GetOwner (GameObject go)
    {
        if (go == null)
            return -1;

        Sync sync = go.GetComponent<Sync>();

        if (sync != null)
            return sync.OwnerPeerIndex;

        return _localPeerIndex;
    }

    public static int GetOwner (Component component)
    {
        if (component == null)
            return -1;

        return GetOwner(component.gameObject);
    }

    public static bool IsLocal (GameObject go)
    {
        return GetOwner(go) == _localPeerIndex;
    }

    public static bool IsLocal (Component component)
    {
        return IsLocal(component.gameObject);
    }

    public static bool IsLocal (int objectIndex)
    {
        var go = GetObject(objectIndex);

        if (go == null)
            return false;

        return IsLocal(go);
    }

    public static bool IsLocalPeerIndex (int peerIndex)
    {
        return peerIndex == _localPeerIndex;
    }

    public static bool IsServerPeerIndex (int peerIndex)
    {
        return peerIndex == ServerPeerIndex;
    }

    public static bool IsClientPeerIndex (int peerIndex)
    {
        return peerIndex != ServerPeerIndex;
    }

    public static bool IsServerOwned (GameObject go)
    {
        return GetOwner(go) == Sync.ServerPeerIndex;
    }

    public static bool IsServerOwned (Component component)
    {
        return IsServerOwned(component.gameObject);
    }

    public static bool IsClientOwned (GameObject go)
    {
        return !IsServerOwned(go);
    }

    public static bool IsClientOwned (Component component)
    {
        return IsClientOwned(component.gameObject);
    }

    public static GameObject[] GetPeerObjects (int peerIndex)
    {
        var gos = new List<GameObject>();

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

            if (sync._ownerPeerIndex == peerIndex)
                gos.Add(sync.gameObject);
        }

        return gos.ToArray();
    }

    public static GameObject[] GetLocalObjects ()
    {
        return GetPeerObjects(_localPeerIndex);
    }

    public static GameObject GetPeerObject (int peerIndex)
    {
        foreach (var sync in _syncedObjects.Values)
        {
            if (sync == null)
                continue;

            if (sync._ownerPeerIndex == peerIndex)
                return sync.gameObject;
        }

        return null;
    }

    public static GameObject GetLocalObject ()
    {
        return GetPeerObject(_localPeerIndex);
    }

    public static T[] GetPeerObjects<T> (int peerIndex) where T : Component
    {
        var components = new List<T>();

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

            if (sync._ownerPeerIndex == peerIndex)
            {
                T component = sync.GetComponent<T>();

                if (component != null)
                    components.Add(component);
            }
        }

        return components.ToArray();
    }

    public static T[] GetLocalObjects<T> () where T : Component
    {
        return GetPeerObjects<T>(_localPeerIndex);
    }

    public static T GetPeerObject<T> (int peerIndex) where T : Component
    {
        foreach (var sync in _syncedObjects.Values)
        {
            if (sync == null)
                continue;

            if (sync._ownerPeerIndex == peerIndex)
            {
                T component = sync.GetComponent<T>();

                if (component != null)
                    return component;
            }
        }

        return null;
    }

    public static T GetLocalObject<T> () where T : Component
    {
        return GetPeerObject<T>(_localPeerIndex);
    }

    public static GameObject Spawn (string prefabId, Vector3 position,
        int ownerPeerIndex = 0, UJeli details = null)
    {
        var prefab = Resources.Load<GameObject>(prefabId);

        if (prefab == null)
            return null;

        return Spawn(prefab, position, ownerPeerIndex, details);
    }

    public static GameObject Spawn (GameObject prefab, Vector3 position,
        int ownerPeerIndex = 0, UJeli details = null)
    {
        return Spawn(prefab, position, Vector3.zero, ownerPeerIndex, details);
    }

    public static GameObject Spawn (string prefabId, Vector3 position, Vector3 direction,
        int ownerPeerIndex = 0, UJeli details = null)
    {
        var prefab = Resources.Load<GameObject>(prefabId);

        if (prefab == null)
            return null;

        return Spawn(prefab, position, direction, ownerPeerIndex, details);
    }

    public static GameObject Spawn (GameObject prefab, Vector3 position, Vector3 direction,
        int ownerPeerIndex = 0, UJeli details = null)
    {
        if (_isMapUnsyncing)
            return null;

        if (prefab.GetComponent<Sync>() == null)
            return null;

        if (details == null)
            details = new UJeli();

        UJeli detailsTemplate = null;

        if (_spawnDetailsTemplates.TryGetValue(prefab.name, out detailsTemplate))
        {
            foreach (var detailsTemplateNode in detailsTemplate.Children)
            {
                if (!details.HasChild(detailsTemplateNode.Name))
                    details.AddChild(detailsTemplateNode.Clone());
            }
        }

        var spawnInfo = new SpawnInfo()
        {
            Prefab = prefab,
            Position = position,
            Direction = direction,
            OwnerPeerIndex = ownerPeerIndex,
            Details = details
        };

        var go = SpawnShell(prefab, position);
        var sync = go.GetComponent<Sync>();
        sync._spawnInfo = spawnInfo;

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

        SetObjectOwner(sync, ownerPeerIndex);

        if (_isServer)
        {
            _nextObjectIndex++;
            SyncObject(sync, _nextObjectIndex, true);

            if (PropagateSpawnDown != null)
                PropagateSpawnDown(0, 0, sync._objectIndex, spawnInfo);
        }
        else if (_isClient)
        {
            if (PropagateSpawnUp != null)
                PropagateSpawnUp(_nextSpawnRequestIndex, spawnInfo);

            _requestedObjects.Add(_nextSpawnRequestIndex, sync);

            _nextSpawnRequestIndex++;
        }

        return go;
    }

    public static GameObject SpawnLocal (string prefabId, Vector3 position, UJeli details = null)
    {
        var prefab = Resources.Load<GameObject>(prefabId);

        if (prefab == null)
            return null;

        return SpawnLocal(prefab, position, details);
    }

    public static GameObject SpawnLocal (GameObject prefab, Vector3 position, UJeli details = null)
    {
        return SpawnLocal(prefab, position, Vector3.zero, details);
    }

    public static GameObject SpawnLocal (string prefabId, Vector3 position, Vector3 direction, UJeli details = null)
    {
        var prefab = Resources.Load<GameObject>(prefabId);

        if (prefab == null)
            return null;

        return SpawnLocal(prefab, position, direction, details);
    }

    public static GameObject SpawnLocal (GameObject prefab, Vector3 position, Vector3 direction, UJeli details = null)
    {
        if (_isMapUnsyncing)
            return null;

        var go = SpawnShell(prefab, position);

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

        if (go.rigidbody != null && !go.rigidbody.isKinematic && details.HasChild("Velocity"))
        {
            go.rigidbody.velocity = details["Velocity"].Vector3Value;
        }

        PreAssignValues(go, details);
        NotifySpawn(go, details, true);

        return go;
    }

    public static void Teleport (GameObject go, Vector3 target)
    {
        Sync sync = go.GetComponent<Sync>();

        if (sync != null)
        {
            if (!sync.SyncPosition)
                return;

            // Teleportation may only be performed by the object's owner or the server.
            if (!_isServer && sync._ownerPeerIndex != _localPeerIndex)
                return;

            var requestMsg = new GameMessage();
            requestMsg.Write(false);
            requestMsg.Write(target);

            sync._teleports[0] = requestMsg;
        }
        else go.transform.position = target;
    }

    public static void Teleport (Component component, Vector3 target)
    {
        Teleport(component.gameObject, target);
    }

    public static void SendEnabledMessage (GameObject go, string message, params object[] args)
    {
        foreach (var mb in go.GetComponentsInChildren<MonoBehaviour>())
        {
            if (!mb.enabled)
                continue;

            var mbType = mb.GetType();

            var msgHandler = mbType.GetMethod(message,
                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);

            if (msgHandler != null)
            {
                var numParams = msgHandler.GetParameters().Length;

                if (args.Length > numParams)
                    msgHandler.Invoke(mb, args.Take(numParams).ToArray());
                else if (args.Length == numParams)
                    msgHandler.Invoke(mb, args);
            }
        }
    }

    public static void SendEnabledMessage (Component component, string message, params object[] args)
    {
        SendEnabledMessage(component.gameObject, message, args);
    }

    public static void Despawn (GameObject go)
    {
        if (go == null)
            return;

        var sync = go.GetComponent<Sync>();

        if (sync == null)
        {
            NotifyDespawn(go);
            Destroy(go);
            return;
        }

        if (_isServer)
        {
            if (PropagateDespawnDown != null)
                PropagateDespawnDown(0, sync._objectIndex);
        }
        else if (_isClient)
        {
            if (sync._objectIndex != -1)
            {
                if (PropagateDespawnUp != null)
                    PropagateDespawnUp(sync._objectIndex);
            }
            else
            {
                foreach (int spawnRequestIndex in _requestedObjects.Keys.ToArray())
                {
                    if (_requestedObjects[spawnRequestIndex] == go)
                        _requestedObjects.Remove(spawnRequestIndex);
                }
            }
        }

        NotifyDespawn(go);
        UnsyncObject(sync);
        Destroy(go);
    }

    public static void Despawn (Component component)
    {
        Despawn(component.gameObject);
    }

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

            Despawn(sync.gameObject);
        }

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

            Despawn(sync.gameObject);
        }
    }

    public static void DespawnPeerObjects (int peerIndex)
    {
        foreach (var sync in _syncedObjects.Values.ToArray())
        {
            if (sync == null)
                continue;

            if (sync._ownerPeerIndex == peerIndex)
                Despawn(sync.gameObject);
        }

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

            if (sync._ownerPeerIndex == peerIndex)
                Despawn(sync.gameObject);
        }
    }

    public static Timeline<T> CreateDiscreteState<T> ()
    {
        var timeline = new Timeline<T>();
        timeline.CacheSize = 1;
        timeline.MaxEntries = 3;
        timeline.IgnoreCachedEvents = false;
        timeline.DeliveryMode = DeliveryMode.ReliableOrdered;

        SetEnumTimelineEncoding<T>(timeline);

        return timeline;
    }

    public static Timeline<T> CreateContinuousState<T> (float sendRate = 10f)
    {
        return CreateContinuousState<T>(TimelineUtils.BuildRateFilter<T>(() => sendRate));
    }

    public static Timeline<T> CreateContinuousState<T> (TimelineSendFilter<T> sendFilter)
    {
        var timeline = new Timeline<T>()
        {
            CacheSize = 3,
            MaxEntries = 3,
            IgnoreCachedEvents = false,
            DeliveryMode = DeliveryMode.Unreliable
        };

        if (sendFilter != null)
            timeline.AddSendFilter(sendFilter);

        SetEnumTimelineEncoding<T>(timeline);

        return timeline;
    }

    public static Timeline<T> CreateEvent<T> ()
    {
        var timeline = new Timeline<T>();
        timeline.CacheSize = 0;
        timeline.MaxEntries = 3;
        timeline.IgnoreCachedEvents = true;
        timeline.DeliveryMode = DeliveryMode.ReliableOrdered;

        SetEnumTimelineEncoding<T>(timeline);

        return timeline;
    }

    public static void SetEnumTimelineEncoding<T> (Timeline<T> timeline)
    {
        var timelineValueType = typeof(T);

        if (timelineValueType.IsEnum)
        {
            var underlyingType = Enum.GetUnderlyingType(timelineValueType);

            if (underlyingType == typeof(byte))
            {
                timeline.Encode = UTimelineUtils.EncodeByteEnum<T>;
                timeline.Decode = UTimelineUtils.DecodeByteEnum<T>;
            }
            else if (underlyingType == typeof(short))
            {
                timeline.Encode = UTimelineUtils.EncodeShortEnum<T>;
                timeline.Decode = UTimelineUtils.DecodeShortEnum<T>;        
            }
            else if (underlyingType == typeof(int))
            {
                timeline.Encode = UTimelineUtils.EncodeIntEnum<T>;
                timeline.Decode = UTimelineUtils.DecodeIntEnum<T>;
            }
            else
            {
                timeline.Encode = UTimelineUtils.EncodeEnumByName<T>;
                timeline.Decode = UTimelineUtils.DecodeEnumByName<T>;
            }
        }
    }
}