Sync.cs

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

public delegate void ObjectDespawnImminentHandler (GameObject go);
public delegate void ObjectDespawnedHandler (GameObject go);

[AddComponentMenu("Liberi/Sync")]
public partial class Sync : MonoBehaviour
{
    public event ObjectDespawnImminentHandler DespawnImminent;
    public event ObjectDespawnedHandler Despawned;

    public Sync RootSync
    {
        get { return _rootSync; }
    }

    public bool IsRoot
    {
        get { return _rootSync == this; }
    }

    public int OwnerPeerIndex
    {
        get { return _rootSync._ownerPeerIndex; }
    }
    
    public int ObjectIndex
    {
        get { return _rootSync._objectIndex; }
    }

    public SpawnInfo SpawnInfo
    {
        get { return _rootSync._spawnInfo; }
    }

    public TimelineBase[] Timelines
    {
        get { return _rootSync._timelines.ToArray(); }
    }

    public TimelineBase[] EssentialTimelines
    {
        get { return _rootSync._essentialTimelines.ToArray(); }
    }
    
    public bool SyncPosition = false;
    public bool SyncDirection = false;
    public bool SyncColliderState = false;
    public bool SyncColliderSize = false;
    public bool SyncAnimator = false;
    public DirectionMode DirectionMode = DirectionMode.None;
    public float PositionCorrectionStrength = 25f;
    public float DirectionCorrectionStrength = 25f;
    public float SetTime = 0f;
    public float GetTime = 0f;
    public float SendRate = 10f;
    public bool DrawDebugGizmos;

    [TimelineTags("Essential")]
    public Timeline<Vector3> Position;
    [TimelineTags("Essential")]
    public Timeline<float> Angle;
    [TimelineTags("Essential")]
    public Timeline<bool> Flipped;

    public Timeline<GameMessage> AnimationMessages;

    Timeline<GameMessage> _teleports;
    Timeline<bool> _colliderState;
    Timeline<Vector3> _colliderSize;

    MonoBehaviour[] _originalBehaviours;
    SpawnInfo _spawnInfo;
    int _objectIndex = -1;
    int _ownerPeerIndex = -1;
    List<TimelineBase> _timelines = new List<TimelineBase>();
    List<TimelineBase> _essentialTimelines = new List<TimelineBase>();
    Sync _rootSync;
    float _errorTime;
    bool _isWaitingForTeleportConfirmation;
    BoxCollider _boxCollider;
    SphereCollider _sphereCollider;
    CapsuleCollider _capsuleCollider;
    Animator _animator;

    private float GetSendRate ()
    {
        return SendRate;
    }

    void Awake ()
    {
        _rootSync = this;

        while (_rootSync.transform.parent != null && _rootSync.transform.parent.GetComponent<Sync>() != null)
        {
            _rootSync = _rootSync.transform.parent.GetComponent<Sync>();
        }

        if (this.IsRoot)
        {
            _originalBehaviours = GetComponentsInChildren<MonoBehaviour>().Where(mb => mb.enabled).ToArray();

            foreach (var mb in _originalBehaviours)
            {
                if (mb == this)
                    continue;

                mb.enabled = false;
            }
        }

        if (SyncPosition)
        {
            var positionSendFilter = TimelineUtils.BuildRateFilter<Vector3>(GetSendRate);

            Position = CreateContinuousState<Vector3>(positionSendFilter);

            _teleports = Sync.CreateEvent<GameMessage>();
        }

        if (SyncDirection)
        {
            if (DirectionMode == DirectionMode.Radial)
            {
                var angleSendFilter = TimelineUtils.BuildRateFilter<float>(GetSendRate);

                Angle = CreateContinuousState<float>(angleSendFilter);
                Angle.Interpolate = UTimelineUtils.InterpolateAngleSlerp;
            }
            else if (DirectionMode == DirectionMode.Flip)
            {
                Flipped = CreateDiscreteState<bool>();
            }
        }

        if (collider == null)
        {
            SyncColliderState = false;
            SyncColliderSize = false;
        }

        if (SyncColliderState)
        {
            _colliderState = CreateDiscreteState<bool>();
        }

        if (SyncColliderSize)
        {
            if (collider is MeshCollider)
            {
                SyncColliderSize = false;
            }
            else
            {
                _boxCollider = GetComponent<BoxCollider>();
                _sphereCollider = GetComponent<SphereCollider>();
                _capsuleCollider = GetComponent<CapsuleCollider>();

                _colliderSize = CreateContinuousState<Vector3>();
                _colliderSize.AddSendFilter(TimelineUtils.BuildInequalityFilter<Vector3>());
            }
        }
        
        if (SyncAnimator)
        {
            _animator = GetComponent<Animator>();
            AnimationMessages = CreateDiscreteState<GameMessage>();
        }
    }

    void OnDrawGizmos ()
    {
        if (!DrawDebugGizmos)
            return;

        if (Position != null)
        {
            if (Position.NumEntries >= 1)
            {
                Gizmos.color = new Color(0f, 0f, 1f, .75f);
                Gizmos.DrawWireSphere(Position.PreviousValue, .1f);
            }

            if (Position.NumEntries >= 2)
            {
                Gizmos.color = new Color(0f, 0f, 1f, .5f);
                Gizmos.DrawWireSphere(Position.PreviousEntry.Prev.Value, .1f);
            }

            Gizmos.color = Color.white;
        }
    }

    void OnSpawn ()
    {
        if (SyncPosition)
        {
            _teleports.EntryPassed += OnTeleportEvent;
        }

        if (_rootSync._ownerPeerIndex == _localPeerIndex)
        {
            PushTransform();
            PushCollider();
        }
        else
        {
            if (rigidbody != null)
            {
                this.rigidbody.useGravity = false;

                if (SyncPosition)
                    this.rigidbody.constraints |= RigidbodyConstraints.FreezePosition;

                if (SyncDirection)
                {
                    if (DirectionMode == DirectionMode.Radial)
                        this.rigidbody.constraints |= RigidbodyConstraints.FreezeRotation;
                    else if (DirectionMode == DirectionMode.Flip)
                    {
                        Flipped.EntryPassed += OnFlippedChanged;
                        transform.SetFlipDirection(Flipped.LastValue ? Vector3.left : Vector3.right);
                    }
                }
            }

            PullTransform();
            PullCollider();

            if (SyncColliderState)
                _colliderState.EntryPassed += OnColliderStateChanged;
        }
        
        if (SyncAnimator)
            AnimationMessages.EntryPassed += OnAnimationMessagePassed;
    }

    void PreDespawn ()
    {
        if (DespawnImminent != null)
            DespawnImminent(gameObject);
    }

    void PostDespawn ()
    {
        if (Despawned != null)
            Despawned(gameObject);
    }

    public Vector3 GetDirection ()
    {
        if (DirectionMode == DirectionMode.Flip)
            return transform.GetFlipDirection();
        else return transform.GetRadialDirection();
    }

    public void SetDirection (Vector3 direction, bool ignoreRigidbody = false)
    {
        if (DirectionMode == DirectionMode.Flip)
        {
            transform.SetFlipDirection(direction);
        }
        else if (DirectionMode == DirectionMode.Radial)
        {
            if (!ignoreRigidbody && rigidbody != null)
                rigidbody.SetRadialDirection(direction);
            else transform.SetRadialDirection(direction);
        }
    }

    void Update ()
    {
        if (_rootSync._ownerPeerIndex == _localPeerIndex)
        {
            PushTransform();
            PushCollider();
        }
        else
        {
            PullTransform();
            PullCollider();
        }
    }

    private void PushTransform ()
    {
        if (SyncPosition)
        {
            Position[SetTime] = transform.position;
        }

        if (SyncDirection)
        {
            if (DirectionMode == DirectionMode.Radial)
            {
                Angle[SetTime] = transform.rotation.eulerAngles.z;
            }
            else if (DirectionMode == DirectionMode.Flip)
            {
                Flipped[SetTime] = transform.localScale.x < 0;
            }
        }
    }

    private void PullTransform ()
    {
        if (_isWaitingForTeleportConfirmation)
            return;

        if (SyncPosition && !Position.IsEmpty)
        {
            var position = transform.position;
            var targetPosition = Position[GetTime];
            var sqrDistToTarget = (targetPosition - position).sqrMagnitude;
            bool shouldSnap = false;

            if (sqrDistToTarget > Mathf.Pow(MaxSmoothDistance, 2))
            {
                shouldSnap = true;
            }
            else
            {
                if (sqrDistToTarget > Mathf.Pow(ErrorDistance, 2))
                {
                    _errorTime += Time.deltaTime;
                    shouldSnap = _errorTime >= MaxErrorTime;
                }
                else if (sqrDistToTarget < Mathf.Pow(MinSmoothDistance, 2))
                {
                    shouldSnap = true;
                }
            }

            if (shouldSnap)
            {
                transform.position = Position[GetTime];
                _errorTime = 0f;
            }
            else
            {
                transform.position = Vector3.Lerp(position,
                    targetPosition, Mathf.Min(1f, PositionCorrectionStrength * Time.deltaTime));
            }
        }

        if (SyncDirection)
        {
            if (DirectionMode == DirectionMode.Radial && !Angle.IsEmpty)
            {
                var rotation = transform.rotation;
                float currentAngle = rotation.eulerAngles.z;
                float interpAngle = Mathf.LerpAngle(
                    currentAngle, Angle[GetTime], DirectionCorrectionStrength * Time.deltaTime);
                
                transform.rotation = Quaternion.Euler(0f, 0f, interpAngle);
            }
        }
    }

    void PushCollider ()
    {
        if (SyncColliderState)
        {
            if (_colliderState.LastValue != collider.enabled)
                _colliderState[0] = collider.enabled;
        }

        if (SyncColliderSize)
        {
            if (_sphereCollider != null)
            {
                _colliderSize[SetTime] = new Vector3(_sphereCollider.radius, 0f, 0f);
            }
            else if (_capsuleCollider != null)
            {
                _colliderSize[SetTime] = new Vector3(_capsuleCollider.radius, _capsuleCollider.height, 0f);
            }
            else if (_boxCollider != null)
            {
                _colliderSize[SetTime] = _boxCollider.size;
            }
        }
    }

    void PullCollider ()
    {
        if (SyncColliderSize && !_colliderSize.IsEmpty)
        {
            var size = _colliderSize[GetTime];

            if (_sphereCollider != null)
            {
                _sphereCollider.radius = size.x;
            }
            else if (_capsuleCollider != null)
            {
                _capsuleCollider.radius = size.x;
                _capsuleCollider.height = size.y;
            }
            else if (_boxCollider != null)
            {
                _boxCollider.size = size;
            }
        }
    }

    void OnFlippedChanged (Timeline<bool> timeline, TimelineEntry<bool> entry)
    {
        transform.SetFlipDirection(entry.Value ? Vector3.left : Vector3.right);
    }

    void OnColliderStateChanged (Timeline<bool> timeline, TimelineEntry<bool> entry)
    {
        collider.enabled = entry.Value;
    }
    
    void OnAnimationMessagePassed (Timeline<GameMessage> timeline, TimelineEntry<GameMessage> entry)
    {
        GameMessage msg = entry.Value;
    
        int stateNameHash = msg.ReadInt32();
        float transitionDuration = msg.ReadFloat();
        int layer = msg.ReadInt32();
        
        //TODO: normalizedTime using Janus time and entry instertion time.
        
        _animator.CrossFade(stateNameHash, transitionDuration, layer);
    }

    void OnTeleportEvent (Timeline<GameMessage> timeline, TimelineEntry<GameMessage> entry)
    {
        var msg = entry.Value;

        bool isConfirmation = msg.ReadBoolean();
        Vector3 target = msg.ReadVector3();
        msg.FinishReading();

        transform.position = target;
        Position.RemoveRange(Position.FirstTime, true, Position.LastTime, true, true);
        Position.Insert(0f, target);

        if (isConfirmation)
        {
            Sync.SendEnabledMessage(this, "OnTeleport", target);

            if (_rootSync._ownerPeerIndex != _localPeerIndex)
                _isWaitingForTeleportConfirmation = false;
        }
        else
        {
            if (_rootSync._ownerPeerIndex == _localPeerIndex)
            {
                var confirmMsg = new GameMessage();
                confirmMsg.Write(true);
                confirmMsg.Write(target);

                _teleports[0] = confirmMsg;
            }
            else _isWaitingForTeleportConfirmation = true;
        }
    }
}