feat(headless): share immutable gameplay content

src/AcDream.Core/Spells/SpellComponentRequirementService.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using AcDream.Core.Items;
+
+namespace AcDream.Core.Spells;
+
+public sealed record SpellFormulaDefinition(
+    uint FormulaVersion,
+    IReadOnlyList<uint> ComponentIds,
+    uint School = 0u);
+
+/// <summary>
+/// Client-side retail component preflight for ClientMagicSystem::CastSpell
+/// (0x00568040). Spell formula entries are SCIDs; carried inventory objects and
+/// SetDesiredComponent use WCIDs, so all comparisons cross the DAT enum map.
+/// </summary>
+public sealed class SpellComponentRequirementService
+{
+    public const uint SpellComponentsRequiredProperty = 68u;
+
+    private readonly ClientObjectTable _objects;
+    private readonly Func<uint> _playerGuid;
+    private readonly Func<string> _accountName;
+    private readonly IReadOnlyDictionary<uint, SpellFormulaDefinition> _formulas;
+    private readonly IReadOnlyDictionary<uint, uint> _wcidByScid;
+    private readonly IReadOnlyDictionary<uint, uint> _magicPackWcidBySchool;
+
+    public SpellComponentRequirementService(
+        ClientObjectTable objects,
+        Func<uint> playerGuid,
+        Func<string> accountName,
+        IReadOnlyDictionary<uint, SpellFormulaDefinition> formulas,
+        IReadOnlyDictionary<uint, uint> wcidByScid,
+        IReadOnlyDictionary<uint, uint>? magicPackWcidBySchool = null)
+    {
+        _objects = objects ?? throw new ArgumentNullException(nameof(objects));
+        _playerGuid = playerGuid ?? throw new ArgumentNullException(nameof(playerGuid));
+        _accountName = accountName ?? throw new ArgumentNullException(nameof(accountName));
+        _formulas = formulas ?? throw new ArgumentNullException(nameof(formulas));
+        _wcidByScid = wcidByScid ?? throw new ArgumentNullException(nameof(wcidByScid));
+        _magicPackWcidBySchool = magicPackWcidBySchool
+            ?? new Dictionary<uint, uint>();
+    }
+
+    public bool HasRequiredComponents(uint spellId)
+    {
+        uint playerGuid = _playerGuid();
+        ClientObject? player = _objects.Get(playerGuid);
+        if (player is not null
+            && !player.Properties.GetBool(SpellComponentsRequiredProperty, true))
+            return true;
+        if (!_formulas.TryGetValue(spellId, out SpellFormulaDefinition? formula))
+            return false;
+
+        HashSet<uint> ownedWcids = _objects.Objects
+            .Where(item => IsOwnedByPlayer(item, playerGuid))
+            .Select(item => item.WeenieClassId)
+            .ToHashSet();
+        IReadOnlyList<uint> components = GetAppropriateFormula(
+            formula, player, playerGuid);
+        foreach (uint scid in components)
+        {
+            if (scid == 0u) continue;
+            if (!_wcidByScid.TryGetValue(scid, out uint wcid)
+                || !ownedWcids.Contains(wcid))
+                return false;
+        }
+        return true;
+    }
+
+    /// <summary>
+    /// Retail <c>ClientMagicSystem::GetAppropriateSpellFormula</c>
+    /// (0x00567D50): an infused school or a directly carried school focus uses
+    /// the scarab-only formula; otherwise the account-customized formula wins.
+    /// ACE characters with component enforcement disabled use the same modern
+    /// scarab/taper presentation instead of exposing an unusable legacy recipe.
+    /// </summary>
+    public IReadOnlyList<uint> GetAppropriateFormula(uint spellId)
+    {
+        if (!_formulas.TryGetValue(spellId, out SpellFormulaDefinition? formula))
+            return [];
+        uint playerGuid = _playerGuid();
+        return GetAppropriateFormula(
+            formula,
+            _objects.Get(playerGuid),
+            playerGuid);
+    }
+
+    /// <summary>
+    /// Whether the component tracker would leave a formula icon unghosted.
+    /// The input is a retail spell-component id (SCID), not a weenie class id.
+    /// </summary>
+    public bool IsComponentOwned(uint spellComponentId)
+    {
+        if (!_wcidByScid.TryGetValue(spellComponentId, out uint weenieClassId))
+            return false;
+        uint playerGuid = _playerGuid();
+        return _objects.Objects.Any(item =>
+            item.WeenieClassId == weenieClassId
+            && IsOwnedByPlayer(item, playerGuid));
+    }
+
+    private IReadOnlyList<uint> GetAppropriateFormula(
+        SpellFormulaDefinition formula,
+        ClientObject? player,
+        uint playerGuid)
+    {
+        bool componentsRequired =
+            player?.Properties.GetBool(SpellComponentsRequiredProperty, true)
+            ?? true;
+        bool infused = SchoolInfusionProperty(formula.School) is uint propertyId
+            && player?.Properties.GetInt(propertyId) > 0;
+        bool carriesMagicPack = _magicPackWcidBySchool.TryGetValue(
+                formula.School, out uint packWcid)
+            && _objects.Objects.Any(item =>
+                item.ContainerId == playerGuid
+                && item.WeenieClassId == packWcid);
+        return !componentsRequired || infused || carriesMagicPack
+            ? RetailSpellFormula.InqScarabOnlyFormula(formula.ComponentIds)
+            : RetailSpellFormula.CustomizeForAccount(
+                formula.ComponentIds, formula.FormulaVersion, _accountName());
+    }
+
+    private static uint? SchoolInfusionProperty(uint school) => school switch
+    {
+        1u => 0x129u, // AugmentationInfusedWarMagic
+        2u => 0x128u, // AugmentationInfusedLifeMagic
+        3u => 0x127u, // AugmentationInfusedItemMagic
+        4u => 0x126u, // AugmentationInfusedCreatureMagic
+        5u => 0x148u, // AugmentationInfusedVoidMagic
+        _ => null,
+    };
+
+    private bool IsOwnedByPlayer(ClientObject item, uint playerGuid)
+    {
+        if (playerGuid == 0u) return false;
+        ClientObject current = item;
+        for (int depth = 0; depth < 16; depth++)
+        {
+            if (current.WielderId == playerGuid || current.ContainerId == playerGuid)
+                return true;
+            if (current.ContainerId == 0u
+                || _objects.Get(current.ContainerId) is not { } parent)
+                return false;
+            current = parent;
+        }
+        return false;
+    }
+}

src/AcDream.Core/Spells/SpellTable.cs

@@ -7,7 +7,8 @@ namespace AcDream.Core.Spells;
 
 /// <summary>
 /// Immutable lookup of retail spell metadata. Production builds create this
-/// table from portal.dat through the App-layer <c>MagicCatalog</c>. The CSV
+/// table from portal.dat through Content's process-shareable
+/// <c>MagicCatalog</c>. The CSV
 /// parser below remains for historical tooling and small synthetic tests.
 ///
 /// <para>