Merge pull request #976 from FFXIV-CombatReborn/mergeWIP

perf improvements

Author: CarnifexOptimus

BossMod/BossModule/AIHints.cs

@@ -51,7 +51,7 @@ public readonly struct DamagePrediction(BitMask players, DateTime activation, Pr
         public readonly PredictedDamageType Type = type;
     }
 
-    public static readonly ArenaBounds DefaultBounds = new ArenaBoundsSquare(30f, AllowObstacleMap: true);
+    public static readonly ArenaBounds DefaultBounds = new ArenaBoundsSquare(30f, allowObstacleMap: true);
 
     // information needed to build base pathfinding map (onto which forbidden/goal zones are later rasterized), if needed (lazy, since it's somewhat expensive and not always needed)
     public WPos PathfindMapCenter;

BossMod/BossModule/AIHintsBuilder.cs

@@ -166,7 +166,7 @@ private void CalculateAutoHints(AIHints hints, Actor player)
             originZ = Math.Max(originZ, e.ViewHeight);
             // TODO: consider quantizing even more, to reduce jittering when player moves?..
             hints.PathfindMapCenter = e.Origin + resolution * new WDir(originX, originZ);
-            hints.PathfindMapBounds = new ArenaBoundsRect(e.ViewWidth * resolution, e.ViewHeight * resolution, MapResolution: resolution); // note: we don't bother caching these bounds, they are very lightweight
+            hints.PathfindMapBounds = new ArenaBoundsRect(e.ViewWidth * resolution, e.ViewHeight * resolution, mapResolution: resolution); // note: we don't bother caching these bounds, they are very lightweight
             hints.PathfindMapObstacles = new(bitmap, new(originX - e.ViewWidth, originZ - e.ViewHeight, originX + e.ViewWidth, originZ + e.ViewHeight));
         }
         else

BossMod/BossModule/ArenaBounds.cs

@@ -2,8 +2,13 @@
 // radius is the largest horizontal/vertical dimension: radius for circle, max of width/height for rect
 // note: this class to represent *relative* arena bounds (relative to arena center) - the reason being that in some cases effective center moves every frame, and bounds caches a lot (clip poly & base map for pathfinding)
 // note: if arena bounds are changed, new instance is recreated; max approx error can change without recreating the instance
-public abstract record class ArenaBounds(float Radius, float MapResolution, float ScaleFactor = 1f, bool AllowObstacleMap = false)
+public abstract class ArenaBounds(float radius, float mapResolution, float scaleFactor = 1f, bool allowObstacleMap = false)
 {
+    public readonly float Radius = radius;
+    public readonly float MapResolution = mapResolution;
+    public readonly float ScaleFactor = scaleFactor;
+    public readonly bool AllowObstacleMap = allowObstacleMap;
+
     // fields below are used for clipping & drawing borders
     public readonly PolygonClipper Clipper = new();
     public float MaxApproxError;
@@ -142,7 +147,7 @@ public void AddToInstanceCache(object key, object value)
     }
 }
 
-public sealed record class ArenaBoundsCircle(float Radius, float MapResolution = 0.5f, bool AllowObstacleMap = false) : ArenaBounds(Radius, MapResolution, AllowObstacleMap: AllowObstacleMap)
+public sealed class ArenaBoundsCircle(float Radius, float MapResolution = 0.5f, bool AllowObstacleMap = false) : ArenaBounds(Radius, MapResolution, allowObstacleMap: AllowObstacleMap)
 {
     private Pathfinding.Map? _cachedMap;
 
@@ -159,7 +164,9 @@ public override WDir ClampToBounds(WDir offset)
     {
         var radius = Radius;
         if (offset.LengthSq() > radius * radius)
+        {
             offset *= radius / offset.Length();
+        }
         return offset;
     }
 
@@ -187,20 +194,32 @@ private Pathfinding.Map BuildMap()
                 var cx = Math.Abs(dx2) + 0.5f;
                 if (cx * cx + cySq > threshold)
                 {
-                    map.PixelMaxG[iCell] = -1f;
+                    map.PixelMaxG[iCell] = -1000f;
                 }
                 ++iCell;
             }
         }
         return map;
     }
+
+    public override string ToString() => $"{nameof(ArenaBoundsCircle)}, Radius {Radius}, MapResolution: {MapResolution}";
 }
 
 // if rotation is 0, half-width is along X and half-height is along Z
-public record class ArenaBoundsRect(float HalfWidth, float HalfHeight, Angle Rotation = default, float MapResolution = 0.5f, bool AllowObstacleMap = false) : ArenaBounds(Math.Max(HalfWidth, HalfHeight), MapResolution, Rotation != default ? CalculateScaleFactor(Rotation) : 1f, AllowObstacleMap)
+public abstract class ABRect : ArenaBounds
 {
+    public ABRect(float halfWidth, float halfHeight, Angle rotation = default, float MapResolution = 0.5f, bool AllowObstacleMap = false) : base(Math.Max(halfWidth, halfHeight), MapResolution, rotation != default ? CalculateScaleFactor(rotation) : 1f, AllowObstacleMap)
+    {
+        HalfWidth = halfWidth;
+        HalfHeight = halfHeight;
+        Rotation = rotation;
+        Orientation = Rotation.ToDirection();
+    }
+    public readonly float HalfWidth;
+    public readonly float HalfHeight;
+    public readonly Angle Rotation;
     private Pathfinding.Map? _cachedMap;
-    public readonly WDir Orientation = Rotation.ToDirection();
+    public readonly WDir Orientation;
 
     private static float CalculateScaleFactor(Angle Rotation)
     {
@@ -210,13 +229,49 @@ private static float CalculateScaleFactor(Angle Rotation)
 
     protected override PolygonClipper.Operand BuildClipPoly() => new(CurveApprox.Rect(Orientation, HalfWidth, HalfHeight));
     public override void PathfindMap(Pathfinding.Map map, WPos center) => map.Init(_cachedMap ??= BuildMap(), center);
+
     private Pathfinding.Map BuildMap()
     {
         var halfWidth = HalfWidth;
         var halfHeight = HalfHeight;
-        var rotation = Rotation;
-        var map = new Pathfinding.Map(MapResolution, default, halfWidth + 0.5f, halfHeight + 0.5f, rotation);
-        map.BlockPixelsInside(new SDInvertedRect(default, rotation, halfHeight, halfHeight, halfWidth), -1f, 0.49999f * MapResolution);
+        var map = new Pathfinding.Map(MapResolution, default, halfWidth + 0.5f, halfHeight + 0.5f, Rotation); // +0.5 offset because otherwise the AI will not run back into the rectangle for some reason
+        // pixels can be partially covered by the rectangle, so we need to rasterize it carefully
+        var width = map.Width;
+        var height = map.Height;
+        var resolution = map.Resolution;
+
+        var dir = Rotation.ToDirection();
+        var dirX = dir.X;
+        var dirZ = dir.Z;
+        var normal = dir.OrthoL();
+        var normalX = normal.X;
+        var normalZ = normal.Z;
+
+        var dx = normal * resolution;
+        var dy = dir * resolution;
+        var startPos = map.Center - ((width >> 1) - 0.5f) * dx - ((height >> 1) - 0.5f) * dy;
+        var halfPixel = 0.5f * resolution;
+
+        for (var y = 0; y < height; ++y)
+        {
+            var posY = startPos + y * dy;
+            var rowBase = y * width;
+            for (var x = 0; x < width; ++x)
+            {
+                var pos = posY + x * dx;
+                var pX = pos.X;
+                var pZ = pos.Z;
+
+                var distParr = pX * dirX + pZ * dirZ;
+                var distOrtho = pX * normalX + pZ * normalZ;
+
+                if (!((distParr - halfPixel) >= -halfHeight && (distParr + halfPixel) <= halfHeight) || !((distOrtho - halfPixel) >= -halfWidth && (distOrtho + halfPixel) <= halfWidth))
+                {
+                    map.PixelMaxG[rowBase + x] = -1000f;
+                }
+            }
+        }
+
         return map;
     }
 
@@ -231,22 +286,33 @@ public override WDir ClampToBounds(WDir offset)
         var offsetX = offset.Dot(orientation.OrthoL());
         var offsetY = offset.Dot(orientation);
         if (Math.Abs(offsetX) > halfWidth)
+        {
             offsetX = Math.Sign(offsetX) * halfWidth;
+        }
         if (Math.Abs(offsetY) > halfHeight)
+        {
             offsetY = Math.Sign(offsetY) * halfHeight;
+        }
         return orientation.OrthoL() * offsetX + orientation * offsetY;
     }
 }
 
-public sealed record class ArenaBoundsSquare(float Radius, Angle Rotation = default, float MapResolution = 0.5f, bool AllowObstacleMap = false) : ArenaBoundsRect(Radius, Radius, Rotation, MapResolution, AllowObstacleMap) { }
+public sealed class ArenaBoundsRect(float halfWidth, float halfHeight, Angle rotation = default, float mapResolution = 0.5f, bool allowObstacleMap = false) : ABRect(halfWidth, halfHeight, rotation, mapResolution, allowObstacleMap)
+{
+    public override string ToString() => $"{nameof(ArenaBoundsRect)}, Radius {Radius}, HalfWidth: {HalfWidth}, HalfHeight: {HalfHeight}, MapResolution: {MapResolution}, ScaleFactor: {ScaleFactor}";
+}
+public sealed class ArenaBoundsSquare(float halfWidth, Angle rotation = default, float mapResolution = 0.5f, bool allowObstacleMap = false) : ABRect(halfWidth, halfWidth, rotation, mapResolution, allowObstacleMap)
+{
+    public override string ToString() => $"{nameof(ArenaBoundsSquare)}, Radius {Radius}, HalfWidth: {HalfWidth}, MapResolution: {MapResolution}, ScaleFactor: {ScaleFactor}";
+}
 
 // custom complex polygon bounds
 // for creating complex bounds by using arrays of shapes
 // first array contains platforms that will be united, second optional array contains shapes that will be subtracted
 // for convenience third array will optionally perform additional unions at the end
 // offset shrinks the pathfinding map only, for example if the edges of the arena are deadly and floating point errors cause the AI to fall of the map or problems like that
 // AdjustForHitbox adjusts both the visible map and the pathfinding map
-public sealed record class ArenaBoundsCustom : ArenaBounds
+public sealed class ArenaBoundsCustom : ArenaBounds
 {
     private Pathfinding.Map? _cachedMap;
     public readonly RelSimplifiedComplexPolygon Polygon;
@@ -265,20 +331,30 @@ public ArenaBoundsCustom(Shape[] UnionShapes, Shape[]? DifferenceShapes = null,
         Polygon = poly;
         offset = Offset;
 
-        var edgeList = new List<(WDir, WDir)>();
         var parts = Polygon.Parts;
         var count = parts.Count;
+        var vertsCount = 0;
+        for (var i = 0; i < count; ++i)
+        {
+            vertsCount += parts[i].VerticesCount;
+        }
+        var edgeArray = new (WDir, WDir)[vertsCount];
+        var k = 0;
         for (var i = 0; i < count; ++i)
         {
             var part = parts[i];
-            edgeList.AddRange(part.ExteriorEdges);
+            var extSpan = part.ExteriorEdges;
+            extSpan.CopyTo(edgeArray.AsSpan(k, extSpan.Length));
+            k += extSpan.Length;
             var len = part.Holes.Length;
             for (var j = 0; j < len; ++j)
             {
-                edgeList.AddRange(part.InteriorEdges(j));
+                var intSpan = part.InteriorEdges(j);
+                intSpan.CopyTo(edgeArray.AsSpan(k, intSpan.Length));
+                k += intSpan.Length;
             }
         }
-        edges = [.. edgeList];
+        edges = edgeArray;
     }
 
     private static float BuildBounds(Shape[] unionShapes, Shape[]? differenceShapes, Shape[]? additionalShapes, float scalefactor, bool adjustForHitbox, out RelSimplifiedComplexPolygon poly, out WPos center, out float halfWidth, out float halfHeight)
@@ -312,13 +388,21 @@ private static (WPos Center, float HalfWidth, float HalfHeight, float Radius, Re
                 var vX = vertex.X;
                 var vZ = vertex.Z;
                 if (vX < minX)
+                {
                     minX = vX;
+                }
                 if (vX > maxX)
+                {
                     maxX = vX;
+                }
                 if (vZ < minZ)
+                {
                     minZ = vZ;
+                }
                 if (vZ > maxZ)
+                {
                     maxZ = vZ;
+                }
             }
         }
 
@@ -415,8 +499,7 @@ private Pathfinding.Map BuildMap()
         var height = map.Height;
         var resolution = map.Resolution;
 
-        map.BlockPixelsInside(new SDInvertedPolygonWithHoles(new(default, Polygon)), -1f, 0.49999f * resolution); // check inner circle of the pixel
-
+        var shape = new SDInvertedPolygonWithHoles(new(default, Polygon));
         // now check the corners
         var halfSample = resolution * 0.49999f; // tiny offset to account for floating point inaccuracies
 
@@ -431,34 +514,38 @@ private Pathfinding.Map BuildMap()
         var dx = new WDir(resolution, default);
         var dy = new WDir(default, resolution);
         var startPos = map.Center - ((width >> 1) - 0.5f) * dx - ((height >> 1) - 0.5f) * dy;
+        var partitioner = Partitioner.Create(0, height);
 
-        Parallel.For(0, height, y =>
+        Parallel.ForEach(partitioner, range =>
         {
-            var rowOffset = y * width;
-            var posY = startPos + y * dy;
-            for (var x = 0; x < width; ++x)
+            var ys = range.Item1;
+            var ye = range.Item2;
+            for (var y = ys; y < ye; ++y)
             {
-                var offset = rowOffset + x;
-
-                if (pixels[offset] == -1f)
+                var rowOffset = y * width;
+                var posY = startPos + y * dy;
+                for (var x = 0; x < width; ++x)
                 {
-                    continue;
-                }
-                var pos = posY + x * dx;
-
-                var relativeCenter = new WDir(pos.X, pos.Z);
+                    var offset = rowOffset + x;
+                    var pos = posY + x * dx;
+                    if (shape.Distance(pos) <= halfSample) // inner circle of the pixel
+                    {
+                        pixels[offset] = -1000f; // no reason to check more points of the cell
+                        continue;
+                    }
+                    var relativeCenter = new WDir(pos.X, pos.Z);
 
-                for (var i = 0; i < 4; ++i)
-                {
-                    if (!polygon.Contains(relativeCenter + sampleOffsets[i]))
+                    for (var i = 0; i < 4; ++i)
                     {
-                        pixels[offset] = -1f;
-                        break;
+                        if (!polygon.Contains(relativeCenter + sampleOffsets[i]))
+                        {
+                            pixels[offset] = -1000f;
+                            break;
+                        }
                     }
                 }
             }
         });
-
         return map;
     }
 
@@ -493,4 +580,6 @@ private static RelSimplifiedComplexPolygon CombinePolygons(RelSimplifiedComplexP
 
         return combinedShape;
     }
+
+    public override string ToString() => $"{nameof(ArenaBoundsCustom)}, Radius {Radius}, HalfWidth: {HalfWidth}, HalfHeight: {HalfHeight}, MapResolution: {MapResolution}, Pathfinding offset: {offset}, Vertices: {edges.Length}, ScaleFactor: {ScaleFactor}";
 }

BossMod/Modules/Dawntrail/Alliance/A21FaithboundKirin/A21FaithboundKirin.cs

@@ -13,7 +13,7 @@ sealed class ArmOfPurgatory(BossModule module) : Components.SimpleAOEs(module, (
 sealed class GloamingGleam(BossModule module) : Components.SimpleAOEs(module, (uint)AID.GloamingGleam, new AOEShapeRect(50f, 6f));
 sealed class RazorFang(BossModule module) : Components.SimpleAOEs(module, (uint)AID.RazorFang, 20f);
 
-[ModuleInfo(BossModuleInfo.Maturity.Verified, Contributors = "The Combat Reborn Team (Malediktus)", PrimaryActorOID = (uint)OID.FaithboundKirin, GroupType = BossModuleInfo.GroupType.CFC, GroupID = 1058u, NameID = 14053u, Category = BossModuleInfo.Category.Alliance, Expansion = BossModuleInfo.Expansion.Dawntrail, SortOrder = 2)]
+[ModuleInfo(BossModuleInfo.Maturity.AISupport, Contributors = "The Combat Reborn Team (Malediktus)", PrimaryActorOID = (uint)OID.FaithboundKirin, GroupType = BossModuleInfo.GroupType.CFC, GroupID = 1058u, NameID = 14053u, Category = BossModuleInfo.Category.Alliance, Expansion = BossModuleInfo.Expansion.Dawntrail, SortOrder = 2)]
 public sealed class A21FaithboundKirin(WorldState ws, Actor primary) : BossModule(ws, primary, DefaultCenter, DefaultArena)
 {
     public static readonly WPos DefaultCenter = new(-850f, 780f);

BossMod/Modules/Dawntrail/Alliance/A22UltimaOmega/Crash.cs

@@ -15,7 +15,7 @@ public override void AddAIHints(int slot, Actor actor, PartyRolesConfig.Assignme
             {
                 var center = Arena.Center;
                 var dir = -25f * c.Direction.ToDirection();
-                hints.AddForbiddenZone(new SDKnockbackInAABBRectFixedDirection(center, dir, 19f, 23.5f)); // rect intentionally slightly smaller to prevent sus knockback
+                hints.AddForbiddenZone(new SDKnockbackInAABBRectFixedDirection(center, dir, 19f, 23.5f), act); // rect intentionally slightly smaller to prevent sus knockback
             }
         }
     }