Add system changes to facilitate Whirling Swipe

Author: CarlosFdez

src/module/actor/creature/document.ts

@@ -95,28 +95,17 @@ abstract class CreaturePF2e<
      */
     override getReach({ action = "interact", weapon = null }: GetReachParameters = {}): number {
         const baseReach = this.attributes.reach.base;
-        const weaponReach = weapon?.isOfType("melee") ? weapon.reach : null;
 
         if (action === "interact" || this.type === "familiar") {
-            return baseReach;
-        } else if (typeof weaponReach === "number") {
-            return weaponReach;
+            return this.attributes.reach.base;
+        } else if (weapon?.isOfType("melee", "weapon")) {
+            return weapon.reach ?? baseReach;
         } else {
-            const attacks: { item: ItemPF2e<ActorPF2e>; ready: boolean }[] = weapon
-                ? [{ item: weapon, ready: true }]
-                : (this.system.actions ?? []);
-            const readyAttacks = attacks.filter((a) => a.ready);
-            const traitsFromItems = readyAttacks.map((a) => new Set(a.item.system.traits?.value ?? []));
-            if (traitsFromItems.length === 0) return baseReach;
-
-            const reaches = traitsFromItems.map((traits): number => {
-                if (setHasElement(traits, "reach")) return baseReach + 5;
-
-                const reachNPattern = /^reach-\d{1,3}$/;
-                return Number([...traits].find((t) => reachNPattern.test(t))?.replace("reach-", "")) || baseReach;
-            });
-
-            return Math.max(...reaches);
+            const readiedItems = this.system.actions?.filter((a) => a.ready).map((a) => a.item) ?? [];
+            return Math.max(
+                baseReach,
+                ...readiedItems.map((i) => i.reach).filter((r): r is number => typeof r === "number"),
+            );
         }
     }
 

src/module/item/melee/document.ts

@@ -49,6 +49,7 @@ class MeleePF2e<TParent extends ActorPF2e | null = ActorPF2e | null> extends Ite
         return Number(this.system.bonus.value) || 0;
     }
 
+    /** The reach of this npc attack when they attack with it */
     get reach(): number | null {
         if (this.isRanged) return null;
         const reachTrait = this.system.traits.value.find((t) => /^reach-\d+$/.test(t));

src/module/item/weapon/document.ts

@@ -105,6 +105,17 @@ class WeaponPF2e<TParent extends ActorPF2e | null = ActorPF2e | null> extends Ph
         return this.system.maxRange ?? (this.system.range ? this.system.range * 6 : null);
     }
 
+    /** The reach of this weapon when using it. */
+    get reach(): number | null {
+        if (!this.isMelee) return null;
+
+        const actor = this.actor;
+        const baseReach = actor?.isOfType("creature") ? (actor.attributes.reach?.base ?? 5) : 5;
+        const traits = this.system.traits.value;
+        const reachIncrease = traits.includes("reach") ? 5 : 0;
+        return baseReach + reachIncrease;
+    }
+
     /** A single object containing range increment and maximum */
     get range(): RangeData | null {
         const rangeIncrement = this.system.range;

src/module/rules/rule-element/base.ts

@@ -256,28 +256,50 @@ abstract class RuleElementPF2e<TSchema extends RuleElementSchema = RuleElementSc
                 "rule",
                 ...Object.keys(injectables).filter((i) => /^[a-z][a-z]+$/g.test(i)),
             ];
-            const pattern = new RegExp(String.raw`{(${injectableKeys.join("|")})\|(.*?)}`, "g");
+
+            const injectablePattern = new RegExp(String.raw`^(${injectableKeys.join("|")})\|(.*?)$`, "g");
             const allInjectables: Record<string, object> = {
                 actor: this.actor,
                 item: this.item,
                 rule: this,
                 ...injectables,
             };
-            return source.replace(pattern, (_match, key: string, prop: string) => {
-                const data = allInjectables[key];
-                const value = (() => {
-                    // In case of formerly deprecated paths upstream now throws on
-                    try {
-                        return fu.getProperty(data, prop);
-                    } catch {
-                        return undefined;
+
+            const bracketPattern = /{([^{}]+)}/g;
+            return source.replace(bracketPattern, (match, value) => {
+                // Support {@actor.level} type stuff
+                if (value.includes("@")) {
+                    const result = this.#saferEval(
+                        Roll.replaceFormulaData(value, {
+                            ...this.item.getRollData(),
+                            rule: this,
+                            ...injectables,
+                        }),
+                        { warn, defaultValue: match },
+                    );
+                    return String(result);
+                }
+
+                const injectableMatch = injectablePattern.exec(value);
+                if (injectableMatch) {
+                    const [_, key, prop] = injectableMatch;
+                    const data = allInjectables[key];
+                    const value = (() => {
+                        // In case of formerly deprecated paths upstream now throws on
+                        try {
+                            return fu.getProperty(data, prop);
+                        } catch {
+                            return undefined;
+                        }
+                    })();
+                    if (value === undefined) {
+                        this.ignored = true;
+                        if (warn) this.failValidation(`Failed to resolve injected property "${prop}" in "${source}"`);
                     }
-                })();
-                if (value === undefined) {
-                    this.ignored = true;
-                    if (warn) this.failValidation(`Failed to resolve injected property "${prop}" in "${source}"`);
+                    return String(value);
                 }
-                return String(value);
+
+                return match;
             });
         }
 
@@ -308,7 +330,7 @@ abstract class RuleElementPF2e<TSchema extends RuleElementSchema = RuleElementSc
         if (typeof value === "number" || typeof value === "boolean" || value === null) {
             return value;
         }
-        value = this.resolveInjectedProperties(value, { warn });
+        value = this.resolveInjectedProperties(value, { warn, injectables: resolvables });
 
         if (Array.isArray(value)) return value;
 
@@ -324,48 +346,51 @@ abstract class RuleElementPF2e<TSchema extends RuleElementSchema = RuleElementSc
         }
 
         if (typeof resolvedFromBracket === "string") {
-            const saferEval = (formula: string): number => {
-                try {
-                    // If any resolvables were not provided for this formula, return the default value
-                    const unresolveds = formula.match(/@[a-z0-9.]+/gi) ?? [];
-                    // Allow failure of "@target" and "@actor.conditions" with no warning
-                    if (unresolveds.length > 0) {
-                        const shouldWarn =
-                            warn &&
-                            !unresolveds.every((u) => u.startsWith("@target.") || u.startsWith("@actor.conditions."));
-                        this.ignored = true;
-                        if (shouldWarn) {
-                            this.failValidation(`unable to resolve formula, "${formula}"`);
-                        }
-                        return Number(defaultValue);
-                    }
-                    return Roll.safeEval(formula);
-                } catch {
-                    this.failValidation(`unable to evaluate formula, "${formula}"`);
-                    return 0;
-                }
-            };
-
             // Include worn armor as resolvable for PCs since there is guaranteed to be no more than one
             if (this.actor.isOfType("character")) {
                 resolvables.armor = this.actor.wornArmor;
             }
 
             const trimmed = resolvedFromBracket.trim();
             return (trimmed.includes("@") || /^-?\d+$/.test(trimmed)) && evaluate
-                ? saferEval(
+                ? this.#saferEval(
                       Roll.replaceFormulaData(trimmed, {
                           ...this.actor.getRollData(),
                           item: this.item,
                           ...resolvables,
                       }),
+                      { warn, defaultValue },
                   )
                 : trimmed;
         }
 
         return defaultValue;
     }
 
+    #saferEval(
+        formula: string,
+        { warn, defaultValue }: { warn: boolean; defaultValue: Exclude<RuleValue, BracketedValue> | null },
+    ): number {
+        try {
+            // If any resolvables were not provided for this formula, return the default value
+            const unresolveds = formula.match(/@[a-z0-9.]+/gi) ?? [];
+            // Allow failure of "@target" and "@actor.conditions" with no warning
+            if (unresolveds.length > 0) {
+                const shouldWarn =
+                    warn && !unresolveds.every((u) => u.startsWith("@target.") || u.startsWith("@actor.conditions."));
+                this.ignored = true;
+                if (shouldWarn) {
+                    this.failValidation(`unable to resolve formula, "${formula}"`);
+                }
+                return Number(defaultValue);
+            }
+            return Roll.safeEval(formula);
+        } catch {
+            this.failValidation(`unable to evaluate formula, "${formula}"`);
+            return 0;
+        }
+    }
+
     protected isBracketedValue(value: unknown): value is BracketedValue {
         return isBracketedValue(value);
     }

src/module/rules/rule-element/item-alteration/alteration.ts

@@ -50,6 +50,12 @@ class ItemAlteration extends foundry.abstract.DataModel<RuleElementPF2e, ItemAlt
         "traits",
     ] as const;
 
+    static VALID_PHASES = {
+        "pd-recovery-dc": ["afterDerived"],
+        // Much prep like strikes and armor occur before afterDerived, and the traits must be set by then
+        traits: ["applyAEs", "beforeDerived"],
+    } as const;
+
     static override defineSchema(): ItemAlterationSchema {
         return {
             mode: new fields.StringField({
@@ -88,7 +94,9 @@ class ItemAlteration extends foundry.abstract.DataModel<RuleElementPF2e, ItemAlt
             alteration: {
                 mode: this.mode,
                 itemType: item.type,
-                value: (this.value = this.parent.resolveValue(this.value, fallbackValue)),
+                value: (this.value = this.parent.resolveValue(this.value, fallbackValue, {
+                    resolvables: { targetItem: item },
+                })),
             },
         };
         if (this.parent.ignored) return;

src/module/rules/rule-element/item-alteration/rule-element.ts

@@ -2,8 +2,9 @@ import type { ActorPF2e } from "@actor";
 import type { ItemPF2e, PhysicalItemPF2e } from "@item";
 import type { ItemType } from "@item/base/data/index.ts";
 import { PHYSICAL_ITEM_TYPES } from "@item/physical/values.ts";
+import { objectHasKey } from "@util";
 import * as R from "remeda";
-import { AELikeRuleElement } from "../ae-like.ts";
+import { AELikeDataPrepPhase, AELikeRuleElement } from "../ae-like.ts";
 import { RuleElementPF2e } from "../base.ts";
 import type { ModelPropsFromRESchema, RuleElementSchema } from "../data.ts";
 import { ItemAlteration, ItemAlterationSchema } from "./alteration.ts";
@@ -34,6 +35,15 @@ class ItemAlterationRuleElement extends RuleElementPF2e<ItemAlterationRuleSchema
                 choices: itemTypeChoices,
                 initial: undefined,
             }),
+            phase: new fields.StringField({
+                required: true,
+                choices: ["applyAEs", "beforeDerived", "afterDerived"],
+                initial: (data: unknown) => {
+                    const validPhasesMap = ItemAlteration.VALID_PHASES;
+                    const property = R.isPlainObject(data) ? data["property"] : null;
+                    return objectHasKey(validPhasesMap, property) ? validPhasesMap[property][0] : "applyAEs";
+                },
+            }),
             ...ItemAlteration.defineSchema(),
         };
     }
@@ -44,10 +54,17 @@ class ItemAlterationRuleElement extends RuleElementPF2e<ItemAlterationRuleSchema
         if (!data.itemId && !data.itemType) {
             throw Error("one of itemId and itemType must be defined");
         }
-    }
 
-    /** Alteration properties that should be processed at the end of data preparation */
-    static #DELAYED_PROPERTIES = ["pd-recovery-dc"];
+        // Validate that the phase is supported by the property
+        const { property, phase } = data;
+        const validPhasesMap = ItemAlteration.VALID_PHASES;
+        const validPhases: readonly ItemAlterationPrepPhase[] = objectHasKey(validPhasesMap, property)
+            ? validPhasesMap[property]
+            : (["applyAEs"] as const);
+        if (phase && !validPhases.includes(phase)) {
+            throw Error(`phase: ${phase} is not a valid choice, must be one of ${validPhases.join(", ")}`);
+        }
+    }
 
     /** Alteration properties that should only be processed when requested directly */
     static #LAZY_PROPERTIES = ["description"];
@@ -93,16 +110,22 @@ class ItemAlterationRuleElement extends RuleElementPF2e<ItemAlterationRuleSchema
     }
 
     override onApplyActiveEffects(): void {
-        this.actor.synthetics.itemAlterations.push(this);
-        const isDelayed = this.constructor.#DELAYED_PROPERTIES.includes(this.property);
-        if (!this.isLazy && !isDelayed) {
+        if (!this.isLazy && this.phase === "applyAEs") {
+            this.actor.synthetics.itemAlterations.push(this);
+            this.applyAlteration();
+        }
+    }
+
+    override beforePrepareData(): void {
+        if (!this.isLazy && this.phase === "beforeDerived") {
+            this.actor.synthetics.itemAlterations.push(this);
             this.applyAlteration();
         }
     }
 
     override afterPrepareData(): void {
-        const isDelayed = this.constructor.#DELAYED_PROPERTIES.includes(this.property);
-        if (!this.isLazy && isDelayed) {
+        if (!this.isLazy && this.phase === "afterDerived") {
+            this.actor.synthetics.itemAlterations.push(this);
             this.applyAlteration();
         }
     }
@@ -175,12 +198,16 @@ interface ItemAlterationRuleElement
     constructor: typeof ItemAlterationRuleElement;
 }
 
+type ItemAlterationPrepPhase = Exclude<AELikeDataPrepPhase, "beforeRoll">;
+
 type ItemAlterationRuleSchema = RuleElementSchema &
     ItemAlterationSchema & {
         /** The type of items to alter */
         itemType: fields.StringField<ItemType, ItemType, false, false, false>;
         /** As an alternative to specifying item types, an exact item ID can be provided */
         itemId: fields.StringField<string, string, false, false, false>;
+        /** The phase to run the alteration in. Most only support applyAEs */
+        phase: fields.StringField<ItemAlterationPrepPhase, ItemAlterationPrepPhase, true, false, true>;
     };
 
 interface ApplyAlterationOptions {

src/module/rules/rule-element/item-alteration/schemas.ts

@@ -4,6 +4,7 @@ import type { ItemSourcePF2e, ItemType } from "@item/base/data/index.ts";
 import type { ItemTrait } from "@item/base/types.ts";
 import { itemIsOfType } from "@item/helpers.ts";
 import { PHYSICAL_ITEM_TYPES, PRECIOUS_MATERIAL_TYPES } from "@item/physical/values.ts";
+import { MANDATORY_RANGED_GROUPS } from "@item/weapon/values.ts";
 import { RARITIES } from "@module/data.ts";
 import { DamageRoll } from "@system/damage/roll.ts";
 import type { DamageDiceFaces, DamageType } from "@system/damage/types.ts";
@@ -14,7 +15,6 @@ import * as R from "remeda";
 import type { AELikeChangeMode } from "../ae-like.ts";
 import fields = foundry.data.fields;
 import validation = foundry.data.validation;
-import { MANDATORY_RANGED_GROUPS } from "@item/weapon/values.ts";
 
 /** A `SchemaField` reappropriated for validation of specific item alterations */
 class ItemAlterationValidator<TSchema extends AlterationSchema> extends fields.SchemaField<TSchema> {