foundry-sw5e/module/item/sheet.js

import TraitSelector from "../apps/trait-selector.js";
import ActiveEffect5e from "../active-effect.js";

/**
 * Override and extend the core ItemSheet implementation to handle specific item types
 * @extends {ItemSheet}
 */
export default class ItemSheet5e extends ItemSheet {
    constructor(...args) {
        super(...args);

        // Expand the default size of the class sheet
        if (this.object.data.type === "class") {
            this.options.width = this.position.width = 600;
            this.options.height = this.position.height = 680;
        }
    }

    /* -------------------------------------------- */

    /** @inheritdoc */
    static get defaultOptions() {
        return foundry.utils.mergeObject(super.defaultOptions, {
            width: 560,
            height: 400,
            classes: ["sw5e", "sheet", "item"],
            resizable: true,
            scrollY: [".tab.details"],
            tabs: [{navSelector: ".tabs", contentSelector: ".sheet-body", initial: "description"}]
        });
    }

    /* -------------------------------------------- */

    /** @inheritdoc */
    get template() {
        const path = "systems/sw5e/templates/items/";
        return `${path}/${this.item.data.type}.html`;
    }

    /* -------------------------------------------- */

    /** @override */
    async getData(options) {
        const data = super.getData(options);
        const itemData = data.data;
        data.labels = this.item.labels;
        data.config = CONFIG.SW5E;

        // Item Type, Status, and Details
        data.itemType = game.i18n.localize(`ITEM.Type${data.item.type.titleCase()}`);
        data.itemStatus = this._getItemStatus(itemData);
        data.itemProperties = this._getItemProperties(itemData);
        data.isPhysical = itemData.data.hasOwnProperty("quantity");

        // Potential consumption targets
        data.abilityConsumptionTargets = this._getItemConsumptionTargets(itemData);

        // Action Details
        data.hasAttackRoll = this.item.hasAttack;
        data.isHealing = itemData.data.actionType === "heal";
        data.isFlatDC = getProperty(itemData, "data.save.scaling") === "flat";
        data.isLine = ["line", "wall"].includes(itemData.data.target?.type);

        // Original maximum uses formula
        const sourceMax = foundry.utils.getProperty(this.item.data._source, "data.uses.max");
        if (sourceMax) itemData.data.uses.max = sourceMax;

        // Vehicles
        data.isCrewed = itemData.data.activation?.type === "crew";
        data.isMountable = this._isItemMountable(itemData);

        // Armor Class
        data.isArmor = itemData.data.armor?.type in data.config.armorTypes;
        data.hasAC = data.isArmor || data.isMountable;

        // Prepare Active Effects
        data.effects = ActiveEffect5e.prepareActiveEffectCategories(this.item.effects);

        // Re-define the template data references (backwards compatible)
        data.item = itemData;
        data.data = itemData.data;
        return data;
    }

    /* -------------------------------------------- */

    /**
     * Get the valid item consumption targets which exist on the actor
     * @param {Object} item         Item data for the item being displayed
     * @return {{string: string}}   An object of potential consumption targets
     * @private
     */
    _getItemConsumptionTargets(item) {
        const consume = item.data.consume || {};
        if (!consume.type) return [];
        const actor = this.item.actor;
        if (!actor) return {};

        // Ammunition
        if (consume.type === "ammo") {
            return actor.itemTypes.consumable.reduce(
                (ammo, i) => {
                    if (i.data.data.consumableType === "ammo") {
                        ammo[i.id] = `${i.name} (${i.data.data.quantity})`;
                    }
                    return ammo;
                },
                {[item._id]: `${item.name} (${item.data.quantity})`}
            );
        }

        // Attributes
        else if (consume.type === "attribute") {
            const attributes = TokenDocument.getTrackedAttributes(actor.data.data);
            attributes.bar.forEach((a) => a.push("value"));
            return attributes.bar.concat(attributes.value).reduce((obj, a) => {
                let k = a.join(".");
                obj[k] = k;
                return obj;
            }, {});
        }

        // Materials
        else if (consume.type === "material") {
            return actor.items.reduce((obj, i) => {
                if (["consumable", "loot"].includes(i.data.type) && !i.data.data.activation) {
                    obj[i.id] = `${i.name} (${i.data.data.quantity})`;
                }
                return obj;
            }, {});
        }

        // Charges
        else if (consume.type === "charges") {
            return actor.items.reduce((obj, i) => {
                // Limited-use items
                const uses = i.data.data.uses || {};
                if (uses.per && uses.max) {
                    const label =
                        uses.per === "charges"
                            ? ` (${game.i18n.format("SW5E.AbilityUseChargesLabel", {value: uses.value})})`
                            : ` (${game.i18n.format("SW5E.AbilityUseConsumableLabel", {
                                  max: uses.max,
                                  per: uses.per
                              })})`;
                    obj[i.id] = i.name + label;
                }

                // Recharging items
                const recharge = i.data.data.recharge || {};
                if (recharge.value) obj[i.id] = `${i.name} (${game.i18n.format("SW5E.Recharge")})`;
                return obj;
            }, {});
        } else return {};
    }

    /* -------------------------------------------- */

    /**
     * Get the text item status which is shown beneath the Item type in the top-right corner of the sheet
     * @return {string}
     * @private
     */
    _getItemStatus(item) {
        if (item.type === "power") {
            return CONFIG.SW5E.powerPreparationModes[item.data.preparation];
        } else if (["weapon", "equipment"].includes(item.type)) {
            return game.i18n.localize(item.data.equipped ? "SW5E.Equipped" : "SW5E.Unequipped");
        } else if (item.type === "tool") {
            return game.i18n.localize(item.data.proficient ? "SW5E.Proficient" : "SW5E.NotProficient");
        }
    }

    /* -------------------------------------------- */

    /**
     * Get the Array of item properties which are used in the small sidebar of the description tab
     * @return {Array}
     * @private
     */
    _getItemProperties(item) {
        const props = [];
        const labels = this.item.labels;

        if (item.type === "weapon") {
            props.push(
                ...Object.entries(item.data.properties)
                    .filter((e) => e[1] === true)
                    .map((e) => CONFIG.SW5E.weaponProperties[e[0]])
            );
        } else if (item.type === "power") {
            props.push(
                labels.materials,
                item.data.components.concentration ? game.i18n.localize("SW5E.Concentration") : null,
                item.data.components.ritual ? game.i18n.localize("SW5E.Ritual") : null
            );
        } else if (item.type === "equipment") {
            props.push(CONFIG.SW5E.equipmentTypes[item.data.armor.type]);
            props.push(labels.armor);
        } else if (item.type === "feat") {
            props.push(labels.featType);
            //TODO: Work out these
        } else if (item.type === "species") {
            //props.push(labels.species);
        } else if (item.type === "archetype") {
            //props.push(labels.archetype);
        } else if (item.type === "background") {
            //props.push(labels.background);
        } else if (item.type === "classfeature") {
            //props.push(labels.classfeature);
        } else if (item.type === "deployment") {
            //props.push(labels.deployment);
        } else if (item.type === "venture") {
            //props.push(labels.venture);
        } else if (item.type === "fightingmastery") {
            //props.push(labels.fightingmastery);
        } else if (item.type === "fightingstyle") {
            //props.push(labels.fightingstyle);
        } else if (item.type === "lightsaberform") {
            //props.push(labels.lightsaberform);
        }

        // Action type
        if (item.data.actionType) {
            props.push(CONFIG.SW5E.itemActionTypes[item.data.actionType]);
        }

        // Action usage
        if (item.type !== "weapon" && item.data.activation && !isObjectEmpty(item.data.activation)) {
            props.push(labels.activation, labels.range, labels.target, labels.duration);
        }
        return props.filter((p) => !!p);
    }

    /* -------------------------------------------- */

    /**
     * Is this item a separate large object like a siege engine or vehicle
     * component that is usually mounted on fixtures rather than equipped, and
     * has its own AC and HP.
     * @param item
     * @returns {boolean}
     * @private
     */
    _isItemMountable(item) {
        const data = item.data;
        return (
            (item.type === "weapon" && data.weaponType === "siege") ||
            (item.type === "equipment" && data.armor.type === "vehicle")
        );
    }

    /* -------------------------------------------- */

    /** @inheritdoc */
    setPosition(position = {}) {
        if (!(this._minimized || position.height)) {
            position.height = this._tabs[0].active === "details" ? "auto" : this.options.height;
        }
        return super.setPosition(position);
    }

    /* -------------------------------------------- */
    /*  Form Submission                             */
    /* -------------------------------------------- */

    /** @inheritdoc */
    _getSubmitData(updateData = {}) {
        // Create the expanded update data object
        const fd = new FormDataExtended(this.form, {editors: this.editors});
        let data = fd.toObject();
        if (updateData) data = mergeObject(data, updateData);
        else data = expandObject(data);

        // Handle Damage array
        const damage = data.data?.damage;
        if (damage) damage.parts = Object.values(damage?.parts || {}).map((d) => [d[0] || "", d[1] || ""]);

        // Return the flattened submission data
        return flattenObject(data);
    }

    /* -------------------------------------------- */

    /** @inheritdoc */
    activateListeners(html) {
        super.activateListeners(html);
        if (this.isEditable) {
            html.find(".damage-control").click(this._onDamageControl.bind(this));
            html.find(".trait-selector.class-skills").click(this._onConfigureTraits.bind(this));
            html.find(".effect-control").click((ev) => {
                if (this.item.isOwned)
                    return ui.notifications.warn(
                        "Managing Active Effects within an Owned Item is not currently supported and will be added in a subsequent update."
                    );
                onManageActiveEffect(ev, this.item);
            });
        }
    }

    /* -------------------------------------------- */

    /**
     * Add or remove a damage part from the damage formula
     * @param {Event} event     The original click event
     * @return {Promise}
     * @private
     */
    async _onDamageControl(event) {
        event.preventDefault();
        const a = event.currentTarget;

        // Add new damage component
        if (a.classList.contains("add-damage")) {
            await this._onSubmit(event); // Submit any unsaved changes
            const damage = this.item.data.data.damage;
            return this.item.update({"data.damage.parts": damage.parts.concat([["", ""]])});
        }

        // Remove a damage component
        if (a.classList.contains("delete-damage")) {
            await this._onSubmit(event); // Submit any unsaved changes
            const li = a.closest(".damage-part");
            const damage = foundry.utils.deepClone(this.item.data.data.damage);
            damage.parts.splice(Number(li.dataset.damagePart), 1);
            return this.item.update({"data.damage.parts": damage.parts});
        }
    }

    /* -------------------------------------------- */

    /**
     * Handle spawning the TraitSelector application for selection various options.
     * @param {Event} event   The click event which originated the selection
     * @private
     */
    _onConfigureTraits(event) {
        event.preventDefault();
        const a = event.currentTarget;

        const options = {
            name: a.dataset.target,
            title: a.parentElement.innerText,
            choices: [],
            allowCustom: false
        };

        switch (a.dataset.options) {
            case "saves":
                options.choices = CONFIG.SW5E.abilities;
                options.valueKey = null;
                break;
            case "skills.choices":
                options.choices = CONFIG.SW5E.skills;
                options.valueKey = null;
                break;
            case "skills":
                const skills = this.item.data.data.skills;
                const choiceSet = skills.choices?.length ? skills.choices : Object.keys(CONFIG.SW5E.skills);
                options.choices = Object.fromEntries(
                    Object.entries(CONFIG.SW5E.skills).filter(([skill]) => choiceSet.includes(skill))
                );
                options.maximum = skills.number;
                break;
        }
        new TraitSelector(this.item, options).render(true);
    }

    /* -------------------------------------------- */

    /** @inheritdoc */
    async _onSubmit(...args) {
        if (this._tabs[0].active === "details") this.position.height = "auto";
        await super._onSubmit(...args);
    }
}