ds4/src/module/actor/actor.ts

import { ModifiableDataBaseTotal } from "../common/common-data";
import { DS4 } from "../config";
import { DS4Item } from "../item/item";
import { ItemType } from "../item/item-data";
import { DS4ArmorPreparedData, DS4ShieldPreparedData } from "../item/item-prepared-data";
import { createCheckRoll } from "../rolls/check-factory";
import { DS4ActorData, isAttribute, isTrait } from "./actor-data";
import { Check, DS4ActorPreparedData } from "./actor-prepared-data";

/**
 * The Actor class for DS4
 */
export class DS4Actor extends Actor<DS4ActorData, DS4Item, DS4ActorPreparedData> {
    /** @override */
    prepareData(): void {
        this.data = duplicate(this._data) as DS4ActorPreparedData;
        if (!this.data.img) this.data.img = CONST.DEFAULT_TOKEN;
        if (!this.data.name) this.data.name = "New " + this.entity;
        this.prepareBaseData();
        this.prepareEmbeddedEntities();
        this.applyActiveEffectsToBaseData();
        this.prepareDerivedData();
        this.applyActiveEffectsToDerivedData();
        this.prepareFinalDerivedData();
    }

    /** @override */
    prepareBaseData(): void {
        const data = this.data;

        data.data.rolling = {
            minimumFumbleResult: 20,
            maximumCoupResult: 1,
        };

        const attributes = data.data.attributes;
        Object.values(attributes).forEach(
            (attribute: ModifiableDataBaseTotal<number>) => (attribute.total = attribute.base + attribute.mod),
        );

        const traits = data.data.traits;
        Object.values(traits).forEach(
            (trait: ModifiableDataBaseTotal<number>) => (trait.total = trait.base + trait.mod),
        );
    }

    applyActiveEffectsToBaseData(): void {
        // reset overrides because our variant of applying active effects does not set them, it only adds overrides
        this.overrides = {};
        this.applyActiveEffectsFiltered(
            (change) =>
                !this.derivedDataProperties.includes(change.key) &&
                !this.finalDerivedDataProperties.includes(change.key),
        );
    }

    applyActiveEffectsToDerivedData(): void {
        this.applyActiveEffectsFiltered((change) => this.derivedDataProperties.includes(change.key));
    }

    /**
     * Apply ActiveEffectChanges to the Actor data which are caused by ActiveEffects and satisfy the given predicate.
     *
     * @param predicate - The predicate that ActiveEffectChanges need to satisfy in order to be applied
     */
    applyActiveEffectsFiltered(predicate: (change: ActiveEffectChange) => boolean): void {
        const overrides: Record<string, unknown> = {};

        // Organize non-disabled effects by their application priority
        const changes = this.effects.reduce(
            (changes: Array<ActiveEffectChange & { effect: ActiveEffect<DS4Actor> }>, e) => {
                if (e.data.disabled) return changes;
                const item = this._getOriginatingItemOfActiveEffect(e);
                if (item?.isNonEquippedEuipable()) return changes;

                const factor = item?.activeEffectFactor ?? 1;

                return changes.concat(
                    e.data.changes.filter(predicate).flatMap((c) => {
                        const duplicatedChange = duplicate(c);
                        duplicatedChange.priority = duplicatedChange.priority ?? duplicatedChange.mode * 10;
                        return Array(factor).fill({
                            ...duplicatedChange,
                            effect: e,
                        });
                    }),
                );
            },
            [],
        );
        changes.sort((a, b) => a.priority - b.priority);

        // Apply all changes
        for (const change of changes) {
            const result = change.effect.apply(this, change);
            if (result !== null) overrides[change.key] = result;
        }

        // Expand the set of final overrides
        this.overrides = expandObject({ ...flattenObject(this.overrides), ...overrides });
    }

    protected _getOriginatingItemOfActiveEffect(effect: ActiveEffect<DS4Actor>): DS4Item | undefined {
        return this.items.find((item) => item.uuid === effect.data.origin) ?? undefined;
    }

    /**
     * Apply transformations to the Actor data after effects have been applied to the base data.
     * @override
     */
    prepareDerivedData(): void {
        this._prepareCombatValues();
        this._prepareChecks();
    }

    /**
     * The list of properties that are derived from others, given in dot notation.
     */
    get derivedDataProperties(): Array<string> {
        const combatValueProperties = Object.keys(DS4.i18n.combatValues).map(
            (combatValue) => `data.combatValues.${combatValue}.total`,
        );
        const checkProperties = Object.keys(DS4.i18n.checks)
            .filter((check) => check !== "defend")
            .map((check) => `data.checks.${check}`);
        return combatValueProperties.concat(checkProperties);
    }

    /**
     * Apply final transformations to the Actor data after all effects have been applied.
     */
    prepareFinalDerivedData(): void {
        this.data.data.combatValues.hitPoints.max = this.data.data.combatValues.hitPoints.total;
        this.data.data.checks.defend = this.data.data.combatValues.defense.total;
        if (this.data.type === "character") {
            this.data.data.slayerPoints.max = 3;
        }
    }

    /**
     * The list of properties that are completely derived (i.e. {@link ActiveEffect}s cannot be applied to them),
     * given in dot notation.
     */
    get finalDerivedDataProperties(): string[] {
        return ["data.combatValues.hitPoints.max", "data.checks.defend"].concat(
            this.data.type === "character" ? ["data.slayerPoints.max"] : [],
        );
    }

    /**
     * The list of item types that can be owned by this actor.
     */
    get ownableItemTypes(): Array<ItemType> {
        switch (this.data.type) {
            case "character":
                return [
                    "weapon",
                    "armor",
                    "shield",
                    "equipment",
                    "loot",
                    "spell",
                    "talent",
                    "racialAbility",
                    "language",
                    "alphabet",
                ];
            case "creature":
                return ["weapon", "armor", "shield", "equipment", "loot", "spell", "specialCreatureAbility"];
            default:
                return [];
        }
    }

    /**
     * Checks whether or not the given item type can be owned by the actor.
     * @param itemType - The item type to check
     */
    canOwnItemType(itemType: ItemType): boolean {
        return this.ownableItemTypes.includes(itemType);
    }

    /**
     *  Prepares the combat values of the actor.
     */
    protected _prepareCombatValues(): void {
        const data = this.data.data;
        const armorValueOfEquippedItems = this._calculateArmorValueOfEquippedItems();

        data.combatValues.hitPoints.base = data.attributes.body.total + data.traits.constitution.total + 10;
        data.combatValues.defense.base =
            data.attributes.body.total + data.traits.constitution.total + armorValueOfEquippedItems;
        data.combatValues.initiative.base = data.attributes.mobility.total + data.traits.agility.total;
        data.combatValues.movement.base = data.attributes.mobility.total / 2 + 1;
        data.combatValues.meleeAttack.base = data.attributes.body.total + data.traits.strength.total;
        data.combatValues.rangedAttack.base = data.attributes.mobility.total + data.traits.dexterity.total;
        data.combatValues.spellcasting.base =
            data.attributes.mind.total + data.traits.aura.total - armorValueOfEquippedItems;
        data.combatValues.targetedSpellcasting.base =
            data.attributes.mind.total + data.traits.dexterity.total - armorValueOfEquippedItems;

        Object.values(data.combatValues).forEach(
            (combatValue: ModifiableDataBaseTotal<number>) => (combatValue.total = combatValue.base + combatValue.mod),
        );
    }

    /**
     * Calculates the total armor value of all equipped items.
     */
    protected _calculateArmorValueOfEquippedItems(): number {
        return this.items
            .map((item) => item.data)
            .filter(
                (data): data is DS4ArmorPreparedData | DS4ShieldPreparedData =>
                    data.type === "armor" || data.type === "shield",
            )
            .filter((data) => data.data.equipped)
            .map((data) => data.data.armorValue)
            .reduce((a, b) => a + b, 0);
    }

    /**
     * Prepares the check target numbers of checks for the actor.
     */
    protected _prepareChecks(): void {
        const data = this.data.data;
        data.checks = {
            appraise: data.attributes.mind.total + data.traits.intellect.total,
            changeSpell: data.attributes.mind.total + data.traits.intellect.total,
            climb: data.attributes.mobility.total + data.traits.strength.total,
            communicate: data.attributes.mind.total + data.traits.dexterity.total,
            decipherScript: data.attributes.mind.total + data.traits.intellect.total,
            defend: 0, // assigned in prepareFinalDerivedData as it must always match data.combatValues.defense.total and is not changeable by effects
            defyPoison: data.attributes.body.total + data.traits.constitution.total,
            disableTraps: data.attributes.mind.total + data.traits.dexterity.total,
            featOfStrength: data.attributes.body.total + data.traits.strength.total,
            flirt: data.attributes.mind.total + data.traits.aura.total,
            haggle: data.attributes.mind.total + Math.max(data.traits.intellect.total, data.traits.intellect.total),
            hide: data.attributes.mobility.total + data.traits.agility.total,
            identifyMagic: data.attributes.mind.total + data.traits.intellect.total,
            jump: data.attributes.mobility.total + data.traits.agility.total,
            knowledge: data.attributes.mind.total + data.traits.intellect.total,
            openLock: data.attributes.mind.total + data.traits.dexterity.total,
            perception: Math.max(data.attributes.mind.total + data.traits.intellect.total, 8),
            pickPocket: data.attributes.mobility.total + data.traits.dexterity.total,
            readTracks: data.attributes.mind.total + data.traits.intellect.total,
            resistDisease: data.attributes.body.total + data.traits.constitution.total,
            ride: data.attributes.mobility.total + Math.max(data.traits.agility.total, data.traits.aura.total),
            search: Math.max(data.attributes.mind.total + data.traits.intellect.total, 8),
            senseMagic: data.attributes.mind.total + data.traits.aura.total,
            sneak: data.attributes.mobility.total + data.traits.agility.total,
            startFire: data.attributes.mind.total + data.traits.dexterity.total,
            swim: data.attributes.mobility.total + data.traits.strength.total,
            wakeUp: data.attributes.mind.total + data.traits.intellect.total,
            workMechanism:
                data.attributes.mind.total + Math.max(data.traits.dexterity.total, data.traits.intellect.total),
        };
    }

    /**
     * Handle how changes to a Token attribute bar are applied to the Actor.
     * This only differs from the base implementation by also allowing negative values.
     * @override
     */
    async modifyTokenAttribute(attribute: string, value: number, isDelta = false, isBar = true): Promise<this> {
        const current = getProperty(this.data.data, attribute);

        // Determine the updates to make to the actor data
        let updates: Record<string, number>;
        if (isBar) {
            if (isDelta) value = Math.min(Number(current.value) + value, current.max);
            updates = { [`data.${attribute}.value`]: value };
        } else {
            if (isDelta) value = Number(current) + value;
            updates = { [`data.${attribute}`]: value };
        }

        // Call a hook to handle token resource bar updates
        const allowed = Hooks.call("modifyTokenAttribute", { attribute, value, isDelta, isBar }, updates);
        return allowed !== false ? this.update(updates) : this;
    }

    /**
     * Roll for a given check.
     * @param check - The check to perform
     */
    async rollCheck(check: Check): Promise<void> {
        await createCheckRoll(this.data.data.checks[check], {
            rollMode: game.settings.get("core", "rollMode") as Const.DiceRollMode, // TODO(types): Type this setting in upstream
            maximumCoupResult: this.data.data.rolling.maximumCoupResult,
            minimumFumbleResult: this.data.data.rolling.minimumFumbleResult,
            flavor: game.i18n.format("DS4.ActorCheckFlavor", { actor: this.name, check: DS4.i18n.checks[check] }),
        });
    }

    /**
     * Roll a generic check. A dialog is presented to select the combination of
     * Attribute and Trait to perform the check against.
     */
    async rollGenericCheck(): Promise<void> {
        const { attribute, trait } = await this.selectAttributeAndTrait();
        const checkTargetNumber = this.data.data.attributes[attribute].total + this.data.data.traits[trait].total;
        await createCheckRoll(checkTargetNumber, {
            rollMode: game.settings.get("core", "rollMode") as Const.DiceRollMode, // TODO(types): Type this setting in upstream
            maximumCoupResult: this.data.data.rolling.maximumCoupResult,
            minimumFumbleResult: this.data.data.rolling.minimumFumbleResult,
            flavor: game.i18n.format("DS4.ActorGenericCheckFlavor", {
                actor: this.name,
                attribute: DS4.i18n.attributes[attribute],
                trait: DS4.i18n.traits[trait],
            }),
        });
    }

    protected async selectAttributeAndTrait(): Promise<{
        attribute: keyof typeof DS4.i18n.attributes;
        trait: keyof typeof DS4.i18n.traits;
    }> {
        const attributeIdentifier = "attribute-trait-selection-attribute";
        const traitIdentifier = "attribute-trait-selection-trait";
        return Dialog.prompt({
            title: game.i18n.localize("DS4.DialogAttributeTraitSelection"),
            content: await renderTemplate("systems/ds4/templates/dialogs/simple-select-form.hbs", {
                selects: [
                    {
                        label: game.i18n.localize("DS4.Attribute"),
                        identifier: attributeIdentifier,
                        options: DS4.i18n.attributes,
                    },
                    {
                        label: game.i18n.localize("DS4.Trait"),
                        identifier: traitIdentifier,
                        options: DS4.i18n.traits,
                    },
                ],
            }),
            label: game.i18n.localize("DS4.GenericOkButton"),
            callback: (html) => {
                const selectedAttribute = html.find(`#${attributeIdentifier}`).val();
                if (!isAttribute(selectedAttribute)) {
                    throw new Error(
                        game.i18n.format("DS4.ErrorUnexpectedAttribute", {
                            actualAttribute: selectedAttribute,
                            expectedTypes: Object.keys(DS4.i18n.attributes)
                                .map((attribute) => `'${attribute}'`)
                                .join(", "),
                        }),
                    );
                }
                const selectedTrait = html.find(`#${traitIdentifier}`).val();
                if (!isTrait(selectedTrait)) {
                    throw new Error(
                        game.i18n.format("DS4.ErrorUnexpectedTrait", {
                            actualTrait: selectedTrait,
                            expectedTypes: Object.keys(DS4.i18n.traits)
                                .map((attribute) => `'${attribute}'`)
                                .join(", "),
                        }),
                    );
                }
                return {
                    attribute: selectedAttribute,
                    trait: selectedTrait,
                };
            },
        });
    }
}