fr.jeanf.scenemanagement 0.2.0 → 0.3.0

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/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;
         }
     }
 }

package/Runtime/DynamicLoading/FollowSystem.cs

@@ -1,4 +1,5 @@
 using Unity.Burst;
+using Unity.Collections;
 using Unity.Entities;
 using Unity.Mathematics;
 using Unity.Transforms;
@@ -9,39 +10,48 @@ namespace jeanf.scenemanagement
     [UpdateInGroup(typeof(InitializationSystemGroup))]
     public partial struct FollowSystem : ISystem
     {
-        private float3 _currentCameraPosition;
         private float3 _lastCameraPosition;
         private const float MIN_POSITION_CHANGE = 0.1f;
+        private const float MIN_POSITION_CHANGE_SQ = MIN_POSITION_CHANGE * MIN_POSITION_CHANGE;
+        private bool _isInitialized;
         
         [BurstCompile]
         public void OnCreate(ref SystemState state)
         {
             state.RequireForUpdate<FollowComponent>();
             _lastCameraPosition = float3.zero;
+            _isInitialized = false;
         }
         
         public void OnUpdate(ref SystemState state)
         {
             if (Camera.main == null) return;
             
-            _currentCameraPosition = Camera.main.transform.position;
+            var currentCameraPosition = (float3)Camera.main.transform.position;
             
-            bool isFirstUpdate = math.all(math.abs(_lastCameraPosition) < 0.001f);
-            float distanceSq = math.distancesq(_lastCameraPosition, _currentCameraPosition);
-            
-            if (isFirstUpdate || distanceSq >= MIN_POSITION_CHANGE * MIN_POSITION_CHANGE)
+            if (!_isInitialized)
             {
-                _lastCameraPosition = _currentCameraPosition;
+                _lastCameraPosition = currentCameraPosition;
+                _isInitialized = true;
                 
-                new FollowJob
+                state.Dependency = new FollowJob
                 {
-                    CameraPosition = _currentCameraPosition
-                }.ScheduleParallel(state.Dependency).Complete();
+                    CameraPosition = currentCameraPosition
+                }.ScheduleParallel(state.Dependency);
+                
+                return;
+            }
+            
+            float distanceSq = math.distancesq(_lastCameraPosition, currentCameraPosition);
+            
+            if (distanceSq >= MIN_POSITION_CHANGE_SQ)
+            {
+                _lastCameraPosition = currentCameraPosition;
                 
-                if (isFirstUpdate)
+                state.Dependency = new FollowJob
                 {
-                    UnityEngine.Debug.Log($"FollowSystem: Initial position update at {_currentCameraPosition}");
-                }
+                    CameraPosition = currentCameraPosition
+                }.ScheduleParallel(state.Dependency);
             }
         }
         
@@ -51,6 +61,7 @@ namespace jeanf.scenemanagement
         [BurstCompile]
         private partial struct FollowJob : IJobEntity
         {
+            [ReadOnly]
             public float3 CameraPosition;
             
             public void Execute(ref LocalTransform transform, in FollowComponent _)

package/Runtime/DynamicLoading/RegionConnectivity.cs

@@ -16,6 +16,10 @@ namespace jeanf.scenemanagement
         [Tooltip("Landing zones for manual teleportation between regions")]
         public List<LandingZoneData> landingZones = new List<LandingZoneData>();
         
+        [Header("Zone Connectivity")]
+        [Tooltip("Define which zones are neighbors within the same region")]
+        public List<ZoneNeighborData> zoneConnections = new List<ZoneNeighborData>();
+        
         public List<Zone> GetZonesForRegion(Region region)
         {
             return region != null ? region.zonesInThisRegion : new List<Zone>();
@@ -32,10 +36,33 @@ namespace jeanf.scenemanagement
             return result;
         }
         
+        public List<Zone> GetNeighborsForZone(Zone zone)
+        {
+            var result = new List<Zone>();
+            foreach (var connection in zoneConnections)
+            {
+                if (connection.zoneA == zone && connection.zoneB != null)
+                    result.Add(connection.zoneB);
+                else if (connection.zoneB == zone && connection.zoneA != null)
+                    result.Add(connection.zoneA);
+            }
+            return result;
+        }
+        
         public bool IsRegionActive(Region region)
         {
             return activeRegions.Contains(region);
         }
+        
+        public bool IsLandingZone(Zone zone)
+        {
+            foreach (var landing in landingZones)
+            {
+                if (landing.landingZone == zone)
+                    return true;
+            }
+            return false;
+        }
     }
     
     [System.Serializable]
@@ -44,4 +71,13 @@ namespace jeanf.scenemanagement
         public Region region;
         public Zone landingZone;
     }
+    
+    [System.Serializable]
+    public class ZoneNeighborData
+    {
+        public Zone zoneA;
+        public Zone zoneB;
+        [Tooltip("Bidirectional connection between these zones")]
+        public bool isBidirectional = true;
+    }
 }

package/Runtime/DynamicLoading/VolumeSystem.cs

@@ -16,16 +16,20 @@ namespace jeanf.scenemanagement
         private NativeList<Entity> _activeVolumes;
         private NativeList<(Entity, LevelInfo)> _toLoadList;
         private NativeList<(Entity, LevelInfo)> _toUnloadList;
-        private NativeHashSet<FixedString128Bytes> _relevantZoneIds;
+        private NativeHashSet<FixedString128Bytes> _checkableZoneIds;
         
         private EntityQuery _relevantQuery;
         private EntityQuery _volumeQuery;
         
         private FixedString128Bytes _currentPlayerZone;
-        private FixedString128Bytes _currentRegionId;
+        private FixedString128Bytes _currentPlayerRegion;
+        private FixedString128Bytes _lastNotifiedZone;
+        private FixedString128Bytes _lastNotifiedRegion;
         
-        private int _frameCounter;
-        private const int DEBUG_FREQUENCY = 60;
+        private NativeHashMap<FixedString128Bytes, FixedString128Bytes> _zoneToRegionMap;
+        private NativeHashMap<FixedString128Bytes, NativeList<FixedString128Bytes>> _zoneNeighbors;
+        private NativeHashSet<FixedString128Bytes> _landingZones;
+        private bool _mappingInitialized;
         
         [BurstCompile]
         public void OnCreate(ref SystemState state)
@@ -36,8 +40,16 @@ namespace jeanf.scenemanagement
             _activeVolumes = new NativeList<Entity>(100, Allocator.Persistent);
             _toLoadList = new NativeList<(Entity, LevelInfo)>(10, Allocator.Persistent);
             _toUnloadList = new NativeList<(Entity, LevelInfo)>(10, Allocator.Persistent);
-            _relevantZoneIds = new NativeHashSet<FixedString128Bytes>(50, Allocator.Persistent);
+            _checkableZoneIds = new NativeHashSet<FixedString128Bytes>(50, Allocator.Persistent);
+            _zoneToRegionMap = new NativeHashMap<FixedString128Bytes, FixedString128Bytes>(100, Allocator.Persistent);
+            _zoneNeighbors = new NativeHashMap<FixedString128Bytes, NativeList<FixedString128Bytes>>(100, Allocator.Persistent);
+            _landingZones = new NativeHashSet<FixedString128Bytes>(50, Allocator.Persistent);
+            
             _currentPlayerZone = new FixedString128Bytes();
+            _currentPlayerRegion = new FixedString128Bytes();
+            _lastNotifiedZone = new FixedString128Bytes();
+            _lastNotifiedRegion = new FixedString128Bytes();
+            _mappingInitialized = false;
             
             _relevantQuery = SystemAPI.QueryBuilder().WithAll<Relevant, LocalToWorld>().Build();
             _volumeQuery = SystemAPI.QueryBuilder().WithAll<Volume, LocalToWorld>().Build();
@@ -49,14 +61,21 @@ namespace jeanf.scenemanagement
             if (_activeVolumes.IsCreated) _activeVolumes.Dispose();
             if (_toLoadList.IsCreated) _toLoadList.Dispose();
             if (_toUnloadList.IsCreated) _toUnloadList.Dispose();
-            if (_relevantZoneIds.IsCreated) _relevantZoneIds.Dispose();
+            if (_checkableZoneIds.IsCreated) _checkableZoneIds.Dispose();
+            if (_zoneToRegionMap.IsCreated) _zoneToRegionMap.Dispose();
+            if (_landingZones.IsCreated) _landingZones.Dispose();
+            if (_zoneNeighbors.IsCreated)
+            {
+                foreach (var kvp in _zoneNeighbors)
+                {
+                    if (kvp.Value.IsCreated) kvp.Value.Dispose();
+                }
+                _zoneNeighbors.Dispose();
+            }
         }
 
         public void OnUpdate(ref SystemState state)
         {
-            _frameCounter++;
-            bool shouldDebug = _frameCounter % DEBUG_FREQUENCY == 0;
-            
             _activeVolumes.Clear();
             _toLoadList.Clear();
             _toUnloadList.Clear();
@@ -70,99 +89,178 @@ namespace jeanf.scenemanagement
             }
             
             var playerPosition = relevantPositions[0].Position;
+            relevantPositions.Dispose();
             
-            UpdateRelevantZones(ref state);
+            if (!_mappingInitialized)
+            {
+                BuildConnectivityMappings(ref state);
+                _mappingInitialized = true;
+            }
             
-            var volumeEntities = _volumeQuery.ToEntityArray(Allocator.TempJob);
-            var volumeTransforms = _volumeQuery.ToComponentDataArray<LocalToWorld>(Allocator.TempJob);
-            var volumes = _volumeQuery.ToComponentDataArray<Volume>(Allocator.TempJob);
+            UpdateCheckableZones();
             
-            FixedString128Bytes newPlayerZone = new FixedString128Bytes();
+            var newPlayerZone = CheckVolumesForPlayerZone(ref state, playerPosition);
+            CheckForZoneAndRegionChange(newPlayerZone);
+            ProcessLevelLoadingStates(ref state);
+        }
+        
+        private FixedString128Bytes CheckVolumesForPlayerZone(ref SystemState state, float3 playerPosition)
+        {
+            var newPlayerZone = new FixedString128Bytes();
             
-            for (int i = 0; i < volumeEntities.Length; i++)
+            foreach (var (volume, transform, entity) in 
+                     SystemAPI.Query<RefRO<Volume>, RefRO<LocalToWorld>>().WithEntityAccess())
             {
-                var volume = volumes[i];
-                
-                if (!_relevantZoneIds.Contains(volume.ZoneId) && !volume.ZoneId.IsEmpty)
+                if (!ShouldCheckVolume(volume.ValueRO.ZoneId))
                     continue;
                 
-                var volumeTransform = volumeTransforms[i];
-                var range = volume.Scale / 2f;
-                var pos = volumeTransform.Position;
+                var range = volume.ValueRO.Scale / 2f;
+                var pos = transform.ValueRO.Position;
                 var distance = math.abs(playerPosition - pos);
                 var insideAxis = (distance < range);
                 
                 if (insideAxis.x && insideAxis.y && insideAxis.z)
                 {
-                    _activeVolumes.Add(volumeEntities[i]);
+                    _activeVolumes.Add(entity);
                     
-                    if (!volume.ZoneId.IsEmpty && newPlayerZone.IsEmpty)
+                    if (!volume.ValueRO.ZoneId.IsEmpty && newPlayerZone.IsEmpty)
                     {
-                        newPlayerZone = volume.ZoneId;
+                        newPlayerZone = volume.ValueRO.ZoneId;
                     }
                 }
             }
             
-            CheckForZoneChange(newPlayerZone, shouldDebug);
-            ProcessLevelLoadingStates(ref state);
-            
-            relevantPositions.Dispose();
-            volumeEntities.Dispose();
-            volumeTransforms.Dispose();
-            volumes.Dispose();
+            return newPlayerZone;
         }
         
-        private void UpdateRelevantZones(ref SystemState state)
+        private void BuildConnectivityMappings(ref SystemState state)
         {
-            _relevantZoneIds.Clear();
+            _zoneToRegionMap.Clear();
+            _landingZones.Clear();
+            
+            foreach (var kvp in _zoneNeighbors)
+            {
+                if (kvp.Value.IsCreated) kvp.Value.Dispose();
+            }
+            _zoneNeighbors.Clear();
             
             foreach (var (regionBuffer, zoneBuffer, landingBuffer) in 
                      SystemAPI.Query<DynamicBuffer<RegionBuffer>, DynamicBuffer<ZoneIdBuffer>, DynamicBuffer<LandingZoneBuffer>>())
             {
-                foreach (var regionData in regionBuffer)
+                foreach (var landingData in landingBuffer)
                 {
-                    if (regionData.regionId.Equals(_currentRegionId))
+                    if (!landingData.landingZoneId.IsEmpty)
                     {
-                        for (int i = 0; i < regionData.zoneCount; i++)
-                        {
-                            var zoneIndex = regionData.zoneStartIndex + i;
-                            if (zoneIndex < zoneBuffer.Length)
-                            {
-                                _relevantZoneIds.Add(zoneBuffer[zoneIndex].zoneId);
-                            }
-                        }
-                        break;
+                        _landingZones.Add(landingData.landingZoneId);
                     }
                 }
                 
-                foreach (var landingData in landingBuffer)
+                foreach (var regionData in regionBuffer)
                 {
-                    if (!landingData.landingZoneId.IsEmpty)
+                    var regionZones = new NativeList<FixedString128Bytes>(regionData.zoneCount, Allocator.Temp);
+                    
+                    for (int i = 0; i < regionData.zoneCount; i++)
                     {
-                        _relevantZoneIds.Add(landingData.landingZoneId);
+                        var zoneIndex = regionData.zoneStartIndex + i;
+                        if (zoneIndex < zoneBuffer.Length)
+                        {
+                            var zoneId = zoneBuffer[zoneIndex].zoneId;
+                            _zoneToRegionMap.TryAdd(zoneId, regionData.regionId);
+                            regionZones.Add(zoneId);
+                        }
+                    }
+                    
+                    for (int i = 0; i < regionZones.Length; i++)
+                    {
+                        var zoneA = regionZones[i];
+                        if (!_zoneNeighbors.ContainsKey(zoneA))
+                        {
+                            _zoneNeighbors[zoneA] = new NativeList<FixedString128Bytes>(10, Allocator.Persistent);
+                        }
+                        
+                        for (int j = 0; j < regionZones.Length; j++)
+                        {
+                            if (i == j) continue;
+                            var zoneB = regionZones[j];
+                            _zoneNeighbors[zoneA].Add(zoneB);
+                        }
                     }
+                    
+                    regionZones.Dispose();
                 }
             }
         }
         
-        private void CheckForZoneChange(FixedString128Bytes newPlayerZone, bool shouldDebug)
+        private void UpdateCheckableZones()
+        {
+            _checkableZoneIds.Clear();
+            
+            if (_currentPlayerZone.IsEmpty)
+            {
+                return;
+            }
+            
+            _checkableZoneIds.Add(_currentPlayerZone);
+            
+            if (_zoneNeighbors.TryGetValue(_currentPlayerZone, out var neighbors))
+            {
+                foreach (var neighbor in neighbors)
+                {
+                    _checkableZoneIds.Add(neighbor);
+                }
+            }
+            
+            foreach (var landingZone in _landingZones)
+            {
+                _checkableZoneIds.Add(landingZone);
+            }
+        }
+        
+        private bool ShouldCheckVolume(FixedString128Bytes zoneId)
+        {
+            if (zoneId.IsEmpty) return false;
+            
+            if (_currentPlayerZone.IsEmpty)
+            {
+                return true;
+            }
+            
+            return _checkableZoneIds.Contains(zoneId);
+        }
+        
+        private void CheckForZoneAndRegionChange(FixedString128Bytes newPlayerZone)
         {
-            bool hasChanged = !_currentPlayerZone.Equals(newPlayerZone);
+            bool zoneChanged = !_currentPlayerZone.Equals(newPlayerZone);
+            bool regionChanged = false;
+            FixedString128Bytes newPlayerRegion = new FixedString128Bytes();
 
-            if (!hasChanged) return;
-            _currentPlayerZone = newPlayerZone;
+            if (!newPlayerZone.IsEmpty && _zoneToRegionMap.TryGetValue(newPlayerZone, out newPlayerRegion))
+            {
+                regionChanged = !_currentPlayerRegion.Equals(newPlayerRegion);
+            }
 
-            if (newPlayerZone.IsEmpty) return;
-                
-            var zoneString = newPlayerZone.ToString();
-                    
-            try 
+            if (zoneChanged)
             {
+                _currentPlayerZone = newPlayerZone;
+            }
+
+            if (regionChanged)
+            {
+                _currentPlayerRegion = newPlayerRegion;
+            }
+
+            if (zoneChanged && !newPlayerZone.IsEmpty && !_lastNotifiedZone.Equals(newPlayerZone))
+            {
+                _lastNotifiedZone = newPlayerZone;
+                var zoneString = newPlayerZone.ToString();
                 WorldManager.NotifyZoneChangeFromECS(zoneString);
             }
-            catch (System.Exception e)
+            
+            if (regionChanged && !newPlayerRegion.IsEmpty && !_lastNotifiedRegion.Equals(newPlayerRegion))
             {
-                Debug.LogError($"[VolumeSystem] Failed to notify WorldManager: {e.Message}");
+                _lastNotifiedRegion = newPlayerRegion;
+                var regionString = newPlayerRegion.ToString();
+                WorldManager.NotifyRegionChangeFromECS(regionString);
             }
         }
         
@@ -209,10 +307,5 @@ namespace jeanf.scenemanagement
                 state.EntityManager.SetComponentData(entity, streamingData);
             }
         }
-        
-        public void SetCurrentRegion(Region region)
-        {
-            _currentRegionId = region != null ? region.id.ToString() : "";
-        }
     }
 }

package/Samples/Example/RegionData/Region_00/Region_00.asset

@@ -13,7 +13,7 @@ MonoBehaviour:
   m_Name: Region_00
   m_EditorClassIdentifier: 
   id:
-    id: f6a8a488-c421-48db-8b31-fc5d846a16fa
+    id: d9233b0a-3c2a-4728-a997-e89055537269
   Coordinate:
     x: 0
     y: 0

package/Samples/Example/RegionData/Region_01/Region_01.asset

@@ -13,12 +13,12 @@ MonoBehaviour:
   m_Name: Region_01
   m_EditorClassIdentifier: 
   id:
-    id: 5bc341eb-447c-4f47-92c3-399166f25b03
+    id: 05887829-c6fb-4cd5-9a35-ef4ab431c7fe
   Coordinate:
     x: 0
     y: 0
-  levelName: region_00
-  level: 0
+  levelName: region_01
+  level: 1
   scenariosInThisRegion:
   - {fileID: 11400000, guid: da48d91e553f86f47add3deca44799c2, type: 2}
   - {fileID: 11400000, guid: 1085c744a096c374dbfdb13da6e13e6f, type: 2}

package/Samples/Example/RegionData/Region_02/Region_02.asset

@@ -13,12 +13,12 @@ MonoBehaviour:
   m_Name: Region_02
   m_EditorClassIdentifier: 
   id:
-    id: 1a82c3ed-aff2-4136-a8d6-4247471c8381
+    id: 3684dbc5-143b-4b2b-9195-5ab04402213e
   Coordinate:
     x: 0
     y: 0
-  levelName: region_00
-  level: 0
+  levelName: region_02
+  level: 2
   scenariosInThisRegion:
   - {fileID: 11400000, guid: da48d91e553f86f47add3deca44799c2, type: 2}
   - {fileID: 11400000, guid: 1085c744a096c374dbfdb13da6e13e6f, type: 2}

package/Samples/Example/RegionData/Region_02/Zones/Zone_22.asset

@@ -13,7 +13,7 @@ MonoBehaviour:
   m_Name: Zone_22
   m_EditorClassIdentifier: 
   id:
-    id: 4ee6665f-c171-4a8c-b16c-3b6e1f23d37e
+    id: 2fe1cc83-e1d7-495b-8c62-f1700a1d1262
   zoneName: 2
   zoneNb: 22
   zoneType: 0

package/Samples/Example/RegionData/Region_02/Zones/Zone_23.asset

@@ -13,7 +13,7 @@ MonoBehaviour:
   m_Name: Zone_23
   m_EditorClassIdentifier: 
   id:
-    id: 4ee6665f-c171-4a8c-b16c-3b6e1f23d37e
+    id: 807cc93f-4673-4c0a-bf67-37d95e5b62e3
   zoneName: 3
   zoneNb: 23
   zoneType: 0

package/Samples/Example/RegionData/Region_02/Zones/Zone_24.asset

@@ -13,7 +13,7 @@ MonoBehaviour:
   m_Name: Zone_24
   m_EditorClassIdentifier: 
   id:
-    id: 4ee6665f-c171-4a8c-b16c-3b6e1f23d37e
+    id: 8c4d1bfb-b91e-4a76-ab5a-0b6801bf4278
   zoneName: 4
   zoneNb: 24
   zoneType: 0

package/Samples/Example/RegionData/Region_02/Zones/Zone_25.asset

@@ -13,7 +13,7 @@ MonoBehaviour:
   m_Name: Zone_25
   m_EditorClassIdentifier: 
   id:
-    id: 4ee6665f-c171-4a8c-b16c-3b6e1f23d37e
+    id: 075bb4ff-4d00-43e5-8d8e-109dba6444d1
   zoneName: 5
   zoneNb: 25
   zoneType: 0

package/Samples/Example/RegionData/Region_02/Zones/Zone_26.asset

@@ -13,7 +13,7 @@ MonoBehaviour:
   m_Name: Zone_26
   m_EditorClassIdentifier: 
   id:
-    id: 4ee6665f-c171-4a8c-b16c-3b6e1f23d37e
+    id: 6e8b1d72-370d-4821-89c0-2c6fcf25ba91
   zoneName: 6
   zoneNb: 26
   zoneType: 0

package/Samples/Example/RegionData/Region_02/Zones/Zone_27.asset

@@ -13,7 +13,7 @@ MonoBehaviour:
   m_Name: Zone_27
   m_EditorClassIdentifier: 
   id:
-    id: 4ee6665f-c171-4a8c-b16c-3b6e1f23d37e
+    id: 3198ecb4-00ce-4eea-9f2d-cd463dd5769f
   zoneName: 7
   zoneNb: 27
   zoneType: 0

package/Samples/Example/RegionData/Region_02/Zones/Zone_28.asset

@@ -13,7 +13,7 @@ MonoBehaviour:
   m_Name: Zone_28
   m_EditorClassIdentifier: 
   id:
-    id: 4ee6665f-c171-4a8c-b16c-3b6e1f23d37e
+    id: 7ae31390-180a-4bc4-ac71-7369452b3075
   zoneName: 8
   zoneNb: 28
   zoneType: 0

package/Samples/Example/Scenes/Main.unity

@@ -709,7 +709,7 @@ PrefabInstance:
     - target: {fileID: 8979075195523201058, guid: e87a4cab69290cb40805f373b8ccd8d7,
         type: 3}
       propertyPath: isDebug
-      value: 0
+      value: 1
       objectReference: {fileID: 0}
     m_RemovedComponents: []
     m_RemovedGameObjects: []
@@ -1119,7 +1119,7 @@ Light:
   m_InnerSpotAngle: 21.80208
   m_CookieSize: 10
   m_Shadows:
-    m_Type: 2
+    m_Type: 0
     m_Resolution: -1
     m_CustomResolution: -1
     m_Strength: 1
@@ -1154,7 +1154,7 @@ Light:
   m_RenderingLayerMask: 1
   m_Lightmapping: 4
   m_LightShadowCasterMode: 2
-  m_AreaSize: {x: 1, y: 1}
+  m_AreaSize: {x: 0.5, y: 0.5}
   m_BounceIntensity: 1
   m_ColorTemperature: 6570
   m_UseColorTemperature: 1
@@ -1227,7 +1227,7 @@ MonoBehaviour:
   m_IncludeForPathTracing: 1
   m_AreaLightShadowCone: 120
   m_UseScreenSpaceShadows: 0
-  m_InteractsWithSky: 1
+  m_InteractsWithSky: 0
   m_AngularDiameter: 0.5
   diameterMultiplerMode: 0
   diameterMultiplier: 1
@@ -1314,7 +1314,7 @@ MonoBehaviour:
   m_ShadowVariant: 0
   m_ShadowPrecision: 0
   useOldInspector: 0
-  useVolumetric: 1
+  useVolumetric: 0
   featuresFoldout: 1
   m_AreaLightEmissiveMeshShadowCastingMode: 0
   m_AreaLightEmissiveMeshMotionVectorGenerationMode: 0

package/Samples/Setup/AdditiveLoading.prefab

@@ -128,9 +128,13 @@ MonoBehaviour:
   isDebug: 0
   ListOfRegions:
   - {fileID: 11400000, guid: bbabf3e47905c1b4da96100c0b4e4484, type: 2}
+  - {fileID: 11400000, guid: 3be0bdecc77225043bf1a2f89f5cfc8c, type: 2}
+  - {fileID: 11400000, guid: 2b8d92f982a2908409fbc1c952eeebf8, type: 2}
   regionChangeRequestChannel: {fileID: 11400000, guid: 0a0e8a2adda6b6842901101278def4b1,
     type: 2}
   sendTeleportTarget: {fileID: 4547402059037323192}
+  _currentPlayerZone: {fileID: 0}
+  _currentPlayerRegion: {fileID: 0}
 --- !u!114 &2246953710021239090
 MonoBehaviour:
   m_ObjectHideFlags: 0
@@ -145,9 +149,11 @@ MonoBehaviour:
   m_EditorClassIdentifier: 
   BeginScenarioRequest: {fileID: 11400000, guid: 030966fcf034be946ab6123e0405c29b,
     type: 2}
-  EndScenarioRequest: {fileID: 11400000, guid: 7c9cef042075e874585508cd8bf5c84e, type: 2}
+  EndScenarioRequestSO: {fileID: 11400000, guid: 7c9cef042075e874585508cd8bf5c84e,
+    type: 2}
   KillAllScenariosRequest: {fileID: 11400000, guid: 64bcbaf957104ff4fa4e7a96c5c92639,
     type: 2}
+  automaticScenarioUnload: 1
 --- !u!1 &2311871612787447076
 GameObject:
   m_ObjectHideFlags: 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fr.jeanf.scenemanagement",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "displayName": "Scene Management",
   "description": "This package contains two scene loading system, one is additive, the other is to load subscenes. \nBoth system are living side-by-side.\nThe dynamic systems handles the loading of all static content (environment) using subscenes.\nThe additive system loads scene additively depending on zone & region and upon scenario load/unload requests. Each region or scenario can have dependency that will remain loaded until either a region or a scenario became irrelevant.",
   "unity": "2021.3",