acdream/src/AcDream.Plugins.MossTank/BuffProfile.cs

using System.Text.RegularExpressions;
using AcDream.Plugin.Abstractions;

namespace AcDream.Plugins.MossTank;

/// <summary>What a buff line raises.</summary>
public enum BuffTargetKind
{
    Unknown = 0,
    Skill,
    Attribute,
}

/// <summary>One buff line: a family, what it raises, and its known tiers.</summary>
public sealed record BuffLine(
    uint Family,
    BuffTargetKind Kind,
    string TargetName,
    List<PluginSpellInfo> Tiers);

/// <summary>
/// Works out which stat each known self-buff raises, straight from retail data.
/// </summary>
/// <remarks>
/// <para>
/// The client's spell table carries no link between a spell and the stat it
/// modifies — that arrives from the server with the enchantment. But retail
/// writes it in the spell's own description:
/// </para>
/// <code>
/// Increases the caster's Life Magic skill by 10 points.
/// Increases the caster's Strength by 10 points.
/// </code>
/// <para>
/// So the mapping is derived from shipped data rather than hard-coded, which
/// matters because the naming is genuinely irregular and no rule would cover
/// it: <b>Invulnerability</b> raises Melee Defense, <b>Impregnability</b>
/// raises Missile Defense, <b>Fealty</b> raises Loyalty, <b>Sprint</b> raises
/// Run, <b>Arcane Enlightenment</b> raises Arcane Lore, and — the one that
/// would silently poison any name-matching scheme — the spell line called
/// <b>Willpower</b> raises the attribute named <b>Self</b>.
/// </para>
/// </remarks>
public static partial class BuffProfile
{
    [GeneratedRegex(
        @"^Increases (?:the caster's|your) (?<target>.+?)(?<skill>\s+skill)? by ",
        RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)]
    private static partial Regex IncreasesPattern();

    /// <summary>
    /// Retail's spell text says "Assess Monster" where the skill table says
    /// "Assess Creature". Without this the skill silently never matches and its
    /// buff is quietly dropped from every plan.
    /// </summary>
    private static readonly Dictionary<string, string> SkillNameAliases =
        new(StringComparer.OrdinalIgnoreCase)
        {
            ["Assess Monster"] = "Assess Creature",
        };

    /// <summary>
    /// Group the character's known self-buffs into buff lines, keeping only
    /// lines that raise a stat and last long enough to be worth maintaining.
    /// </summary>
    public static List<BuffLine> Build(IReadOnlyList<PluginSpellInfo> knownSelfBuffs)
    {
        var byFamily = new Dictionary<uint, BuffLine>();

        foreach (PluginSpellInfo spell in knownSelfBuffs)
        {
            // Instantaneous spells (the vital transfers, heals) are not buffs;
            // they also share families across unrelated lines, so grouping them
            // by family would be wrong twice over.
            if (spell.DurationSeconds <= 0f)
                continue;

            if (!TryParseTarget(spell.Description, out BuffTargetKind kind, out string target))
                continue;

            if (!byFamily.TryGetValue(spell.Family, out BuffLine? line))
            {
                line = new BuffLine(spell.Family, kind, target, new List<PluginSpellInfo>());
                byFamily.Add(spell.Family, line);
            }
            line.Tiers.Add(spell);
        }

        foreach (BuffLine line in byFamily.Values)
            line.Tiers.Sort(static (a, b) => b.Tier.CompareTo(a.Tier));   // strongest first

        return byFamily.Values.ToList();
    }

    /// <summary>Parse "Increases the caster's X [skill] by N points."</summary>
    public static bool TryParseTarget(
        string? description, out BuffTargetKind kind, out string target)
    {
        kind = BuffTargetKind.Unknown;
        target = string.Empty;
        if (string.IsNullOrEmpty(description))
            return false;

        Match match = IncreasesPattern().Match(description);
        if (!match.Success)
            return false;

        target = match.Groups["target"].Value.Trim();
        if (target.Length == 0)
            return false;
        if (SkillNameAliases.TryGetValue(target, out string? alias))
            target = alias;

        // The word "skill" is what separates a skill buff from an attribute
        // buff in retail's own wording.
        kind = match.Groups["skill"].Success ? BuffTargetKind.Skill : BuffTargetKind.Attribute;
        return true;
    }
}