TransformSynchronization.cs

using System;
using System.Collections;
using System.Collections.Generic;
using Improbable.Gdk.Core;
using Improbable.Gdk.Subscriptions;
using Unity.Collections;
using Unity.Entities;
using UnityEngine;
using Entity = Unity.Entities.Entity;

namespace Improbable.Gdk.TransformSynchronization
{
    public class TransformSynchronization : MonoBehaviour
    {
#pragma warning disable 649
        [Require] private TransformInternalReader transformReader;
        [Require] private Entity entity;
        [Require] private World world;
#pragma warning restore 649

        public List<TransformSynchronizationReceiveStrategy> ReceiveStrategies;
        public List<TransformSynchronizationSendStrategy> SendStrategies;

        public bool SetKinematicWhenNotAuthoritative = true;

        private EntityManager entityManager;
        private string workerType;
        private bool initialised;

        public uint TickNumber
        {
            get
            {
                if (!initialised || enabled == false)
                {
                    return 0;
                }

                var manager = world.EntityManager;

                if (transformReader.HasAuthority)
                {
                    return manager.GetComponentData<TicksSinceLastTransformUpdate>(entity)
                        .NumberOfTicks + transformReader.Data.PhysicsTick;
                }

                return manager.GetComponentData<TransformToSet>(entity).ApproximateRemoteTick;
            }
        }

        private void OnEnable()
        {
            if (ReceiveStrategies == null || ReceiveStrategies.Count == 0)
            {
                throw new InvalidOperationException($"{nameof(TransformSynchronization)} " +
                    $"on {gameObject.name} must be provided a transform receive strategy");
            }

            entityManager = world.EntityManager;
            workerType = world.GetExistingSystem<WorkerSystem>().WorkerType;

            StartCoroutine(DelayedApply());
        }

        private IEnumerator DelayedApply()
        {
            yield return null;
            if (initialised)
            {
                yield break;
            }

            ApplyStrategies();
            initialised = true;
        }

        private void OnDisable()
        {
            StopAllCoroutines();
            RemoveStrategies();

            entityManager = default;
            workerType = null;
            initialised = false;
        }

        private void ApplyStrategies()
        {
            using (var commandBuffer = new EntityCommandBuffer(Allocator.Temp))
            {
                if (SetKinematicWhenNotAuthoritative)
                {
                    commandBuffer.AddComponent(entity, new ManageKinematicOnAuthorityChangeTag());
                    commandBuffer.AddComponent(entity, new KinematicStateWhenAuth());
                }

                ApplyReceiveStrategies(commandBuffer);
                ApplySendStrategies(commandBuffer);

                commandBuffer.Playback(entityManager);
            }
        }

        private void RemoveStrategies()
        {
            using (var commandBuffer = new EntityCommandBuffer(Allocator.Temp))
            {
                if (SetKinematicWhenNotAuthoritative)
                {
                    commandBuffer.RemoveComponent<ManageKinematicOnAuthorityChangeTag>(entity);
                    commandBuffer.RemoveComponent<KinematicStateWhenAuth>(entity);
                }

                RemoveReceiveStrategies(commandBuffer);
                RemoveSendStrategies(commandBuffer);

                commandBuffer.Playback(entityManager);
            }
        }

        private void ApplyReceiveStrategies(EntityCommandBuffer commandBuffer)
        {
            AddCommonReceiveComponents(commandBuffer);

            foreach (var strategy in ReceiveStrategies)
            {
                if (strategy.WorkerType != workerType)
                {
                    continue;
                }

                strategy.Apply(entity, world, commandBuffer);
            }
        }

        private void RemoveReceiveStrategies(EntityCommandBuffer commandBuffer)
        {
            RemoveCommonReceiveComponents(commandBuffer);

            foreach (var strategy in ReceiveStrategies)
            {
                if (strategy.WorkerType != workerType)
                {
                    continue;
                }

                strategy.Remove(entity, world, commandBuffer);
            }
        }

        private void ApplySendStrategies(EntityCommandBuffer commandBuffer)
        {
            if (SendStrategies == null || SendStrategies.Count == 0)
            {
                return;
            }

            AddCommonSendComponents(commandBuffer);

            foreach (var strategy in SendStrategies)
            {
                if (strategy.WorkerType != workerType)
                {
                    continue;
                }

                strategy.Apply(entity, world, commandBuffer);
            }
        }

        private void RemoveSendStrategies(EntityCommandBuffer commandBuffer)
        {
            if (SendStrategies == null || SendStrategies.Count == 0)
            {
                return;
            }

            RemoveCommonSendComponents(commandBuffer);

            foreach (var strategy in SendStrategies)
            {
                if (strategy.WorkerType != workerType)
                {
                    continue;
                }

                strategy.Remove(entity, world, commandBuffer);
            }
        }

        private void AddCommonReceiveComponents(EntityCommandBuffer commandBuffer)
        {
            commandBuffer.AddComponent(entity, new SetTransformToGameObjectTag());

            var transformComponent = transformReader.Data;

            var defaultToSet = new TransformToSet
            {
                Position = transformComponent.Location.ToUnityVector() + world.GetExistingSystem<WorkerSystem>().Origin,
                Velocity = transformComponent.Velocity.ToUnityVector(),
                Orientation = transformComponent.Rotation.ToUnityQuaternion(),
                ApproximateRemoteTick = 0
            };

            var previousTransform = new DeferredUpdateTransform
            {
                Transform = transformComponent
            };

            commandBuffer.AddComponent(entity, defaultToSet);
            commandBuffer.AddComponent(entity, previousTransform);
            commandBuffer.AddBuffer<BufferedTransform>(entity);
        }

        private void RemoveCommonReceiveComponents(EntityCommandBuffer commandBuffer)
        {
            commandBuffer.RemoveComponent<SetTransformToGameObjectTag>(entity);
            commandBuffer.RemoveComponent<TransformToSet>(entity);
            commandBuffer.RemoveComponent<DeferredUpdateTransform>(entity);
            commandBuffer.RemoveComponent<BufferedTransform>(entity);
        }

        private void AddCommonSendComponents(EntityCommandBuffer commandBuffer)
        {
            commandBuffer.AddComponent(entity, new GetTransformFromGameObjectTag());

            var transformComponent = transformReader.Data;

            var defaultToSend = new TransformToSend
            {
                Position = transformComponent.Location.ToUnityVector() - world.GetExistingSystem<WorkerSystem>().Origin,
                Velocity = transformComponent.Velocity.ToUnityVector(),
                Orientation = transformComponent.Rotation.ToUnityQuaternion()
            };

            var ticksSinceLastUpdate = new TicksSinceLastTransformUpdate
            {
                NumberOfTicks = 0
            };

            var lastTransform = new LastTransformSentData
            {
                // could set this to the max time if we want to immediately send something
                TimeSinceLastUpdate = 0.0f,
                Transform = transformComponent
            };

            var position = entityManager.GetComponentData<Position.Component>(entity);
            var lastPosition = new LastPositionSentData
            {
                // could set this to the max time if we want to immediately send something
                TimeSinceLastUpdate = 0.0f,
                Position = position
            };

            commandBuffer.AddComponent(entity, defaultToSend);
            commandBuffer.AddComponent(entity, ticksSinceLastUpdate);
            commandBuffer.AddComponent(entity, lastPosition);
            commandBuffer.AddComponent(entity, lastTransform);
        }

        private void RemoveCommonSendComponents(EntityCommandBuffer commandBuffer)
        {
            commandBuffer.RemoveComponent<GetTransformFromGameObjectTag>(entity);
            commandBuffer.RemoveComponent<TransformToSend>(entity);
            commandBuffer.RemoveComponent<TicksSinceLastTransformUpdate>(entity);
            commandBuffer.RemoveComponent<LastTransformSentData>(entity);
            commandBuffer.RemoveComponent<LastPositionSentData>(entity);
        }
    }
}