fix: Changes Map.Sector.Mobiles to link list & Fixes various related crash bugs (#1553)

### Summary

Eliminates `IPooledEnumerable<T>` and `eable.Free()` from `Map` for mobiles. This drastically simplifies code that iterates in range, for example:

```cs
foreach (var m in m.GetMobilesInRange(5))
{
}
```
The code above no longer requires an eable and calling `Free()`.

- [X] Fixed several locations where an NPC that was damaged would cause a server crash.
- [X] Removed an unnecessary allocation in guard fake calls (NPCs calling guards on you)
- [X] Fixes damage precision loss in Poison Strike Spell
- [X] BogThing no longer attempts to "search" for boglings to eat when it is at full health

Projects/Server/Items/Item.cs

@@ -2488,21 +2488,24 @@ public class Item : IHued, IComparable<Item>, ISpawnable, IObjectPropertyListEnt
     public Map.ItemBoundsEnumerable<T> GetItemsInRange<T>(int range) where T : Item =>
         m_Map == null ? Map.ItemBoundsEnumerable<T>.Empty : m_Map.GetItemsInRange<T>(m_Parent == null ? m_Location : GetWorldLocation(), range);
 
-    public IPooledEnumerable<Mobile> GetMobilesInRange(int range)
-    {
-        var map = m_Map;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Map.MobileAtEnumerable<Mobile> GetMobilesAt() => GetMobilesAt<Mobile>();
 
-        return map?.GetMobilesInRange(m_Parent == null ? m_Location : GetWorldLocation(), range)
-               ?? PooledEnumeration.NullEnumerable<Mobile>.Instance;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Map.MobileAtEnumerable<T> GetMobilesAt<T>() where T : Mobile =>
+        m_Map == null ? Map.MobileAtEnumerable<T>.Empty : m_Map.GetMobilesAt<T>(m_Parent == null ? m_Location : GetWorldLocation());
 
-    public IPooledEnumerable<NetState> GetClientsInRange(int range)
-    {
-        var map = m_Map;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Map.MobileBoundsEnumerable<Mobile> GetMobilesInRange(int range) => GetMobilesInRange<Mobile>(range);
 
-        return map.GetClientsInRange(m_Parent == null ? m_Location : GetWorldLocation(), range)
-               ?? PooledEnumeration.NullEnumerable<NetState>.Instance;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Map.MobileBoundsEnumerable<T> GetMobilesInRange<T>(int range) where T : Mobile =>
+        m_Map == null ? Map.MobileBoundsEnumerable<T>.Empty : m_Map.GetMobilesInRange<T>(m_Parent == null ? m_Location : GetWorldLocation(), range);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public IPooledEnumerable<NetState> GetClientsInRange(int range) =>
+        m_Map.GetClientsInRange(m_Parent == null ? m_Location : GetWorldLocation(), range)
+        ?? PooledEnumeration.NullEnumerable<NetState>.Instance;
 
     public bool GetTempFlag(int flag) => ((LookupCompactInfo()?.m_TempFlags ?? 0) & flag) != 0;
 

Projects/Server/Maps/Map.MobileEnumerator.cs

@@ -0,0 +1,288 @@
+/*************************************************************************
+ * ModernUO                                                              *
+ * Copyright 2019-2023 - ModernUO Development Team                       *
+ * Email: hi@modernuo.com                                                *
+ * File: Map.MobileEnumerator.cs                                         *
+ *                                                                       *
+ * This program is free software: you can redistribute it and/or modify  *
+ * it under the terms of the GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3 of the License, or     *
+ * (at your option) any later version.                                   *
+ *                                                                       *
+ * You should have received a copy of the GNU General Public License     *
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>. *
+ *************************************************************************/
+
+using System;
+using System.Runtime.CompilerServices;
+using Server.Collections;
+
+namespace Server;
+
+public partial class Map
+{
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public MobileAtEnumerable<Mobile> GetMobilesAt(Point3D p) => GetMobilesAt<Mobile>(p);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public MobileAtEnumerable<T> GetMobilesAt<T>(Point3D p) where T : Mobile => GetMobilesAt<T>(new Point2D(p.X, p.Y));
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public MobileAtEnumerable<Mobile> GetMobilesAt(int x, int y) => GetMobilesAt<Mobile>(new Point2D(x, y));
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public MobileAtEnumerable<T> GetMobilesAt<T>(int x, int y) where T : Mobile => GetMobilesAt<T>(new Point2D(x, y));
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public MobileAtEnumerable<Mobile> GetMobilesAt(Point2D p) => GetMobilesAt<Mobile>(p);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public MobileAtEnumerable<T> GetMobilesAt<T>(Point2D p) where T : Mobile => new(this, p);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public MobileBoundsEnumerable<Mobile> GetMobilesInRange(Point3D p) => GetMobilesInRange<Mobile>(p);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public MobileBoundsEnumerable<Mobile> GetMobilesInRange(Point3D p, int range) => GetMobilesInRange<Mobile>(p, range);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public MobileBoundsEnumerable<T> GetMobilesInRange<T>(Point3D p) where T : Mobile => GetMobilesInRange<T>(p, Core.GlobalMaxUpdateRange);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public MobileBoundsEnumerable<T> GetMobilesInRange<T>(Point3D p, int range) where T : Mobile =>
+        GetMobilesInRange<T>(p.m_X, p.m_Y, range);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public MobileBoundsEnumerable<Mobile> GetMobilesInRange(Point2D p) => GetMobilesInRange<Mobile>(p);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public MobileBoundsEnumerable<Mobile> GetMobilesInRange(Point2D p, int range) => GetMobilesInRange<Mobile>(p, range);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public MobileBoundsEnumerable<T> GetMobilesInRange<T>(Point2D p) where T : Mobile => GetMobilesInRange<T>(p, Core.GlobalMaxUpdateRange);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public MobileBoundsEnumerable<T> GetMobilesInRange<T>(Point2D p, int range) where T : Mobile =>
+        GetMobilesInRange<T>(p.m_X, p.m_Y, range);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public MobileBoundsEnumerable<T> GetMobilesInRange<T>(int x, int y, int range) where T : Mobile =>
+        GetMobilesInBounds<T>(new Rectangle2D(x - range, y - range, range * 2 + 1, range * 2 + 1));
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public MobileBoundsEnumerable<Mobile> GetMobilesInBounds(Rectangle2D bounds) => GetMobilesInBounds<Mobile>(bounds);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public MobileBoundsEnumerable<T> GetMobilesInBounds<T>(Rectangle2D bounds, bool makeBoundsInclusive = false) where T : Mobile =>
+        new(this, bounds, makeBoundsInclusive);
+
+    public ref struct MobileAtEnumerable<T> where T : Mobile
+    {
+        public static MobileAtEnumerable<T> Empty
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => new();
+        }
+
+        private Map _map;
+        private Point2D _location;
+
+        public MobileAtEnumerable(Map map, Point2D loc)
+        {
+            _map = map;
+            _location = loc;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public MobileAtEnumerator<T> GetEnumerator() => new(_map, _location);
+    }
+
+    public ref struct MobileAtEnumerator<T> where T : Mobile
+    {
+        private bool _started;
+        private Point2D _location;
+        private ref readonly ValueLinkList<Mobile> _linkList;
+        private int _version;
+        private T _current;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public MobileAtEnumerator(Map map, Point2D loc)
+        {
+            _started = false;
+            _location = loc;
+            _linkList = ref map.GetRealSector(loc.m_X, loc.m_Y).Mobiles;
+            _version = 0;
+            _current = null;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool MoveNext()
+        {
+            ref var loc = ref _location;
+            Mobile current;
+
+            if (!_started)
+            {
+                current = _linkList._first;
+                _started = true;
+                _version = _linkList.Version;
+
+                if (current is T { Deleted: false } o && o.X == loc.m_X && o.Y == loc.m_Y)
+                {
+                    _current = o;
+                    return true;
+                }
+            }
+            else if (_linkList.Version != _version)
+            {
+                throw new InvalidOperationException(CollectionThrowStrings.InvalidOperation_EnumFailedVersion);
+            }
+            else
+            {
+                current = _current;
+            }
+
+            while (current != null)
+            {
+                current = current.Next;
+
+                if (current is T { Deleted: false } o && o.X == loc.m_X && o.Y == loc.m_Y)
+                {
+                    _current = o;
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public T Current
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => _current;
+        }
+    }
+
+    public ref struct MobileBoundsEnumerable<T> where T : Mobile
+    {
+        public static MobileBoundsEnumerable<T> Empty
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => new(null, Rectangle2D.Empty, false);
+        }
+
+        private Map _map;
+        private Rectangle2D _bounds;
+        private bool _makeBoundsInclusive;
+
+        public MobileBoundsEnumerable(Map map, Rectangle2D bounds, bool makeBoundsInclusive)
+        {
+            _map = map;
+            _bounds = bounds;
+            _makeBoundsInclusive = makeBoundsInclusive;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public MobileEnumerator<T> GetEnumerator() => new(_map, _bounds, _makeBoundsInclusive);
+    }
+
+    public ref struct MobileEnumerator<T> where T : Mobile
+    {
+        private Map _map;
+        private int _sectorStartX;
+        private int _sectorEndX;
+        private int _sectorEndY;
+        private Rectangle2D _bounds;
+
+        private int _currentSectorX;
+        private int _currentSectorY;
+
+        private ref readonly ValueLinkList<Mobile> _linkList;
+        private int _currentVersion;
+        private T _current;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public MobileEnumerator(Map map, Rectangle2D bounds, bool makeBoundsInclusive)
+        {
+            _map = map;
+            _bounds = bounds;
+
+            if (makeBoundsInclusive)
+            {
+                ++bounds.Width;
+                ++bounds.Height;
+            }
+
+            _bounds = bounds;
+
+            map.CalculateSectors(bounds, out _sectorStartX, out var _sectorStartY, out _sectorEndX, out _sectorEndY);
+
+            // We start the X sector one short because it gets incremented immediately in MoveNext()
+            _currentSectorX = _sectorStartX - 1;
+            _currentSectorY = _sectorStartY;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool MoveNext()
+        {
+            var map = _map;
+
+            if (map == null)
+            {
+                return false;
+            }
+
+            Mobile current = _current;
+            ref Rectangle2D bounds = ref _bounds;
+            var currentSectorX = _currentSectorX;
+            var currentSectorY = _currentSectorY;
+            var sectorEndX = _sectorEndX;
+            var sectorEndY = _sectorEndY;
+
+            while (true)
+            {
+                current = current?.Next;
+
+                while (current == null)
+                {
+                    // Move to next sector
+                    if (currentSectorX < sectorEndX)
+                    {
+                        _currentSectorX = ++currentSectorX;
+                    }
+                    else if (currentSectorY < sectorEndY)
+                    {
+                        _currentSectorX = currentSectorX = _sectorStartX;
+                        _currentSectorY = ++currentSectorY;
+                    }
+                    else
+                    {
+                        // Ran out of sectors
+                        return false;
+                    }
+
+                    _linkList = ref map.GetRealSector(currentSectorX, currentSectorY).Mobiles;
+                    _currentVersion = _linkList.Version;
+                    current = _linkList._first;
+                }
+
+                if (_linkList.Version != _currentVersion)
+                {
+                    throw new InvalidOperationException(CollectionThrowStrings.InvalidOperation_EnumFailedVersion);
+                }
+
+                if (current is T { Deleted: false } o && bounds.Contains(o.Location))
+                {
+                    _current = o;
+                    return true;
+                }
+            }
+        }
+
+        public T Current
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => _current;
+        }
+    }
+}

Projects/Server/Maps/Map.cs

@@ -614,8 +614,10 @@ public sealed partial class Map : IComparable<Map>, ISpanFormattable, ISpanParsa
         }
     }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void OnEnter(Mobile m) => OnEnter(m.Location, m);
+    public void OnEnter(Mobile m)
+    {
+        OnEnter(m.Location, m);
+    }
 
     public void OnEnter(Point3D p, Mobile m)
     {
@@ -650,8 +652,10 @@ public sealed partial class Map : IComparable<Map>, ISpanFormattable, ISpanParsa
         }
     }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void OnLeave(Mobile m) => OnLeave(m.Location, m);
+    public void OnLeave(Mobile m)
+    {
+        OnLeave(m.Location, m);
+    }
 
     public void OnLeave(Point3D p, Mobile m)
     {
@@ -877,18 +881,6 @@ public sealed partial class Map : IComparable<Map>, ISpanFormattable, ISpanParsa
     public IPooledEnumerable<NetState> GetClientsInBounds(Rectangle2D bounds) =>
         PooledEnumeration.GetClients(this, bounds);
 
-    public IPooledEnumerable<Mobile> GetMobilesInRange(Point3D p) => GetMobilesInRange(p, Core.GlobalMaxUpdateRange);
-
-    public IPooledEnumerable<Mobile> GetMobilesInRange(Point3D p, int range) => GetMobilesInRange<Mobile>(p, range);
-
-    public IPooledEnumerable<T> GetMobilesInRange<T>(Point3D p, int range) where T : Mobile =>
-        GetMobilesInBounds<T>(new Rectangle2D(p.m_X - range, p.m_Y - range, range * 2 + 1, range * 2 + 1));
-
-    public IPooledEnumerable<Mobile> GetMobilesInBounds(Rectangle2D bounds) => GetMobilesInBounds<Mobile>(bounds);
-
-    public IPooledEnumerable<T> GetMobilesInBounds<T>(Rectangle2D bounds) where T : Mobile =>
-        PooledEnumeration.GetMobiles<T>(this, bounds);
-
     public bool CanFit(
         Point3D p, int height, bool checkBlocksFit = false, bool checkMobiles = true,
         bool requireSurface = true
@@ -981,10 +973,8 @@ public sealed partial class Map : IComparable<Map>, ISpanFormattable, ISpanParsa
 
         if (checkMobiles)
         {
-            for (var i = 0; i < mobs.Count; ++i)
+            foreach (var m in sector.Mobiles)
             {
-                var m = mobs[i];
-
                 if (m.Location.m_X == x && m.Location.m_Y == y && (m.AccessLevel == AccessLevel.Player || !m.Hidden) &&
                     m.Z + 16 > z && z + height > m.Z)
                 {
@@ -1443,7 +1433,7 @@ public sealed partial class Map : IComparable<Map>, ISpanFormattable, ISpanParsa
         private bool m_Active;
         private List<NetState> _clients;
         private ValueLinkList<Item> _items;
-        private List<Mobile> _mobiles;
+        private ValueLinkList<Mobile> _mobiles;
         private List<BaseMulti> _multis;
         private List<Region> _regions;
 
@@ -1459,7 +1449,7 @@ public sealed partial class Map : IComparable<Map>, ISpanFormattable, ISpanParsa
 
         public List<BaseMulti> Multis => _multis ?? m_DefaultMultiList;
 
-        public List<Mobile> Mobiles => _mobiles ?? m_DefaultMobileList;
+        internal ref ValueLinkList<Mobile> Mobiles => ref _mobiles;
 
         internal ref readonly ValueLinkList<Item> Items => ref _items;
 
@@ -1490,7 +1480,7 @@ public sealed partial class Map : IComparable<Map>, ISpanFormattable, ISpanParsa
 
         public void OnEnter(Mobile mob)
         {
-            Utility.Add(ref _mobiles, mob);
+            _mobiles.AddLast(mob);
 
             if (mob.NetState != null)
             {
@@ -1502,7 +1492,7 @@ public sealed partial class Map : IComparable<Map>, ISpanFormattable, ISpanParsa
 
         public void OnLeave(Mobile mob)
         {
-            Utility.Remove(ref _mobiles, mob);
+            _mobiles.Remove(mob);
 
             if (mob.NetState != null)
             {
@@ -1547,7 +1537,7 @@ public sealed partial class Map : IComparable<Map>, ISpanFormattable, ISpanParsa
 
         private void UpdateMobileRegions()
         {
-            if (_mobiles != null)
+            if (_mobiles.Count > 0)
             {
                 using var queue = PooledRefQueue<Mobile>.Create(_mobiles.Count);
                 foreach (var mob in _mobiles)
@@ -1581,12 +1571,9 @@ public sealed partial class Map : IComparable<Map>, ISpanFormattable, ISpanParsa
                     item.OnSectorActivate();
                 }
 
-                if (_mobiles != null)
+                foreach (var mob in _mobiles)
                 {
-                    foreach (var mob in _mobiles)
-                    {
-                        mob.OnSectorActivate();
-                    }
+                    mob.OnSectorActivate();
                 }
 
                 m_Active = true;
@@ -1602,12 +1589,9 @@ public sealed partial class Map : IComparable<Map>, ISpanFormattable, ISpanParsa
                     item.OnSectorDeactivate();
                 }
 
-                if (_mobiles != null)
+                foreach (var mob in _mobiles)
                 {
-                    foreach (var mob in _mobiles)
-                    {
-                        mob.OnSectorDeactivate();
-                    }
+                    mob.OnSectorDeactivate();
                 }
 
                 m_Active = false;

Projects/Server/Maps/PooledEnumeration.cs

@@ -35,7 +35,6 @@ public static class PooledEnumeration
     {
         ClientSelector = SelectClients;
         EntitySelector = SelectEntities;
-        MobileSelector = SelectMobiles<Mobile>;
         MultiSelector = SelectMultis;
         MultiTileSelector = SelectMultiTiles;
     }
@@ -65,13 +64,9 @@ public static class PooledEnumeration
     public static IEnumerable<IEntity> SelectEntities(Map.Sector s, Rectangle2D bounds)
     {
         var entities = new List<IEntity>(s.Mobiles.Count + s.Items.Count);
-        for (int i = s.Mobiles.Count - 1; i >= 0; --i)
+        foreach (var mob in s.Mobiles)
         {
-            Mobile mob = s.Mobiles[i];
-            if (mob is { Deleted: false } && bounds.Contains(mob.Location))
-            {
-                entities.Add(mob);
-            }
+            entities.Add(mob);
         }
 
         foreach (var item in s.Items)
@@ -82,19 +77,6 @@ public static class PooledEnumeration
         return entities;
     }
 
-    public static IEnumerable<T> SelectMobiles<T>(Map.Sector s, Rectangle2D bounds) where T : Mobile
-    {
-        var entities = new List<T>(s.Mobiles.Count);
-        for (int i = s.Mobiles.Count - 1; i >= 0; --i)
-        {
-            if (s.Mobiles[i] is T { Deleted: false } mob && bounds.Contains(mob.Location))
-            {
-                entities.Add(mob);
-            }
-        }
-        return entities;
-    }
-
     public static IEnumerable<BaseMulti> SelectMultis(Map.Sector s, Rectangle2D bounds)
     {
         var entities = new List<BaseMulti>(s.Multis.Count);
@@ -169,12 +151,6 @@ public static class PooledEnumeration
     public static PooledEnumerable<IEntity> GetEntities(Map map, Rectangle2D bounds) =>
         PooledEnumerable<IEntity>.Instantiate(map, bounds, EntitySelector ?? SelectEntities);
 
-    public static PooledEnumerable<Mobile> GetMobiles(Map map, Rectangle2D bounds) =>
-        GetMobiles<Mobile>(map, bounds);
-
-    public static PooledEnumerable<T> GetMobiles<T>(Map map, Rectangle2D bounds) where T : Mobile =>
-        PooledEnumerable<T>.Instantiate(map, bounds, SelectMobiles<T>);
-
     public static PooledEnumerable<BaseMulti> GetMultis(Map map, Rectangle2D bounds) =>
         PooledEnumerable<BaseMulti>.Instantiate(map, bounds, MultiSelector ?? SelectMultis);
 

Projects/Server/Mobiles/Mobile.cs

@@ -4154,10 +4154,8 @@ public partial class Mobile : IHued, IComparable<Mobile>, ISpawnable, IObjectPro
         if (oldSector != newSector)
         {
             using var queue = PooledRefQueue<IEntity>.Create(2048);
-            for (var i = 0; i < oldSector.Mobiles.Count; ++i)
+            foreach (var m in oldSector.Mobiles)
             {
-                var m = oldSector.Mobiles[i];
-
                 if (m != this && m.X == oldX && m.Y == oldY && m.Z + 15 > oldZ && oldZ + 15 > m.Z)
                 {
                     queue.Enqueue(m);
@@ -4189,10 +4187,8 @@ public partial class Mobile : IHued, IComparable<Mobile>, ISpawnable, IObjectPro
                 }
             }
 
-            for (var i = 0; i < newSector.Mobiles.Count; ++i)
+            foreach (var m in newSector.Mobiles)
             {
-                var m = newSector.Mobiles[i];
-
                 if (m.X == x && m.Y == y && m.Z + 15 > newZ && newZ + 15 > m.Z)
                 {
                     queue.Enqueue(m);
@@ -4227,9 +4223,8 @@ public partial class Mobile : IHued, IComparable<Mobile>, ISpawnable, IObjectPro
         else
         {
             using var queue = PooledRefQueue<(IEntity, byte)>.Create(2048);
-            for (var i = 0; i < oldSector.Mobiles.Count; ++i)
+            foreach (var m in oldSector.Mobiles)
             {
-                var m = oldSector.Mobiles[i];
                 byte flag;
                 if (m != this && m.X == oldX && m.Y == oldY && m.Z + 15 > oldZ && oldZ + 15 > m.Z)
                 {
@@ -8126,14 +8121,25 @@ public partial class Mobile : IHued, IComparable<Mobile>, ISpawnable, IObjectPro
     public Map.ItemBoundsEnumerable<T> GetItemsInRange<T>(int range) where T : Item =>
         m_Map == null ? Map.ItemBoundsEnumerable<T>.Empty : m_Map.GetItemsInRange<T>(m_Location, range);
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public IPooledEnumerable<IEntity> GetObjectsInRange(int range) =>
         m_Map?.GetObjectsInRange(m_Location, range) ?? PooledEnumeration.NullEnumerable<IEntity>.Instance;
 
-    public IPooledEnumerable<Mobile> GetMobilesInRange(int range) => GetMobilesInRange<Mobile>(range);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Map.MobileAtEnumerable<Mobile> GetMobilesInRange() => GetMobilesInRange<Mobile>();
 
-    public IPooledEnumerable<T> GetMobilesInRange<T>(int range) where T : Mobile =>
-        m_Map?.GetMobilesInRange<T>(m_Location, range) ?? PooledEnumeration.NullEnumerable<T>.Instance;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Map.MobileAtEnumerable<T> GetMobilesInRange<T>() where T : Mobile =>
+        m_Map == null ? Map.MobileAtEnumerable<T>.Empty : m_Map.GetMobilesAt<T>(m_Location);
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Map.MobileBoundsEnumerable<Mobile> GetMobilesInRange(int range) => GetMobilesInRange<Mobile>(range);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Map.MobileBoundsEnumerable<T> GetMobilesInRange<T>(int range) where T : Mobile =>
+        m_Map == null ? Map.MobileBoundsEnumerable<T>.Empty : m_Map.GetMobilesInRange<T>(m_Location, range);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public IPooledEnumerable<NetState> GetClientsInRange(int range) =>
         m_Map?.GetClientsInRange(m_Location, range) ?? PooledEnumeration.NullEnumerable<NetState>.Instance;