fr.jeanf.scenemanagement 0.2.0 → 0.3.1

package/Runtime/AdditiveLoading/Editor/WorldManagerEditor.cs

@@ -0,0 +1,83 @@
+#if UNITY_EDITOR
+using UnityEngine;
+using UnityEditor;
+
+namespace jeanf.scenemanagement
+{
+    [CustomEditor(typeof(WorldManager))]
+    public class WorldManagerEditor : Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            DrawDefaultInspector();
+            
+            var worldManager = (WorldManager)target;
+            
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField("Current Player State", EditorStyles.boldLabel);
+            
+            var currentZone = WorldManager.CurrentPlayerZone;
+            var currentRegion = WorldManager.CurrentPlayerRegion;
+            
+            EditorGUI.BeginDisabledGroup(true);
+            
+            if (currentZone != null)
+            {
+                EditorGUILayout.TextField("Current Zone", $"{currentZone.zoneName}");
+            }
+            else
+            {
+                EditorGUILayout.TextField("Current Zone", "None");
+            }
+            
+            if (currentRegion != null)
+            {
+                EditorGUILayout.TextField("Current Region", $"{currentRegion.levelName}");
+            }
+            else
+            {
+                EditorGUILayout.TextField("Current Region", "None");
+            }
+            
+            EditorGUI.EndDisabledGroup();
+            
+            if (Application.isPlaying)
+            {
+                EditorGUILayout.Space();
+                if (GUILayout.Button("Debug Zone/Region Info"))
+                {
+                    Debug.Log($"=== WorldManager Debug Info ===");
+                    Debug.Log($"Current Zone: {(currentZone != null ? $"'{currentZone.zoneName}' (ID: {currentZone.id})" : "None")}");
+                    Debug.Log($"Current Region: {(currentRegion != null ? $"'{currentRegion.levelName}' (ID: {currentRegion.id})" : "None")}");
+                    
+                    var zoneCount = worldManager.GetType().GetField("_zoneDictionary", 
+                        System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)
+                        ?.GetValue(worldManager) as System.Collections.Generic.Dictionary<string, Zone>;
+                    
+                    var regionCount = worldManager.GetType().GetField("_regionDictionary", 
+                        System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)
+                        ?.GetValue(worldManager) as System.Collections.Generic.Dictionary<string, Region>;
+                    
+                    if (zoneCount != null && regionCount != null)
+                    {
+                        Debug.Log($"Total zones in dictionary: {zoneCount.Count}");
+                        Debug.Log($"Total regions in dictionary: {regionCount.Count}");
+                        
+                        Debug.Log("Available zones:");
+                        foreach (var zone in zoneCount.Values)
+                        {
+                            Debug.Log($"  - '{zone.zoneName}' (ID: {zone.id})");
+                        }
+                        
+                        Debug.Log("Available regions:");
+                        foreach (var region in regionCount.Values)
+                        {
+                            Debug.Log($"  - '{region.levelName}' (ID: {region.id})");
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+#endif

package/Runtime/AdditiveLoading/Editor/WorldManagerEditor.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 146fcca9a633f6a45bffd11a94703fad

package/Runtime/AdditiveLoading/SceneLoader.cs

@@ -12,7 +12,10 @@ namespace jeanf.scenemanagement
     {
         public bool isDebug = false;
         private CancellationTokenSource _queueCts;
-        [SerializeField] private int maxConcurrentLoads = 2; 
+        [SerializeField] private int maxConcurrentLoads = 2;
+        [SerializeField] private int gcFrameSpread = 5;
+        [SerializeField] private bool enableIncrementalGC = true;
+        [SerializeField] private float memoryFlushDelay = 0.1f;
         
         public delegate void IsLoadingDelegate(bool loadingState);
         public static IsLoadingDelegate IsLoading;
@@ -49,6 +52,7 @@ namespace jeanf.scenemanagement
         
         private bool _isProcessingLoadQueue = false;
         private bool _isProcessingUnloadQueue = false;
+        private bool _isFlushingMemory = false;
 
         private void OnEnable() => Subscribe();
         private void OnDisable() => Unsubscribe();
@@ -59,6 +63,7 @@ namespace jeanf.scenemanagement
             LoadSceneRequest += QueueLoadScene;
             UnLoadSceneRequest += QueueUnloadScene;
             UnloadAllScenesRequest += QueueUnloadAllScenes;
+            FlushScenesRequest += () => IncrementalMemoryFlush().Forget();
         }
 
         private void Unsubscribe()
@@ -66,6 +71,7 @@ namespace jeanf.scenemanagement
             LoadSceneRequest -= QueueLoadScene;
             UnLoadSceneRequest -= QueueUnloadScene;
             UnloadAllScenesRequest -= QueueUnloadAllScenes;
+            FlushScenesRequest = null;
         }
         
         private enum SceneOperationType { Load, Unload }
@@ -84,8 +90,6 @@ namespace jeanf.scenemanagement
         
         private void QueueUnloadAllScenes()
         {
-            if (isDebug) Debug.Log("Unloading all scenes");
-            
             while (_loadQueue.TryDequeue(out _)) { }
             
             _scenesToUnload.Clear();
@@ -102,14 +106,48 @@ namespace jeanf.scenemanagement
             ProcessUnloadQueue().Forget();
         }
         
-        private async UniTask FlushMemoryAsync(CancellationToken cancellationToken)
+        private async UniTaskVoid IncrementalMemoryFlush()
         {
-            if (isDebug) Debug.Log("Flushing memory");
-            
-            await Resources.UnloadUnusedAssets().ToUniTask(cancellationToken: cancellationToken);
-            GC.Collect();
-            
-            if (isDebug) Debug.Log("Memory flush complete");
+            if (_isFlushingMemory) return;
+            _isFlushingMemory = true;
+
+            try
+            {
+                await UniTask.Delay(TimeSpan.FromSeconds(memoryFlushDelay), DelayType.Realtime);
+                
+                var unloadOperation = Resources.UnloadUnusedAssets();
+                await unloadOperation.ToUniTask();
+                
+                if (enableIncrementalGC)
+                {
+                    await IncrementalGarbageCollection();
+                }
+            }
+            finally
+            {
+                _isFlushingMemory = false;
+            }
+        }
+
+        private async UniTask IncrementalGarbageCollection()
+        {
+            if (GC.MaxGeneration >= 2)
+            {
+                for (int generation = 0; generation <= GC.MaxGeneration; generation++)
+                {
+                    GC.Collect(generation, GCCollectionMode.Optimized, false);
+                    
+                    for (int frame = 0; frame < gcFrameSpread; frame++)
+                    {
+                        await UniTask.Yield();
+                    }
+                }
+            }
+            else
+            {
+                GC.Collect(0, GCCollectionMode.Optimized, false);
+                await UniTask.Yield();
+            }
         }
 
         private async UniTaskVoid ProcessLoadQueue()
@@ -191,7 +229,6 @@ namespace jeanf.scenemanagement
                         await UniTask.WhenAll(_operationBuffer);
                     }
                     
-                    // Small delay to prevent overwhelming the system
                     await UniTask.Yield();
                 }
             }
@@ -199,7 +236,7 @@ namespace jeanf.scenemanagement
             {
                 if (_loadedScenes.Count == 0)
                 {
-                    await FlushMemoryAsync(token);
+                    IncrementalMemoryFlush().Forget();
                 }
                 
                 _isProcessingUnloadQueue = false;
@@ -212,11 +249,9 @@ namespace jeanf.scenemanagement
 
         private async UniTask LoadSceneAsync(string sceneName, CancellationToken cancellationToken)
         {
-            AsyncOperation loadOperation = null;
-    
             try
             {
-                loadOperation = SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Additive);
+                var loadOperation = SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Additive);
                 loadOperation.allowSceneActivation = true;
                 await loadOperation.ToUniTask(cancellationToken: cancellationToken);
                 _loadedScenes.Add(sceneName);
@@ -240,5 +275,44 @@ namespace jeanf.scenemanagement
                 _processingScenes.Remove(sceneName);
             }
         }
+
+        private void OnApplicationFocus(bool hasFocus)
+        {
+            if (!hasFocus && enableIncrementalGC)
+            {
+                IncrementalMemoryFlush().Forget();
+            }
+        }
+
+        private void OnApplicationPause(bool pauseStatus)
+        {
+            if (pauseStatus && enableIncrementalGC)
+            {
+                IncrementalMemoryFlush().Forget();
+            }
+        }
+
+        public void ForceMemoryFlush()
+        {
+            if (!_isFlushingMemory)
+            {
+                IncrementalMemoryFlush().Forget();
+            }
+        }
+
+        public bool IsCurrentlyLoading()
+        {
+            return _isProcessingLoadQueue || _isProcessingUnloadQueue || _isFlushingMemory;
+        }
+
+        public int GetLoadedSceneCount()
+        {
+            return _loadedScenes.Count;
+        }
+
+        public int GetPendingOperationCount()
+        {
+            return _loadQueue.Count + _unloadQueue.Count;
+        }
     }
 }

package/Runtime/AdditiveLoading/WorldManager.cs

@@ -1,5 +1,4 @@
 using System.Collections.Generic;
-using System.Linq;
 using UnityEngine;
 using jeanf.EventSystem;
 using jeanf.propertyDrawer;
@@ -14,36 +13,57 @@ namespace jeanf.scenemanagement
         public bool isDebug = false;
         private SceneLoader _sceneLoader;
         public List<Region> ListOfRegions;
+        
         private Dictionary<string, Zone> _zoneDictionary = new Dictionary<string, Zone>();
         private Dictionary<string, Region> _regionDictionary = new Dictionary<string, Region>();
         private Dictionary<string, Region> _regionDictionaryPerZone = new Dictionary<string, Region>();
-        private Dictionary<Collider, Region> _regionDictionaryPerCollider = new Dictionary<Collider, Region>();
         private Dictionary<string, List<SceneReference>> _dependenciesPerRegion = new Dictionary<string, List<SceneReference>>();
+        private Dictionary<string, List<string>> _compiledSceneLists = new Dictionary<string, List<string>>();
+        private HashSet<string> _landingZoneIds = new HashSet<string>();
 
         private List<Region> _activeRegions = new List<Region>();
-        private List<GameObject> _activeZones = new List<GameObject>();
+        private bool _mappingInitialized = false;
+        
+        private List<string> _tempSceneNames = new List<string>();
+        private List<Region> _tempRegionsToRemove = new List<Region>();
 
         [SerializeField] private StringEventChannelSO regionChangeRequestChannel;
         [SerializeField] private SendTeleportTarget sendTeleportTarget;
 
         [ReadOnly] [SerializeField] private Zone _currentPlayerZone;
+        [ReadOnly] [SerializeField] private Region _currentPlayerRegion;
+        
         private static WorldManager Instance;
+        private static bool _isRegionTransitioning = false;
+        
         public static Zone CurrentPlayerZone 
         { 
-            get => Instance._currentPlayerZone;
-            private set => Instance._currentPlayerZone = value;
+            get => Instance?._currentPlayerZone;
+            private set 
+            {
+                if (Instance != null)
+                {
+                    Instance._currentPlayerZone = value;
+                }
+            }
         }
         
-        [ReadOnly] [SerializeField] private Region _currentPlayerRegion;
         public static Region CurrentPlayerRegion
         { 
-            get => Instance._currentPlayerRegion;
-            private set => Instance._currentPlayerRegion = value;
+            get => Instance?._currentPlayerRegion;
+            private set 
+            {
+                if (Instance != null)
+                {
+                    Instance._currentPlayerRegion = value;
+                }
+            }
         }
 
+        public static bool IsRegionTransitioning => _isRegionTransitioning;
+
         public delegate void SendId(string newRegionID);
         public static SendId RequestRegionChange;
-        
         public static SendId PublishCurrentRegionId;
         public static SendId PublishCurrentZoneId;
         
@@ -54,7 +74,8 @@ namespace jeanf.scenemanagement
         public static BroadcastAppList _broadcastAppList;
 
         private bool hasGameBeenInitialized = false;
-        
+        private string _lastNotifiedZone = "";
+        private string _lastNotifiedRegion = "";
 
         private void Awake()
         {
@@ -71,7 +92,6 @@ namespace jeanf.scenemanagement
         {
             regionChangeRequestChannel.OnEventRaised += OnRegionChange;
             RequestRegionChange += OnRegionChange;
-            
             ResetWorld += Init;
             ScenarioManager.OnZoneOverridesChanged += OnZoneOverridesChanged;
         }
@@ -80,112 +100,214 @@ namespace jeanf.scenemanagement
         {
             regionChangeRequestChannel.OnEventRaised -= OnRegionChange;
             RequestRegionChange -= OnRegionChange;
-            
             ResetWorld -= Init;
             ScenarioManager.OnZoneOverridesChanged -= OnZoneOverridesChanged;
         }
 
-
         private void Init()
         {
-            if(isDebug) Debug.Log($"[WorldManager] World reset.");
             hasGameBeenInitialized = false;
+            _currentPlayerZone = null;
+            _currentPlayerRegion = null;
+            _lastNotifiedZone = "";
+            _lastNotifiedRegion = "";
+            _isRegionTransitioning = false;
+            
+            ClearAllMappings();
+            BuildDataMappings();
+        }
+        
+        private void ClearAllMappings()
+        {
+            _zoneDictionary.Clear();
+            _regionDictionary.Clear();
+            _regionDictionaryPerZone.Clear();
+            _dependenciesPerRegion.Clear();
+            _compiledSceneLists.Clear();
+            _landingZoneIds.Clear();
+            _activeRegions.Clear();
+            _tempSceneNames.Clear();
+            _tempRegionsToRemove.Clear();
+            _mappingInitialized = false;
+        }
+        
+        private void BuildDataMappings()
+        {
+            if (_mappingInitialized) return;
+            
+            var regionCount = ListOfRegions?.Count ?? 0;
+            if (regionCount == 0) return;
+            
             foreach (var region in ListOfRegions)
             {
-                // build region Dictionary
-                if(isDebug) Debug.Log($"[WorldManager] Adding region with id: {region.id.id} to the region dictionary.");
-                _regionDictionary.TryAdd(region.id, region);
+                if (region == null) continue;
+                if (!_regionDictionary.TryAdd(region.id, region)) continue;
+                
+                _dependenciesPerRegion.TryAdd(region.id, region.dependenciesInThisRegion);
+                PrecompileSceneList(region);
                 
-                // build scenario Dictionary
-                foreach (var scenario in region.scenariosInThisRegion)
+                if (region.scenariosInThisRegion != null)
                 {
-                    if(isDebug) Debug.Log($"[WorldManager] Adding scenario with id: {scenario.id.id} to the scenario dictionary.");
-                    ScenarioManager.ScenarioDictionary.TryAdd(scenario.id, scenario);
+                    foreach (var scenario in region.scenariosInThisRegion)
+                    {
+                        if (scenario != null)
+                        {
+                            ScenarioManager.ScenarioDictionary.TryAdd(scenario.id, scenario);
+                        }
+                    }
                 }
 
-                // build zoneData Dictionary
-                foreach (var zone in region.zonesInThisRegion)
+                if (region.zonesInThisRegion != null)
                 {
-                    if(isDebug) Debug.Log($"[WorldManager] Adding zone with id: {zone.id} to the zone dictionary.");
-                    _zoneDictionary.TryAdd(zone.id, zone);
-                    _regionDictionaryPerZone.TryAdd(zone.id, region);
-                }   
-
-                // build dependency Dictionary
-                if(isDebug) Debug.Log($"[WorldManager] Adding list of dependencies for the region with id: {region.id.id} to the dependency dictionary.");
-                _dependenciesPerRegion.TryAdd(region.id, region.dependenciesInThisRegion);
+                    foreach (var zone in region.zonesInThisRegion)
+                    {
+                        if (zone != null)
+                        {
+                            _zoneDictionary.TryAdd(zone.id, zone);
+                            _regionDictionaryPerZone.TryAdd(zone.id, region);
+                        }
+                    }
+                }
+            }
+            
+            BuildLandingZoneCache();
+            _mappingInitialized = true;
+        }
+        
+        private void PrecompileSceneList(Region region)
+        {
+            var sceneNames = new List<string>(region.dependenciesInThisRegion.Count);
+            foreach (var dependency in region.dependenciesInThisRegion)
+            {
+                sceneNames.Add(dependency.SceneName);
+            }
+            _compiledSceneLists[region.id] = sceneNames;
+        }
+        
+        private void BuildLandingZoneCache()
+        {
+            var connectivity = FindObjectOfType<RegionConnectivityAuthoring>();
+            if (connectivity?.regionConnectivity?.landingZones == null) return;
+            
+            foreach (var landing in connectivity.regionConnectivity.landingZones)
+            {
+                if (landing?.landingZone != null)
+                {
+                    _landingZoneIds.Add(landing.landingZone.id);
+                }
             }
         }
         
         public static void NotifyZoneChangeFromECS(string zoneId)
         {
-            if (Instance != null)
+            if (Instance != null && !_isRegionTransitioning)
             {
                 Instance.OnZoneChangedFromECS(zoneId);
             }
         }
+        
+        public static void NotifyRegionChangeFromECS(string regionId)
+        {
+            if (Instance != null && !_isRegionTransitioning)
+            {
+                Instance.OnRegionChangedFromECS(regionId);
+            }
+        }
 
         private void OnZoneChangedFromECS(string zoneId)
         {
+            if (string.IsNullOrEmpty(zoneId) || _lastNotifiedZone == zoneId) return;
+            
             if (!_zoneDictionary.TryGetValue(zoneId, out var zone)) return;
-    
-            CurrentPlayerZone = zone;
-            PublishCurrentZoneId?.Invoke(zone.id.id);
+
+            _lastNotifiedZone = zoneId;
+            _currentPlayerZone = zone;
+            
+            PublishCurrentZoneId?.Invoke(zone.id);
             PublishAppList(zone);
-    
-            var newRegion = _regionDictionaryPerZone[zone.id.id];
-            if(newRegion != CurrentPlayerRegion) OnRegionChange(newRegion);
         }
+        
+        private void OnRegionChangedFromECS(string regionId)
+        {
+            if (string.IsNullOrEmpty(regionId) || _lastNotifiedRegion == regionId) return;
+            
+            if (!_regionDictionary.TryGetValue(regionId, out var region)) return;
+            
+            _lastNotifiedRegion = regionId;
+            _currentPlayerRegion = region;
+            
+            OnRegionChange(region);
+        }
+        
         private void OnZoneOverridesChanged(string zoneId)
         {
-            // Only update if we're in the affected zone
-            if (CurrentPlayerZone.id == zoneId)
+            if (CurrentPlayerZone != null && CurrentPlayerZone.id == zoneId)
             {
                 PublishAppList(CurrentPlayerZone);
             }
         }
 
-        private void SetCurrentZoneAndRegion(GameObject gameObject, Zone zone)
-        {
-            if (!gameObject.CompareTag("Player")) return;
-            CurrentPlayerZone = zone;
-            PublishCurrentZoneId?.Invoke(zone.id);
-            PublishAppList(zone);
-            var newRegion = _regionDictionaryPerZone[zone.id];
-            if(newRegion != CurrentPlayerRegion) OnRegionChange(newRegion);
-        }
-
         private void OnRegionChange(string newRegionID)
         {
             if (!_regionDictionary.TryGetValue(newRegionID, out var region)) return;
             OnRegionChange(region);
         }
         
-        // ReSharper disable Unity.PerformanceAnalysis
         private void OnRegionChange(Region region)
         {
-            CurrentPlayerRegion = region;
-            PublishCurrentRegionId?.Invoke(CurrentPlayerRegion.id);
+            _isRegionTransitioning = true;
+            
+            _currentPlayerRegion = region;
+            _lastNotifiedRegion = region.id;
+            
+            PublishCurrentRegionId?.Invoke(_currentPlayerRegion.id);
 
-            var currentActiveRegion = _activeRegions;
-            var regionsToRemove = currentActiveRegion.Select(RequestUnLoadForObsoleteRegion).ToList();
+            _tempRegionsToRemove.Clear();
+            foreach (var activeRegion in _activeRegions)
+            {
+                var removedRegion = RequestUnLoadForObsoleteRegion(activeRegion);
+                _tempRegionsToRemove.Add(removedRegion);
+            }
 
-            foreach (var r in regionsToRemove)
+            foreach (var r in _tempRegionsToRemove)
             {
                 _activeRegions.Remove(r);
             }
             
             RequestLoadForRegionDependencies(region);
 
-            // set teleporting position
             var spawnPos = SetTeleportTarget(region, hasGameBeenInitialized);
-            sendTeleportTarget.transform.position = spawnPos.position;
-            sendTeleportTarget.transform.rotation = Quaternion.Euler(spawnPos.rotation);
-            // teleport!
-            sendTeleportTarget.Teleport();
             
-            Debug.Log($"[WorldManager] Current region: {region.levelName}.");
+            if (sendTeleportTarget != null)
+            {
+                sendTeleportTarget.transform.position = spawnPos.position;
+                sendTeleportTarget.transform.rotation = Quaternion.Euler(spawnPos.rotation);
+                sendTeleportTarget.Teleport();
+            }
+            
             _activeRegions.Add(region);
+            
+            StartCoroutine(CompleteRegionTransition());
+        }
+
+        private System.Collections.IEnumerator CompleteRegionTransition()
+        {
+            yield return new WaitForEndOfFrame();
+            yield return new WaitForEndOfFrame();
+            
+            _isRegionTransitioning = false;
+            
+            if (_currentPlayerRegion?.zonesInThisRegion != null && _currentPlayerRegion.zonesInThisRegion.Count > 0)
+            {
+                var firstZone = _currentPlayerRegion.zonesInThisRegion[0];
+                if (firstZone != null)
+                {
+                    _currentPlayerZone = firstZone;
+                    _lastNotifiedZone = firstZone.id;
+                    PublishCurrentZoneId?.Invoke(firstZone.id);
+                    PublishAppList(firstZone);
+                }
+            }
         }
 
         private SpawnPos SetTeleportTarget(Region region, bool hasRegionBeenInitialized)
@@ -203,39 +325,59 @@ namespace jeanf.scenemanagement
         private void PublishAppList(Zone zone)
         {
             var listToBroadcast = zone.DefaultAppsInZone;
-            if(isDebug) Debug.Log($"[WorldManager] Default list for zone [{zone.name}] : [{string.Join(", ", listToBroadcast)}]");
-            // check if for this zone there is no override 
             if (ScenarioManager.activeOverridesPerZone.TryGetValue(zone.id, out var value))
             {
-                // if yes, send override list
                 listToBroadcast = value;
-                if(isDebug) Debug.Log($"[WorldManager] List override found for zone [{zone.name}] : [{string.Join(", ", listToBroadcast)}]");
             }
             
-            // broadcast list
             _broadcastAppList?.Invoke(listToBroadcast);
         }
 
         private void RequestLoadForRegionDependencies(Region region)
         {
-            if ( region.dependenciesInThisRegion.Count <= 0 ) return;
-            foreach (var scene in CompileSceneList(region))
+            if (!_compiledSceneLists.TryGetValue(region.id, out var sceneNames) || sceneNames.Count <= 0) return;
+            
+            foreach (var sceneName in sceneNames)
             {
-                _sceneLoader.LoadSceneRequest(scene);
+                _sceneLoader.LoadSceneRequest(sceneName);
             }
         }
+        
         private Region RequestUnLoadForObsoleteRegion(Region region)
         {
-            foreach (var scene in CompileSceneList(region))
+            if (_compiledSceneLists.TryGetValue(region.id, out var sceneNames))
             {
-                _sceneLoader.UnLoadSceneRequest(scene);
+                foreach (var sceneName in sceneNames)
+                {
+                    _sceneLoader.UnLoadSceneRequest(sceneName);
+                }
             }
             return region;
         }
-        
-        private static List<string> CompileSceneList(Region region)
+
+        public bool IsLandingZone(string zoneId)
+        {
+            return _landingZoneIds.Contains(zoneId);
+        }
+
+        public HashSet<string> GetLandingZoneIds()
+        {
+            return _landingZoneIds;
+        }
+
+        public static Dictionary<string, Zone> GetZoneDictionary()
+        {
+            return Instance?._zoneDictionary;
+        }
+
+        public static Dictionary<string, Region> GetRegionDictionary()
+        {
+            return Instance?._regionDictionary;
+        }
+
+        public static Dictionary<string, Region> GetRegionDictionaryPerZone()
         {
-            return region.dependenciesInThisRegion.Select(dependency => dependency.SceneName).ToList();
+            return Instance?._regionDictionaryPerZone;
         }
     }
 }