BoneSync/BoneSync/Sync/ObjectSyncCache.cs

using BoneSync.Sync.Components;
using StressLevelZero.Interaction;
using StressLevelZero.Pool;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BoneSync.Sync
{
    public static class ObjectSyncCache
    {
        private static Dictionary<string, Syncable> _pathToSyncable = new Dictionary<string, Syncable>();
        private static Dictionary<ushort, Syncable> _idToSyncable = new Dictionary<ushort, Syncable>();
        private static Dictionary<Poolee, Syncable> _pooleeToSyncable = new Dictionary<Poolee, Syncable>();
        private static Dictionary<InteractableHost, Syncable> _interactableHostToSyncable = new Dictionary<InteractableHost, Syncable>();
        private static Dictionary<InteractableHostManager, Syncable> _interactableHostManagerToSyncable = new Dictionary<InteractableHostManager, Syncable>();

        public static void AddSyncable(Syncable syncable)
        {
            string path = syncable.transform.GetPath();
            if (path != null && path != "")
            {
                _pathToSyncable[path] = syncable;
            }
            if (syncable.GetSyncId() != 0)
            {
                _idToSyncable[syncable.GetSyncId()] = syncable;
            }
            if (syncable.interactableHost)
            {
                _interactableHostToSyncable[syncable.interactableHost] = syncable;
            }
            if (syncable.interactableManager)
            {
                _interactableHostManagerToSyncable[syncable.interactableManager] = syncable;
            }
            if (syncable.poolee)
            {
                _pooleeToSyncable[syncable.poolee] = syncable;
            }
        }

        public static void RemoveSyncable(Syncable syncable)
        {
            if (syncable.transform)
            {
                _pathToSyncable.Remove(syncable.transform.GetPath());
            }
            if (syncable.GetSyncId() != 0)
            {
                _idToSyncable.Remove(syncable.GetSyncId());
            }
            if (syncable.interactableHost)
            {
                _interactableHostToSyncable.Remove(syncable.interactableHost);
            }
            if (syncable.interactableManager)
            {
                _interactableHostManagerToSyncable.Remove(syncable.interactableManager);
            }
            if (syncable.poolee)
            {
                _pooleeToSyncable.Remove(syncable.poolee);
            }
        }

        public static void UpdateSyncId(Syncable syncable)
        {
            // remove other enties where value is the same
            foreach (KeyValuePair<ushort, Syncable> entry in _idToSyncable)
            {
                if (entry.Value == syncable)
                {
                    _idToSyncable.Remove(entry.Key);
                }
            }
            ushort id = syncable.GetSyncId();
            if (_idToSyncable.ContainsKey(id))
            {
                _idToSyncable.Remove(id);
            }
            _idToSyncable[id] = syncable;
        }

        public static Syncable GetSyncable(string path)
        {
            if (_pathToSyncable.ContainsKey(path))
            {
                return _pathToSyncable[path];
            }
            return null;
        }

        public static Syncable GetSyncable(ushort id)
        {
            if (_idToSyncable.ContainsKey(id))
            {
                return _idToSyncable[id];
            }
            return null;
        }

        public static Syncable GetSyncable(Poolee poolee)
        {
            if (_pooleeToSyncable.ContainsKey(poolee))
            {
                return _pooleeToSyncable[poolee];
            }
            return null;
        }

        public static Syncable GetSyncable(InteractableHost interactableHost)
        {
            if (_interactableHostToSyncable.ContainsKey(interactableHost))
            {
                return _interactableHostToSyncable[interactableHost];
            }
            return null;
        }

        public static Syncable GetSyncable(InteractableHostManager interactableHostManager)
        {
            if (_interactableHostManagerToSyncable.ContainsKey(interactableHostManager))
            {
                return _interactableHostManagerToSyncable[interactableHostManager];
            }
            return null;
        }

        public static void DISCARD_ALL_SYNCABLES()
        {
            foreach (Syncable syncable in Syncable.syncablesCache.Values)
            {
                syncable.DiscardSyncable();
            }
        }
    }
}