Mogus

BoneSync/Sync/ObjectSyncCache.cs

@@ -0,0 +1,140 @@
+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();
+            }
+        }
+    }
+}