Skills with a CELL pattern hit their pattern, not a single target

documentation/dat/Skill.dat.md

@@ -13,6 +13,7 @@
 | CastEffect | Int16 |  |  |
 | CastId | Int16 |  |  |
 | CastTime | Int16 |  |  |
+| CellPattern | String |  |  |
 | Class | Byte |  |  |
 | Combo | ICollection`1 |  |  |
 | Cooldown | Int16 |  |  |

src/NosCore.Database/Entities/Skill.cs

@@ -40,6 +40,10 @@ public Skill()
 
         public short Cooldown { get; set; }
 
+        /// <summary>Cells hit, "dx,dy,..." from the caster facing north. Null when there is none.</summary>
+        [MaxLength(512)]
+        public string? CellPattern { get; set; }
+
         public byte CpCost { get; set; }
 
         public short Duration { get; set; }

src/NosCore.Database/Migrations/20260826123844_AddSkillCellPattern.cs

@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace NosCore.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddSkillCellPattern : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "CellPattern",
+                table: "Skill",
+                type: "character varying(512)",
+                maxLength: 512,
+                nullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "CellPattern",
+                table: "Skill");
+        }
+    }
+}

src/NosCore.Database/Migrations/NosCoreContextModelSnapshot.cs

@@ -2743,6 +2743,10 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<short>("CastTime")
                         .HasColumnType("smallint");
 
+                    b.Property<string>("CellPattern")
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
                     b.Property<byte>("Class")
                         .HasColumnType("smallint");
 

src/NosCore.GameObject/Services/BattleService/Model/SkillInfo.cs

@@ -27,7 +27,8 @@ public sealed record SkillInfo(
     byte Element,
     short Duration,
     short MpCost,
-    IReadOnlyList<BCardDto> BCards)
+    IReadOnlyList<BCardDto> BCards,
+    string? CellPattern = null)
 {
     public bool IsAoe => HitType is TargetHitType.SingleAoeTargetHit
                          or TargetHitType.AoeTargetHit

src/NosCore.GameObject/Services/BattleService/SkillCells.cs

@@ -0,0 +1,81 @@
+//  __  _  __    __   ___ __  ___ ___
+// |  \| |/__\ /' _/ / _//__\| _ \ __|
+// | | ' | \/ |`._`.| \_| \/ | v / _|
+// |_|\__|\__/ |___/ \__/\__/|_|_\___|
+//
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+
+namespace NosCore.GameObject.Services.BattleService;
+
+public static class SkillCells
+{
+    public static sbyte[]? Parse(string? pattern)
+    {
+        if (string.IsNullOrWhiteSpace(pattern))
+        {
+            return null;
+        }
+
+        var parts = pattern.Split(',');
+
+        // Pairs, so an odd count is a broken row, not a pattern with a spare coordinate.
+        if (parts.Length == 0 || parts.Length % 2 != 0)
+        {
+            return null;
+        }
+
+        var cells = new sbyte[parts.Length];
+        for (var i = 0; i < parts.Length; i++)
+        {
+            if (!sbyte.TryParse(parts[i], NumberStyles.Integer, CultureInfo.InvariantCulture,
+                    out cells[i]))
+            {
+                return null;
+            }
+        }
+
+        return cells;
+    }
+
+    public static HashSet<(short X, short Y)> Resolve(sbyte[] pattern, short casterX,
+        short casterY, short targetX, short targetY)
+    {
+        var cells = new HashSet<(short, short)>(pattern.Length / 2);
+
+        double dx = targetX - casterX;
+        double dy = targetY - casterY;
+        var len = Math.Sqrt((dx * dx) + (dy * dy));
+
+        double ux = 0, uy = -1;
+        if (len > 0.0001)
+        {
+            ux = dx / len;
+            uy = dy / len;
+        }
+
+        foreach (var (cx, cy) in Pairs(pattern))
+        {
+            double right = cx;
+            double forward = -cy;
+
+            var x = (right * -uy) + (forward * ux);
+            var y = (right * ux) + (forward * uy);
+
+            cells.Add(((short)(casterX + Math.Round(x, MidpointRounding.AwayFromZero)),
+                (short)(casterY + Math.Round(y, MidpointRounding.AwayFromZero))));
+        }
+
+        return cells;
+    }
+
+    private static IEnumerable<(sbyte X, sbyte Y)> Pairs(sbyte[] pattern)
+    {
+        for (var i = 0; i + 1 < pattern.Length; i += 2)
+        {
+            yield return (pattern[i], pattern[i + 1]);
+        }
+    }
+}

src/NosCore.GameObject/Services/BattleService/SkillResolver.cs

@@ -135,6 +135,7 @@ private SkillInfo BuildInfo(SkillDto main, SkillDto? upgrade, long castId)
             Element: main.Element,
             Duration: main.Duration,
             MpCost: main.MpCost,
-            BCards: _catalog.GetSkillBCards(main.SkillVNum));
+            BCards: _catalog.GetSkillBCards(main.SkillVNum),
+            CellPattern: main.CellPattern);
     }
 }

src/NosCore.GameObject/Services/BattleService/TargetResolver.cs

@@ -35,6 +35,12 @@ public IReadOnlyList<IAliveEntity> Resolve(IAliveEntity attacker, IAliveEntity p
             return results;
         }
 
+        var pattern = SkillCells.Parse(skill.CellPattern);
+        var cells = pattern == null
+            ? null
+            : SkillCells.Resolve(pattern, attacker.PositionX, attacker.PositionY,
+                primaryTarget.PositionX, primaryTarget.PositionY);
+
         var range = skill.TargetRange;
         var cx = primaryTarget.PositionX;
         var cy = primaryTarget.PositionY;
@@ -44,7 +50,7 @@ public IReadOnlyList<IAliveEntity> Resolve(IAliveEntity attacker, IAliveEntity p
             if (monster.VisualId == primaryTarget.VisualId && monster.VisualType == primaryTarget.VisualType) continue;
             if (!monster.IsAlive) continue;
             if (!IsEnemy(attacker, monster)) continue;
-            if (WithinRange(cx, cy, monster.PositionX, monster.PositionY, range))
+            if (IsHit(cells, cx, cy, monster.PositionX, monster.PositionY, range))
             {
                 results.Add(monster);
             }
@@ -61,7 +67,7 @@ public IReadOnlyList<IAliveEntity> Resolve(IAliveEntity attacker, IAliveEntity p
             if (player.VisualId == attacker.VisualId && attacker.VisualType == VisualType.Player) continue;
             if (!player.IsAlive) continue;
             if (!IsEnemy(attacker, player)) continue;
-            if (WithinRange(cx, cy, player.PositionX, player.PositionY, range))
+            if (IsHit(cells, cx, cy, player.PositionX, player.PositionY, range))
             {
                 results.Add(player);
             }
@@ -86,6 +92,12 @@ private static bool IsEnemy(IAliveEntity attacker, IAliveEntity candidate)
         };
     }
 
+    private static bool IsHit(HashSet<(short X, short Y)>? cells, short cx, short cy, short x,
+        short y, int range)
+    {
+        return cells != null ? cells.Contains((x, y)) : WithinRange(cx, cy, x, y, range);
+    }
+
     private static bool WithinRange(short cx, short cy, short x, short y, int range)
     {
         return Math.Abs(cx - x) <= range && Math.Abs(cy - y) <= range;

src/NosCore.Parser/Parsers/SkillParser.cs

@@ -54,6 +54,7 @@ public FluentParserBuilder<SkillDto> BuildParser(string folder)
                 .Field(x => x.Type, chunk => Convert.ToByte(chunk["TYPE"][0][5]))
                 .Field(x => x.Element, chunk => Convert.ToByte(chunk["TYPE"][0][7]))
                 .Field(x => x.Combo, chunk => AddCombos(chunk))
+                .Field(x => x.CellPattern, chunk => ReadCellPattern(chunk))
                 .Field(x => x.CpCost, chunk => chunk["COST"][0][2] == "-1" ? (byte)0 : byte.Parse(chunk["COST"][0][2]))
                 .Field(x => x.Price, chunk => Convert.ToInt32(chunk["COST"][0][3]))
                 .Field(x => x.CastEffect, chunk => Convert.ToInt16(chunk["EFFECT"][0][3]))
@@ -144,6 +145,48 @@ private List<BCardDto> AddBCards(Dictionary<string, string[][]> chunks)
             return list;
         }
 
+        // CELL holds thirty cells at most; a longer pattern continues in the unused tail of
+        // COST. A continues flag on the last available triple means the row ran out, not that
+        // there is more, so the tail is read and may well be empty.
+        private static string? ReadCellPattern(Dictionary<string, string[][]> chunks)
+        {
+            if (!chunks.TryGetValue("CELL", out var cell) || cell.Length == 0)
+            {
+                return null;
+            }
+
+            var cells = new List<int>();
+            var ranOut = ReadTriples(cell[0], 4, cells);
+
+            if (ranOut && chunks.TryGetValue("COST", out var cost) && cost.Length > 0)
+            {
+                ReadTriples(cost[0], 5, cells);
+            }
+
+            return cells.Count == 0 ? null : string.Join(",", cells);
+        }
+
+        // Field [0] is empty and [1] is the section name, so CELL's triples start at [4] and
+        // COST's tail at [5].
+        private static bool ReadTriples(string[] fields, int start, List<int> into)
+        {
+            for (var i = start; i + 2 < fields.Length; i += 3)
+            {
+                if (!int.TryParse(fields[i], out var dx)
+                    || !int.TryParse(fields[i + 1], out var dy)
+                    || !int.TryParse(fields[i + 2], out var continues)
+                    || continues == 0)
+                {
+                    return false;
+                }
+
+                into.Add(dx);
+                into.Add(dy);
+            }
+
+            return true;
+        }
+
         // FCOMBO's first field is a switch (has a chain / has not), not a step. The row starts
         // at index 2, so triplet j starts at 3 + j*3; counting from the switch shifted every
         // step by one field and the chain never fired.

test/NosCore.GameObject.Tests/Services/BattleService/SkillCellsTests.cs

@@ -0,0 +1,130 @@
+//  __  _  __    __   ___ __  ___ ___
+// |  \| |/__\ /' _/ / _//__\| _ \ __|
+// | | ' | \/ |`._`.| \_| \/ | v / _|
+// |_|\__|\__/ |___/ \__/\__/|_|_\___|
+//
+
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NosCore.GameObject.Services.BattleService;
+
+namespace NosCore.GameObject.Tests.Services.BattleService
+{
+    [TestClass]
+    public class SkillCellsTests
+    {
+        private const string PiercingShot = "0,-8,0,-7,0,-6,0,-5,0,-4,0,-3,0,-2,0,-1";
+
+        private static List<(sbyte dx, sbyte dy)> Pairs(sbyte[] flat)
+        {
+            var cells = new List<(sbyte, sbyte)>();
+            for (var i = 0; i < flat.Length; i += 2)
+            {
+                cells.Add((flat[i], flat[i + 1]));
+            }
+
+            return cells;
+        }
+
+        [TestMethod]
+        public void AimingNorthLeavesThePatternAsWritten()
+        {
+            var pattern = SkillCells.Parse(PiercingShot)!;
+            var cells = SkillCells.Resolve(pattern, 50, 50, 50, 40);
+
+            Assert.AreEqual(8, cells.Count);
+            for (short dy = 1; dy <= 8; dy++)
+            {
+                Assert.IsTrue(cells.Contains((50, (short)(50 - dy))), $"missing (50,{50 - dy})");
+            }
+        }
+
+        [TestMethod]
+        public void AimingSouthTurnsThePatternAround()
+        {
+            var pattern = SkillCells.Parse(PiercingShot)!;
+            var cells = SkillCells.Resolve(pattern, 50, 50, 50, 60);
+
+            Assert.AreEqual(8, cells.Count);
+            for (short dy = 1; dy <= 8; dy++)
+            {
+                Assert.IsTrue(cells.Contains((50, (short)(50 + dy))), $"missing (50,{50 + dy})");
+            }
+        }
+
+        [TestMethod]
+        public void AimingEastPutsTheLineOnTheXAxis()
+        {
+            var pattern = SkillCells.Parse(PiercingShot)!;
+            var cells = SkillCells.Resolve(pattern, 50, 50, 60, 50);
+
+            Assert.AreEqual(8, cells.Count);
+            for (short dx = 1; dx <= 8; dx++)
+            {
+                Assert.IsTrue(cells.Contains(((short)(50 + dx), 50)), $"missing ({50 + dx},50)");
+            }
+        }
+
+        // Diagonals round, so demand the quadrant and the reach rather than exact cells.
+        [TestMethod]
+        public void AimingDiagonallyPointsTheLineAtTheTarget()
+        {
+            var pattern = SkillCells.Parse(PiercingShot)!;
+            var cells = SkillCells.Resolve(pattern, 50, 50, 60, 40);
+
+            Assert.IsTrue(cells.All(c => c.X >= 50 && c.Y <= 50),
+                "a cell landed outside the target's quadrant");
+
+            var furthest = cells.Max(c => System.Math.Max(System.Math.Abs(c.X - 50),
+                System.Math.Abs(c.Y - 50)));
+            Assert.AreEqual(6, furthest,
+                "eight diagonal steps reach six cells on each axis, not eight");
+        }
+
+        // Without the zero-distance guard the normalisation divides by zero and every cell
+        // collapses onto the caster, silently.
+        [TestMethod]
+        public void CastingOnYourOwnCellKeepsTheWrittenOrientation()
+        {
+            var pattern = SkillCells.Parse(PiercingShot)!;
+            var cells = SkillCells.Resolve(pattern, 50, 50, 50, 50);
+
+            Assert.AreEqual(8, cells.Count);
+            Assert.IsTrue(cells.Contains((50, 42)));
+        }
+
+        // Most skills have no drawing: 1890 of the 1958. The column is null for them.
+        [TestMethod]
+        public void ASkillWithoutADrawingHasNoPattern()
+        {
+            Assert.IsNull(SkillCells.Parse(null));
+            Assert.IsNull(SkillCells.Parse(""));
+            Assert.IsNull(SkillCells.Parse("   "));
+        }
+
+        // A broken row must not stop a fight: the pattern decides who a skill hits, and throwing
+        // here would take down the cast instead of degrading it to a single target.
+        [TestMethod]
+        public void AMalformedColumnIsNoPatternRatherThanAnException()
+        {
+            Assert.IsNull(SkillCells.Parse("0,-1,0"), "an odd count is a broken row, not a cell");
+            Assert.IsNull(SkillCells.Parse("0,-1,x,2"));
+            Assert.IsNull(SkillCells.Parse("0,-1,,2"));
+            Assert.IsNull(SkillCells.Parse("0,-1,200,2"), "200 does not fit an sbyte");
+        }
+
+        [TestMethod]
+        public void AWellFormedColumnComesBackAsPairs()
+        {
+            var pattern = SkillCells.Parse(PiercingShot)!;
+            Assert.AreEqual(16, pattern.Length);
+
+            var cells = Pairs(pattern);
+            Assert.AreEqual(8, cells.Count);
+            Assert.IsTrue(cells.All(c => c.dx == 0), "the line is one cell wide");
+            Assert.AreEqual(-8, cells.Min(c => c.dy));
+            Assert.AreEqual(-1, cells.Max(c => c.dy));
+        }
+    }
+}