feat: (Day) Add an instance controller for prep for future work (AscensionGameDev#2093)

* feat: (Day) Add an instance controller for prep for future work

* chore: (Day) Switch to hashset for instancecontroller player collection

* chore: (Day) Code review for instance controller

* chore: (Day) Code review for instance controller

* fix: (Day) Fix my broken PR

* chore: (Day) Code review

* chore: (Day) CR

Author: AlexVild

Intersect.Server.Core/Core/LogicService.LogicThread.cs

@@ -11,6 +11,7 @@
 using Intersect.Server.Database.PlayerData.Players;
 using Intersect.Utilities;
 using Intersect.Server.Database.PlayerData.Api;
+using Intersect.Server.Core.MapInstancing;
 
 namespace Intersect.Server.Core
 {
@@ -152,22 +153,31 @@ protected override void ThreadStart(ServerContext serverContext)
                             }
 
                             //Refresh list of active maps & their instances
-                            foreach (var layerId in ActiveMapInstances.Keys.ToArray())
+                            foreach (var (instanceId, mapInstance) in ActiveMapInstances.ToArray())
                             {
-                                if (!processedMapInstances.Contains(layerId))
+                                if (processedMapInstances.Contains(instanceId) || mapInstance.ShouldBeActive())
                                 {
-                                    // Remove the map entirely from the update queue
-                                    if (ActiveMapInstances[layerId] != null && ActiveMapInstances[layerId].ShouldBeCleaned())
+                                    continue;
+                                }
+
+                                if (mapInstance != default)
+                                {
+                                    if (mapInstance.ShouldBeCleaned())
                                     {
-                                        ActiveMapInstances[layerId].RemoveLayerFromController();
-                                        ActiveMapInstances.Remove(layerId);
-                                    } else if (ActiveMapInstances[layerId] == null || !ActiveMapInstances[layerId].ShouldBeActive())
+                                        mapInstance.RemoveLayerFromController();
+                                    }
+                                    else if (!mapInstance.ShouldBeActive())
                                     {
-                                        ActiveMapInstances.Remove(layerId);
+                                        mapInstance.ResetNpcSpawns();
                                     }
                                 }
+
+                                ActiveMapInstances.Remove(instanceId);
                             }
 
+                            // Allow our instance controllers to keep their instances up to date
+                            InstanceProcessor.UpdateInstanceControllers(ActiveMapInstances.Values.ToArray());
+
                             if (Options.Instance.Metrics.Enable)
                             {
                                 MetricsRoot.Instance.Game.ActiveEntities.Record(globalEntities);

Intersect.Server.Core/Core/MapInstancing/Controllers/InstanceController.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Intersect.Server.Entities;
+
+namespace Intersect.Server.Core.MapInstancing.Controllers;
+public class InstanceController
+{
+    public Guid InstanceId { get; set; }
+
+    public HashSet<Player> Players { get; set; } = new();
+
+    public InstanceController(Guid instanceId, Player creator)
+    {
+        InstanceId = instanceId;
+        AddPlayer(creator);
+    }
+
+    public void AddPlayer(Player player)
+    {
+        if (player == null || !player.Online)
+        {
+            return;
+        }
+        Players.Add(player);
+    }
+
+    public void RemovePlayer(Guid playerId)
+    {
+        Players.RemoveWhere(pl => pl.Id == playerId);
+    }
+}

Intersect.Server.Core/Core/MapInstancing/InstanceProcessor.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Intersect.Server.Core.MapInstancing.Controllers;
+using Intersect.Server.Entities;
+using Intersect.Server.Maps;
+
+namespace Intersect.Server.Core.MapInstancing;
+public static class InstanceProcessor
+{
+    private static Dictionary<Guid, InstanceController> InstanceControllers = new();
+
+    public static Guid[] CurrentControllers => InstanceControllers.Keys.ToArray();
+
+    public static bool TryGetInstanceController(Guid instanceId, out InstanceController controller)
+    {
+        return InstanceControllers.TryGetValue(instanceId, out controller);
+    }
+
+    private static void CleanupOrphanedControllers(IEnumerable<Guid> activeInstanceIds)
+    {
+        var processingInstances = InstanceControllers.Keys
+            .Except(activeInstanceIds)
+            .Except(new Guid[1] { default }) // Never cleanup the overworld instance
+            .ToArray();
+
+        foreach (var id in processingInstances)
+        {
+            InstanceControllers.Remove(id);
+            Logging.Log.Debug($"Removing instance controller {id}");
+        }
+    }
+
+    public static bool TryAddInstanceController(Guid mapInstanceId, Player creator)
+    {
+        if (InstanceControllers.ContainsKey(mapInstanceId))
+        {
+            return false;
+        }
+
+        InstanceControllers[mapInstanceId] = new InstanceController(mapInstanceId, creator);
+        return true;
+    }
+
+    public static void UpdateInstanceControllers(MapInstance[] activeMaps)
+    {
+        if (activeMaps == null || activeMaps.Length == 0)
+        {
+            return;
+        }
+
+        // Cleanup inactive instances
+        CleanupOrphanedControllers(activeMaps.Select(map => map.MapInstanceId));
+
+        Dictionary<Guid, MapInstance[]> mapsAndInstances = activeMaps
+            .GroupBy(m => m.MapInstanceId)
+            .ToDictionary(m => m.Key, m => m.ToArray());
+
+        // For each instance...
+        foreach (var (instanceId, mapsInInstance) in mapsAndInstances)
+        {
+            // Fetch our instance controller...
+            if (!InstanceControllers.TryGetValue(instanceId, out var instanceController))
+            {
+                continue;
+            }
+
+            // TODO do update-y things in here, i.e processing permadead NPCs. Keeping empty for initial code review
+        }
+    }
+}

Intersect.Server.Core/Entities/Events/CommandProcessing.cs

@@ -7,6 +7,7 @@
 using Intersect.GameObjects.Events;
 using Intersect.GameObjects.Events.Commands;
 using Intersect.GameObjects.Switches_and_Variables;
+using Intersect.Server.Core.MapInstancing;
 using Intersect.Server.Database;
 using Intersect.Server.Database.PlayerData.Players;
 using Intersect.Server.Database.PlayerData.Security;
@@ -330,9 +331,9 @@ Stack<CommandInstance> callStack
                 return;
             }
 
-            if (command.AllInInstance)
+            if (command.AllInInstance && InstanceProcessor.TryGetInstanceController(player.MapInstanceId, out var instanceController))
             {
-                foreach (var instanceMember in Globals.OnlineList.ToArray())
+                foreach (var instanceMember in instanceController.Players.ToArray())
                 {
                     if (instanceMember.Id == player.Id || !instanceMember.Online)
                     {

Intersect.Server.Core/Entities/Player.cs

@@ -11,6 +11,7 @@
 using Intersect.Logging;
 using Intersect.Network;
 using Intersect.Network.Packets.Server;
+using Intersect.Server.Core.MapInstancing;
 using Intersect.Server.Database;
 using Intersect.Server.Database.Logging.Entities;
 using Intersect.Server.Database.PlayerData;
@@ -389,6 +390,14 @@ public override void Dispose()
             base.Dispose();
         }
 
+        private void RemoveFromInstanceController(Guid mapInstanceId)
+        {
+            if (InstanceProcessor.TryGetInstanceController(mapInstanceId, out var instanceController))
+            {
+                instanceController.RemovePlayer(Id);
+            }
+        }
+
         public void TryLogout(bool force = false, bool softLogout = false)
         {
             LastOnline = DateTime.Now;
@@ -418,6 +427,8 @@ private void Logout(bool softLogout = false)
                 instance.RemoveEntity(this);
             }
 
+            RemoveFromInstanceController(MapInstanceId);
+
             //Update parties
             LeaveParty();
 
@@ -750,7 +761,7 @@ public override void Update(long timeMs)
                         {
                             if (!surrMap.TryGetInstance(MapInstanceId, out mapInstance))
                             {
-                                surrMap.TryCreateInstance(MapInstanceId, out mapInstance);
+                                surrMap.TryCreateInstance(MapInstanceId, out mapInstance, this);
                             }
                         }
 
@@ -1791,12 +1802,21 @@ public override void Warp(Guid newMapId,
                 if (!newMap.TryGetInstance(MapInstanceId, out newMapInstance))
                 {
                     // Create a new instance for the map we're on
-                    newMap.TryCreateInstance(MapInstanceId, out newMapInstance);
+                    newMap.TryCreateInstance(MapInstanceId, out newMapInstance, this);
+                    // ...and its surroundings
                     foreach (var surrMap in newSurroundingMaps)
                     {
-                        MapController.Get(surrMap).TryCreateInstance(MapInstanceId, out var surrMapInstance);
+                        if (!MapController.TryGet(surrMap, out var map))
+                        {
+                            continue;
+                        }
+                        map.TryCreateInstance(MapInstanceId, out _, this);
                     }
                 }
+                else
+                {
+                    _ = TryAddToInstanceController();
+                }
             }
 
             // An instance of the map MUST exist. Otherwise, head to spawn.
@@ -2108,6 +2128,7 @@ private void SendToNewMapInstance(MapController newMap)
             {
                 PacketSender.SendMapInstanceChangedPacket(this, oldMap, PreviousMapInstanceId);
                 oldMapInstance.ClearEntityTargetsOf(this); // Remove targets of this entity
+                RemoveFromInstanceController(PreviousMapInstanceId);
             }
             // Clear events - we'll get them again from the map instance's event cache
             EventTileLookup.Clear();
@@ -7172,6 +7193,17 @@ public bool TryChangeName(string newName)
 
         }
 
+        public bool TryAddToInstanceController()
+        {
+            if (InstanceProcessor.TryGetInstanceController(MapInstanceId, out var instanceController))
+            {
+                instanceController.AddPlayer(this);
+                return true;
+            }
+
+            return false;
+        }
+
         //TODO: Clean all of this stuff up
 
         #region Temporary Values

Intersect.Server.Core/Maps/MapController.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations.Schema;
@@ -152,13 +152,12 @@ public static bool TryGet(Guid id, out MapController mapController)
         /// <param name="mapControllerId">The id of the <see cref="MapController"/></param>
         /// <param name="instanceId">The instance ID we want - crucially, NOT the unique ID of the <see cref="MapInstance"/>. Matches with some entity's InstanceId</param>
         /// <param name="mapInstance">Out value for the successfully found <see cref="MapInstance"/></param>
-        /// <param name="createIfNew">(Default: false) Whether or not to create an instance of a controller if we can't find an instance with the requested ID</param>
         /// <returns>True if successful in retrieving a <see cref="MapInstance"/>, false otherwise</returns>
-        public static bool TryGetInstanceFromMap(Guid mapControllerId, Guid instanceId, out MapInstance mapInstance, bool createIfNew = false)
+        public static bool TryGetInstanceFromMap(Guid mapControllerId, Guid instanceId, out MapInstance mapInstance)
         {
             mapInstance = null;
             var controller = Get(mapControllerId);
-            if (controller != null && controller.TryGetInstance(instanceId, out mapInstance, createIfNew))
+            if (controller != null && controller.TryGetInstance(instanceId, out mapInstance))
             {
                 return mapInstance != null;
             }
@@ -415,17 +414,18 @@ public void RespawnAllInstances()
         /// </summary>
         /// <param name="instanceId"></param>
         /// <returns>Whether or not we needed to create a new map instance</returns>
-        public bool TryCreateInstance(Guid instanceId, out MapInstance newLayer)
+        public bool TryCreateInstance(Guid instanceId, out MapInstance newLayer, Player creator)
         {
             newLayer = null;
             lock (GetMapLock())
             {
                 if (!mInstances.ContainsKey(instanceId))
                 {
                     Log.Debug($"Creating new instance with ID {instanceId} for map {Name}");
-                    mInstances[instanceId] = new MapInstance(this, instanceId);
-                    mInstances[instanceId].Initialize();
-                    newLayer = mInstances[instanceId];
+                    newLayer = new MapInstance(this, instanceId, creator);
+                    newLayer.Initialize();
+                    mInstances[instanceId] = newLayer;
+
                     return true;
                 }
 
@@ -438,26 +438,10 @@ public bool TryCreateInstance(Guid instanceId, out MapInstance newLayer)
         /// </summary>
         /// <param name="mapInstanceId">The id of the instance - NOT the unique id of a <see cref="MapInstance"/></param>
         /// <param name="instance">Out value - the mapInstance we find. Null if not found</param>
-        /// <param name="createIfNew">Whether or not to create an instance if we can't find one</param>
         /// <returns>True if successful in finding the requested instance, false otherwise</returns>
-        public bool TryGetInstance(Guid mapInstanceId, out MapInstance instance, bool createIfNew = false)
+        public bool TryGetInstance(Guid mapInstanceId, out MapInstance instance)
         {
-            instance = null;
-            if (mInstances.TryGetValue(mapInstanceId, out instance))
-            {
-                return true;
-            }
-            else
-            {
-                if (createIfNew)
-                {
-                    if (TryCreateInstance(mapInstanceId, out instance))
-                    {
-                        return true;
-                    }
-                }
-            }
-            return false;
+            return mInstances.TryGetValue(mapInstanceId, out instance) ? instance != default : false;
         }
 
         /// <summary>

Intersect.Server.Core/Maps/MapInstance.cs

@@ -15,6 +15,7 @@
 using Intersect.Server.Entities;
 using Intersect.Server.Classes.Maps;
 using MapAttribute = Intersect.Enums.MapAttribute;
+using Intersect.Server.Core.MapInstancing;
 
 namespace Intersect.Server.Maps
 {
@@ -144,11 +145,12 @@ public partial class MapInstance : IDisposable
         private MapActionMessages mActionMessages = new MapActionMessages();
         private MapAnimations mMapAnimations = new MapAnimations();
 
-        public MapInstance(MapController map, Guid mapInstanceId)
+        public MapInstance(MapController map, Guid mapInstanceId, Player creator)
         {
             mMapController = map;
             MapInstanceId = mapInstanceId;
             Id = Guid.NewGuid();
+            _ = InstanceProcessor.TryAddInstanceController(MapInstanceId, creator);
         }
 
         public bool IsDisposed { get; protected set; }