feat(game): map's server_attr + mob ai improvements (#339)

* feat(game): map's server_attr + mob ai improvements

* refactor(game): use Coordinates record for attr checks

Author: andreionoie

src/CorePluginAPI/Coordinates.cs

@@ -1,9 +1,19 @@
-namespace QuantumCore.API;
+using System.Numerics;
+
+namespace QuantumCore.API;
 
 public record struct Coordinates(uint X, uint Y)
 {
     public override string ToString() => $"({X}, {Y})";
 
     public static Coordinates operator *(Coordinates a, uint multiplier) => new(a.X * multiplier, a.Y * multiplier);
     public static Coordinates operator +(Coordinates a, Coordinates b) => new(a.X + b.X, a.Y + b.Y);
+
+    public static Coordinates operator +(Coordinates a, Vector2 delta)
+    {
+        return new Coordinates(checked((uint)(a.X + delta.X)), checked((uint)(a.Y + delta.Y)));
+    }
+    
+    // throw on underflow with checked()
+    public static Coordinates operator -(Coordinates a, Coordinates b) => new(checked(a.X - b.X), checked(a.Y - b.Y));
 }

src/CorePluginAPI/Core/Models/EMapAttribute.cs

@@ -0,0 +1,11 @@
+namespace QuantumCore.API.Core.Models;
+
+[Flags]
+public enum EMapAttribute : uint
+{
+    None = 0,
+    Block = 1 << 0, // collision detection
+    Water = 1 << 1,
+    NonPvp = 1 << 2, // AKA "BAN_PK"
+    Object = 1 << 7, // building
+}

src/Game.Benchmarks/Benchmarks/WorldUpdateBenchmark.cs

@@ -58,6 +58,7 @@ public void GlobalSetup()
                             provider.GetRequiredService<ICacheManager>(), callInfo.Arg<IWorld>(),
                             provider.GetRequiredService<ILogger<Map>>(),
                             provider.GetRequiredService<ISpawnPointProvider>(),
+                            provider.GetRequiredService<IMapAttributeProvider>(),
                             provider.GetRequiredService<IDropProvider>(),
                             provider.GetRequiredService<IItemManager>(),
                             provider.GetRequiredService<IServerBase>(),

src/Libraries/Game.Server/Extensions/MapAttributeExtensions.cs

@@ -0,0 +1,50 @@
+using System.Numerics;
+using QuantumCore.API;
+using QuantumCore.API.Core.Models;
+using QuantumCore.API.Game.World;
+using QuantumCore.Game.World;
+
+namespace QuantumCore.Game.Extensions;
+
+internal static class MapAttributeExtensions
+{
+    public static bool PositionIsAttr(this IEntity entity, EMapAttribute flags)
+    {
+        return entity.Map is Map localMap && localMap.IsAttr(entity.Coordinates(), flags);
+    }
+    
+    // TODO: optimize / improve this function for better AI following around obstacles
+    public static bool IsAttrOnStraightPathTo(this IEntity entity, Coordinates endCoords, EMapAttribute flags)
+    {
+        if (entity.Map is not Map localMap)
+            return false;
+
+        // cast to int since delta might be negative
+        var dx = (int)endCoords.X - (int)entity.Coordinates().X;
+        var dy = (int)endCoords.Y - (int)entity.Coordinates().Y;
+        if (dx == 0 && dy == 0)
+        {
+            return entity.PositionIsAttr(flags);
+        }
+
+        const int Samples = 100;
+        for (var i = 1; i <= Samples; i++)
+        {
+            var t = (float)i / Samples;
+            var sampleDelta = new Vector2(dx * t, dy * t);
+
+            if (localMap.IsAttr(entity.Coordinates() + sampleDelta, flags))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+    
+    public static Coordinates Coordinates(this IEntity entity)
+    {
+        // TODO: entity position should be directly refactored as Coordinate instead?
+        return new Coordinates((uint)entity.PositionX, (uint)entity.PositionY);
+    }
+}

src/Libraries/Game.Server/Extensions/ServiceExtensions.cs

@@ -45,6 +45,7 @@ public static IServiceCollection AddGameServices(this IServiceCollection service
         services.AddSingleton<IParserService, ParserService>();
         services.AddSingleton<ISpawnGroupProvider, SpawnGroupProvider>();
         services.AddSingleton<ISpawnPointProvider, SpawnPointProvider>();
+        services.AddSingleton<IMapAttributeProvider, MapAttributeProvider>();
         services.AddSingleton<IJobManager, JobManager>();
         services.AddSingleton<IStructuredFileProvider, StructuredFileProvider>();
         services.AddScoped<IAtlasProvider, AtlasProvider>();

src/Libraries/Game.Server/Services/AtlasProvider.cs

@@ -31,6 +31,7 @@ private record AtlasValue(string MapName, Coordinates Position, uint Width, uint
     private readonly IFileProvider _fileProvider;
     private readonly IServerBase _server;
     private readonly IServiceProvider _serviceProvider;
+    private readonly IMapAttributeProvider _attributeProvider;
 
     /// <summary>
     /// Regex for parsing lines in the atlas info
@@ -42,7 +43,8 @@ private record AtlasValue(string MapName, Coordinates Position, uint Width, uint
     public AtlasProvider(IConfiguration configuration, IMonsterManager monsterManager,
         IAnimationManager animationManager, ISpawnPointProvider spawnPointProvider,
         ICacheManager cacheManager, ILogger<AtlasProvider> logger, IItemManager itemManager,
-        IFileProvider fileProvider, IServerBase server, IServiceProvider serviceProvider)
+        IFileProvider fileProvider, IServerBase server, IServiceProvider serviceProvider,
+        IMapAttributeProvider attributeProvider)
     {
         _configuration = configuration;
         _monsterManager = monsterManager;
@@ -54,6 +56,7 @@ public AtlasProvider(IConfiguration configuration, IMonsterManager monsterManage
         _fileProvider = fileProvider;
         _server = server;
         _serviceProvider = serviceProvider;
+        _attributeProvider = attributeProvider;
     }
 
     public async Task<IEnumerable<IMap>> GetAsync(IWorld world)
@@ -121,8 +124,8 @@ public async Task<IEnumerable<IMap>> GetAsync(IWorld world)
             {
                 townCoordsDict.TryGetValue(mapName, out var coords);
 
-                map = new Map(_monsterManager, _animationManager, _cacheManager, world, _logger,
-                    _spawnPointProvider, _serviceProvider.GetRequiredService<IDropProvider>(), _itemManager, _server,
+                map = new Map(_monsterManager, _animationManager, _cacheManager, world, _logger, _spawnPointProvider,
+                    _attributeProvider, _serviceProvider.GetRequiredService<IDropProvider>(), _itemManager, _server,
                     mapName, position,
                     width,
                     height, coords, _serviceProvider);

src/Libraries/Game.Server/Services/IMapAttributeProvider.cs

@@ -0,0 +1,15 @@
+using QuantumCore.API;
+using QuantumCore.API.Core.Models;
+
+namespace QuantumCore.Game.Services;
+
+public interface IMapAttributeProvider
+{
+    Task<IMapAttributeSet?> GetAttributesAsync(string mapName, Coordinates position, uint mapWidth, uint mapHeight,
+        CancellationToken cancellationToken = default);
+}
+
+public interface IMapAttributeSet
+{
+    EMapAttribute GetAttribute(Coordinates coords);
+}

src/Libraries/Game.Server/Services/MapAttributeProvider.cs

@@ -0,0 +1,213 @@
+using System.Buffers.Binary;
+using System.Numerics;
+using EnumsNET;
+using Microsoft.Extensions.FileProviders;
+using Microsoft.Extensions.Logging;
+using QuantumCore.API;
+using QuantumCore.API.Core.Models;
+using QuantumCore.Core.Types;
+using QuantumCore.Game.World;
+
+namespace QuantumCore.Game.Services;
+
+internal sealed class MapAttributeProvider : IMapAttributeProvider
+{
+    private readonly IFileProvider _fileProvider;
+    private readonly ILogger<MapAttributeProvider> _logger;
+
+    public MapAttributeProvider(IFileProvider fileProvider, ILogger<MapAttributeProvider> logger)
+    {
+        _fileProvider = fileProvider;
+        _logger = logger;
+    }
+
+    public async Task<IMapAttributeSet?> GetAttributesAsync(string mapName, Coordinates position, uint mapWidth,
+        uint mapHeight, CancellationToken cancellationToken = default)
+    {
+        var attrPath = $"maps/{mapName}/server_attr";
+        var file = _fileProvider.GetFileInfo(attrPath);
+        if (!file.Exists)
+        {
+            _logger.LogDebug("No server_attr file found for map {Map}", mapName);
+            return null;
+        }
+
+        _logger.LogDebug("Loading cell attributes from file {ServerAttrPath}", attrPath);
+
+        await using var stream = file.CreateReadStream();
+
+        // header contains length and width in sectree units (which are squares of 128x128 attr cells)
+        var headerBuffer = new byte[2 * sizeof(int)];
+        await stream.ReadExactlyAsync(headerBuffer, cancellationToken);
+        var sectreesWidth = BinaryPrimitives.ReadInt32LittleEndian(headerBuffer.AsSpan(0 * sizeof(int), sizeof(int)));
+        var sectreesHeight = BinaryPrimitives.ReadInt32LittleEndian(headerBuffer.AsSpan(1 * sizeof(int), sizeof(int)));
+
+        var expectedSectreesWidth = (int)(mapWidth * Map.MapUnit / MapAttributeSet.SectreeSize);
+        var expectedSectreesHeight = (int)(mapHeight * Map.MapUnit / MapAttributeSet.SectreeSize);
+        if (sectreesWidth != expectedSectreesWidth || sectreesHeight != expectedSectreesHeight)
+        {
+            _logger.LogWarning(
+                "{ServerAttrPath} dimensions ({SectreeWidth}x{SectreeHeight}) do not match atlasinfo.txt dimensions ({ExpectedWidth}x{ExpectedHeight})",
+                attrPath, sectreesWidth, sectreesHeight, expectedSectreesWidth, expectedSectreesHeight);
+        }
+
+        var sectrees = new MapAttributeSectree?[sectreesHeight, sectreesWidth];
+        var lzoDecompressor = new Lzo(MapAttributeSet.CellsPerSectree * sizeof(uint));
+        var intBuffer = new byte[4];
+
+        // info for debug logging only
+        long cellsWithKnownFlags = 0;
+        var unknownFlagCounts = new Dictionary<int, long>();
+        var flagCountsDebugInfo = Enum.GetValues<EMapAttribute>()
+            .Where(x => x != EMapAttribute.None)
+            .ToDictionary(attr => attr, _ => 0L);
+
+        for (var y = 0; y < sectreesHeight; y++)
+        {
+            for (var x = 0; x < sectreesWidth; x++)
+            {
+                await stream.ReadExactlyAsync(intBuffer, cancellationToken);
+                var blockSize = BinaryPrimitives.ReadInt32LittleEndian(intBuffer);
+                
+                var compressedSectree = new byte[blockSize];
+                await stream.ReadExactlyAsync(compressedSectree, cancellationToken);
+                
+                var decompressedSectree = lzoDecompressor.DecodeRaw(compressedSectree);
+                if (decompressedSectree.Length != MapAttributeSet.CellsPerSectree * sizeof(uint))
+                {
+                    _logger.LogWarning("{ServerAttrPath} failed to decode sectree ({X}, {Y}): unexpected size {DecompressedSectorLength}", attrPath, x, y, decompressedSectree.Length);
+                    sectrees[y, x] = MapAttributeSectree.Empty;
+                    continue;
+                }
+
+                var allCellsAttrs = new EMapAttribute[MapAttributeSet.CellsPerSectree];
+                for (var i = 0; i < allCellsAttrs.Length; i++)
+                {
+                    var rawCellFlags = BinaryPrimitives.ReadUInt32LittleEndian(
+                        decompressedSectree.AsSpan(i * sizeof(uint), sizeof(uint))
+                    );
+                    // all set bits of `rawCellFlags` are preserved when cast to enum - individual flags can be extracted with HasFlag()
+                    var cellAttrFlags = (EMapAttribute)rawCellFlags;
+                    allCellsAttrs[i] = cellAttrFlags;
+
+                    // saving debug info if server_attr is corrupted or wrong format
+                    if (_logger.IsEnabled(LogLevel.Debug)) {
+                        var cellHasValidFlag = false;
+                        foreach (var flag in flagCountsDebugInfo.Keys.ToList())
+                        {
+                            if (cellAttrFlags.HasFlag(flag))
+                            {
+                                flagCountsDebugInfo[flag]++;
+                                cellHasValidFlag = true;
+                            }
+                        }
+
+                        if (cellHasValidFlag) cellsWithKnownFlags++;
+
+                        var unknownFlags = cellAttrFlags &
+                                           ~flagCountsDebugInfo.Keys.Aggregate(EMapAttribute.None,
+                                               (acc, attr) => acc | attr);
+                        if (unknownFlags != EMapAttribute.None)
+                        {
+                            var remaining = (uint)unknownFlags;
+                            while (remaining != 0)
+                            {
+                                var lsb = remaining & ~(remaining - 1);
+                                var bitPosition = BitOperations.TrailingZeroCount(lsb);
+                                unknownFlagCounts.TryGetValue(bitPosition, out var count);
+                                unknownFlagCounts[bitPosition] = count + 1;
+                                remaining &= remaining - 1;
+                            }
+                        }
+                    }
+                }
+
+                sectrees[y, x] = new MapAttributeSectree(allCellsAttrs);
+            }
+        }
+
+        if (_logger.IsEnabled(LogLevel.Debug))
+        {
+            var totalCells = (long)sectreesHeight * sectreesWidth * MapAttributeSet.CellsPerSectree;
+            var percentage = 100.0 * cellsWithKnownFlags / totalCells;
+            _logger.LogDebug( "Loaded {ServerAttrPath} {CellSize}x{CellSize2} cell attributes: {Summary} (cells with known flags: {NonZero}/{Total} = {Percentage:F2}%)",
+                attrPath, MapAttributeSet.CellSize, MapAttributeSet.CellSize,
+                string.Join(" ", flagCountsDebugInfo.Select(kv => $"{kv.Key}={kv.Value}")),
+                cellsWithKnownFlags, totalCells, percentage);
+
+            if (unknownFlagCounts.Count > 0)
+            {
+                _logger.LogWarning("{ServerAttrPath} contains cells with unknown flag bits (LSB being bit 0): {UnknownSummary}",
+                    attrPath, string.Join(", ", unknownFlagCounts.Select(kv => $"bit {kv.Key} found in {kv.Value} cells")));
+            }
+        }
+
+        return new MapAttributeSet(sectreesWidth, sectreesHeight, position, sectrees);
+    }
+
+    private sealed class MapAttributeSet : IMapAttributeSet
+    {
+        internal const int SectreeSize = 6400; // 64m x 64m
+        internal const int CellSize = 50; // 50cm x 50cm  - basically a quarter of the size of a full world cell (2m x 2m)
+        internal const int CellsPerAxis = SectreeSize / CellSize;
+        internal const int CellsPerSectree = CellsPerAxis * CellsPerAxis;
+
+        private readonly MapAttributeSectree?[,] _sectreesAttrs;
+        private readonly int _sectreesWidth;
+        private readonly int _sectreesHeight;
+        private readonly Coordinates _baseCoords;
+
+        public MapAttributeSet(int sectreesWidth, int sectreesHeight, Coordinates basePosition,
+            MapAttributeSectree?[,] sectreesAttrs)
+        {
+            _sectreesWidth = sectreesWidth;
+            _sectreesHeight = sectreesHeight;
+            _baseCoords = basePosition;
+            _sectreesAttrs = sectreesAttrs;
+        }
+
+        public EMapAttribute GetAttribute(Coordinates coords)
+        {
+            if (!TryLocate(coords, out var locatedSectreeAttrs, out var cellX, out var cellY) || locatedSectreeAttrs is null)
+            {
+                return EMapAttribute.None;
+            }
+
+            return locatedSectreeAttrs.Get(cellX, cellY);
+        }
+
+        private bool TryLocate(Coordinates coords, out MapAttributeSectree? sectreeAttrs, out int cellX, out int cellY)
+        {
+            sectreeAttrs = null;
+            cellX = 0;
+            cellY = 0;
+
+            var relativeCoords = coords - _baseCoords;
+
+            // find which sectree covers the x y relative map coords
+            var sectreeIndexX = relativeCoords.X / SectreeSize;
+            var sectreeIndexY = relativeCoords.Y / SectreeSize;
+            if (sectreeIndexX >= _sectreesWidth || sectreeIndexY >= _sectreesHeight)
+            {
+                return false;
+            }
+            sectreeAttrs = _sectreesAttrs[sectreeIndexY, sectreeIndexX];
+            
+            // find which cell of the sectree covers the x y relative map coords
+            cellX = (int)((relativeCoords.X % SectreeSize) / CellSize);
+            cellY = (int)((relativeCoords.Y % SectreeSize) / CellSize);
+            
+            return cellX < CellsPerAxis && cellY < CellsPerAxis;
+        }
+    }
+
+    private sealed class MapAttributeSectree(EMapAttribute[] values)
+    {
+        public static MapAttributeSectree Empty { get; } = new(new EMapAttribute[MapAttributeSet.CellsPerSectree]);
+
+        public EMapAttribute Get(int x, int y)
+        {
+            return values[y * MapAttributeSet.CellsPerAxis + x];
+        }
+    }
+}

src/Libraries/Game.Server/Types/Lzo.cs

@@ -27,6 +27,14 @@ public byte[] Decode(byte[] data)
             return buffer;
         }
 
+        public byte[] DecodeRaw(byte[] data)
+        {
+            using var src = new MemoryStream(data);
+            var buffer = new byte[_size];
+            Decompress(src, buffer);
+            return buffer;
+        }
+
         private int ConsumeZeroByteLength(MemoryStream src)
         {
             var pos = src.Position;
@@ -254,4 +262,4 @@ private void Decompress(MemoryStream src, byte[] dest)
             }
         }
     }
-}
+}