Added homebrew for armor and weapon fatures (#1166)

Co-authored-by: Chris Ryan <chrisr@blackhole>

module/applications/sheets-configs/_module.mjs

@@ -2,7 +2,8 @@ export { default as ActionConfig } from './action-config.mjs';
 export { default as CharacterSettings } from './character-settings.mjs';
 export { default as AdversarySettings } from './adversary-settings.mjs';
 export { default as CompanionSettings } from './companion-settings.mjs';
-export { default as DowntimeConfig } from './downtimeConfig.mjs';
+export { default as SettingActiveEffectConfig } from './setting-active-effect-config.mjs';
+export { default as SettingFeatureConfig } from './setting-feature-config.mjs';
 export { default as EnvironmentSettings } from './environment-settings.mjs';
 export { default as ActiveEffectConfig } from './activeEffectConfig.mjs';
 export { default as DhTokenConfig } from './token-config.mjs';

module/applications/sheets-configs/action-config.mjs

@@ -138,7 +138,7 @@ export default class DHActionConfig extends DaggerheartSheet(ApplicationV2) {
             };
         }
 
-        if (this.action.parent.metadata.isQuantifiable) {
+        if (this.action.parent.metadata?.isQuantifiable) {
             options.quantity = {
                 label: 'DAGGERHEART.GENERAL.itemQuantity',
                 group: 'Global'

module/applications/sheets-configs/activeEffectConfig.mjs

@@ -96,6 +96,13 @@ export default class DhActiveEffectConfig extends foundry.applications.sheets.Ac
         });
     }
 
+    async _prepareContext(options) {
+        const context = await super._prepareContext(options);
+        context.systemFields = context.document.system.schema.fields;
+
+        return context;
+    }
+
     async _preparePartContext(partId, context) {
         const partContext = await super._preparePartContext(partId, context);
         switch (partId) {

module/applications/sheets-configs/setting-active-effect-config.mjs

@@ -0,0 +1,227 @@
+import autocomplete from 'autocompleter';
+
+const { HandlebarsApplicationMixin, ApplicationV2 } = foundry.applications.api;
+
+export default class SettingActiveEffectConfig extends HandlebarsApplicationMixin(ApplicationV2) {
+    constructor(effect) {
+        super({});
+
+        this.effect = foundry.utils.deepClone(effect);
+        const ignoredActorKeys = ['config', 'DhEnvironment'];
+        this.changeChoices = Object.keys(game.system.api.models.actors).reduce((acc, key) => {
+            if (!ignoredActorKeys.includes(key)) {
+                const model = game.system.api.models.actors[key];
+                const attributes = CONFIG.Token.documentClass.getTrackedAttributes(model);
+                const group = game.i18n.localize(model.metadata.label);
+                const choices = CONFIG.Token.documentClass
+                    .getTrackedAttributeChoices(attributes, model)
+                    .map(x => ({ ...x, group: group }));
+                acc.push(...choices);
+            }
+            return acc;
+        }, []);
+    }
+
+    static DEFAULT_OPTIONS = {
+        classes: ['daggerheart', 'sheet', 'dh-style', 'active-effect-config'],
+        tag: 'form',
+        position: {
+            width: 560
+        },
+        form: {
+            submitOnChange: false,
+            closeOnSubmit: false,
+            handler: SettingActiveEffectConfig.#onSubmit
+        },
+        actions: {
+            editImage: SettingActiveEffectConfig.#editImage,
+            addChange: SettingActiveEffectConfig.#addChange,
+            deleteChange: SettingActiveEffectConfig.#deleteChange
+        }
+    };
+
+    static PARTS = {
+        header: { template: 'systems/daggerheart/templates/sheets/activeEffect/header.hbs' },
+        tabs: { template: 'templates/generic/tab-navigation.hbs' },
+        details: { template: 'systems/daggerheart/templates/sheets/activeEffect/details.hbs', scrollable: [''] },
+        settings: { template: 'systems/daggerheart/templates/sheets/activeEffect/settings.hbs' },
+        changes: {
+            template: 'systems/daggerheart/templates/sheets/activeEffect/changes.hbs',
+            scrollable: ['ol[data-changes]']
+        },
+        footer: { template: 'systems/daggerheart/templates/sheets/global/tabs/tab-form-footer.hbs' }
+    };
+
+    static TABS = {
+        sheet: {
+            tabs: [
+                { id: 'details', icon: 'fa-solid fa-book' },
+                { id: 'settings', icon: 'fa-solid fa-bars', label: 'DAGGERHEART.GENERAL.Tabs.settings' },
+                { id: 'changes', icon: 'fa-solid fa-gears' }
+            ],
+            initial: 'details',
+            labelPrefix: 'EFFECT.TABS'
+        }
+    };
+
+    /**@inheritdoc */
+    async _onFirstRender(context, options) {
+        await super._onFirstRender(context, options);
+    }
+
+    async _prepareContext(_options) {
+        const context = await super._prepareContext(_options);
+        context.source = this.effect;
+        context.fields = game.system.api.documents.DhActiveEffect.schema.fields;
+        context.systemFields = game.system.api.data.activeEffects.BaseEffect._schema.fields;
+
+        return context;
+    }
+
+    _attachPartListeners(partId, htmlElement, options) {
+        super._attachPartListeners(partId, htmlElement, options);
+        const changeChoices = this.changeChoices;
+
+        htmlElement.querySelectorAll('.effect-change-input').forEach(element => {
+            autocomplete({
+                input: element,
+                fetch: function (text, update) {
+                    if (!text) {
+                        update(changeChoices);
+                    } else {
+                        text = text.toLowerCase();
+                        var suggestions = changeChoices.filter(n => n.label.toLowerCase().includes(text));
+                        update(suggestions);
+                    }
+                },
+                render: function (item, search) {
+                    const label = game.i18n.localize(item.label);
+                    const matchIndex = label.toLowerCase().indexOf(search);
+
+                    const beforeText = label.slice(0, matchIndex);
+                    const matchText = label.slice(matchIndex, matchIndex + search.length);
+                    const after = label.slice(matchIndex + search.length, label.length);
+
+                    const element = document.createElement('li');
+                    element.innerHTML = `${beforeText}${matchText ? `<strong>${matchText}</strong>` : ''}${after}`;
+                    if (item.hint) {
+                        element.dataset.tooltip = game.i18n.localize(item.hint);
+                    }
+
+                    return element;
+                },
+                renderGroup: function (label) {
+                    const itemElement = document.createElement('div');
+                    itemElement.textContent = game.i18n.localize(label);
+                    return itemElement;
+                },
+                onSelect: function (item) {
+                    element.value = `system.${item.value}`;
+                },
+                click: e => e.fetch(),
+                customize: function (_input, _inputRect, container) {
+                    container.style.zIndex = foundry.applications.api.ApplicationV2._maxZ;
+                },
+                minLength: 0
+            });
+        });
+    }
+
+    async _preparePartContext(partId, context) {
+        if (partId in context.tabs) context.tab = context.tabs[partId];
+        switch (partId) {
+            case 'details':
+                context.isActorEffect = false;
+                context.isItemEffect = true;
+                const useGeneric = game.settings.get(
+                    CONFIG.DH.id,
+                    CONFIG.DH.SETTINGS.gameSettings.appearance
+                ).showGenericStatusEffects;
+                if (!useGeneric) {
+                    context.statuses = Object.values(CONFIG.DH.GENERAL.conditions).map(status => ({
+                        value: status.id,
+                        label: game.i18n.localize(status.name)
+                    }));
+                }
+                break;
+            case 'changes':
+                context.modes = Object.entries(CONST.ACTIVE_EFFECT_MODES).reduce((modes, [key, value]) => {
+                    modes[value] = game.i18n.localize(`EFFECT.MODE_${key}`);
+                    return modes;
+                }, {});
+
+                context.priorities = ActiveEffectConfig.DEFAULT_PRIORITIES;
+                break;
+        }
+
+        return context;
+    }
+
+    static async #onSubmit(event, form, formData) {
+        this.data = foundry.utils.expandObject(formData.object);
+        this.close();
+    }
+
+    /**
+     * Edit a Document image.
+     * @this {DocumentSheetV2}
+     * @type {ApplicationClickAction}
+     */
+    static async #editImage(_event, target) {
+        if (target.nodeName !== 'IMG') {
+            throw new Error('The editImage action is available only for IMG elements.');
+        }
+
+        const attr = target.dataset.edit;
+        const current = foundry.utils.getProperty(this.effect, attr);
+        const fp = new FilePicker.implementation({
+            current,
+            type: 'image',
+            callback: path => (target.src = path),
+            position: {
+                top: this.position.top + 40,
+                left: this.position.left + 10
+            }
+        });
+
+        await fp.browse();
+    }
+
+    /**
+     * Add a new change to the effect's changes array.
+     * @this {ActiveEffectConfig}
+     * @type {ApplicationClickAction}
+     */
+    static async #addChange() {
+        const submitData = foundry.utils.expandObject(new FormDataExtended(this.form).object);
+        const changes = Object.values(submitData.changes ?? {});
+        changes.push({});
+
+        this.effect.changes = changes;
+        this.render();
+    }
+
+    /**
+     * Delete a change from the effect's changes array.
+     * @this {ActiveEffectConfig}
+     * @type {ApplicationClickAction}
+     */
+    static async #deleteChange(event) {
+        const submitData = foundry.utils.expandObject(new FormDataExtended(this.form).object);
+        const changes = Object.values(submitData.changes);
+        const row = event.target.closest('li');
+        const index = Number(row.dataset.index) || 0;
+        changes.splice(index, 1);
+
+        this.effect.changes = changes;
+        this.render();
+    }
+
+    static async configure(effect, options = {}) {
+        return new Promise(resolve => {
+            const app = new this(effect, options);
+            app.addEventListener('close', () => resolve(app.data), { once: true });
+            app.render({ force: true });
+        });
+    }
+}

module/applications/sheets-configs/setting-feature-config.mjs

@@ -3,8 +3,8 @@ import DHActionConfig from './action-config.mjs';
 
 const { HandlebarsApplicationMixin, ApplicationV2 } = foundry.applications.api;
 
-export default class DowntimeConfig extends HandlebarsApplicationMixin(ApplicationV2) {
-    constructor(move, movePath, settings, options) {
+export default class SettingFeatureConfig extends HandlebarsApplicationMixin(ApplicationV2) {
+    constructor(move, movePath, settings, optionalParts, options) {
         super(options);
 
         this.move = move;
@@ -12,6 +12,10 @@ export default class DowntimeConfig extends HandlebarsApplicationMixin(Applicati
         this.movePath = movePath;
         this.actionsPath = `${movePath}.actions`;
         this.settings = settings;
+
+        const { hasIcon, hasEffects } = optionalParts;
+        this.hasIcon = hasIcon;
+        this.hasEffects = hasEffects;
     }
 
     get title() {
@@ -30,6 +34,7 @@ export default class DowntimeConfig extends HandlebarsApplicationMixin(Applicati
             addItem: this.addItem,
             editItem: this.editItem,
             removeItem: this.removeItem,
+            addEffect: this.addEffect,
             resetMoves: this.resetMoves,
             saveForm: this.saveForm
         },
@@ -41,13 +46,14 @@ export default class DowntimeConfig extends HandlebarsApplicationMixin(Applicati
         tabs: { template: 'systems/daggerheart/templates/sheets/global/tabs/tab-navigation.hbs' },
         main: { template: 'systems/daggerheart/templates/settings/downtime-config/main.hbs' },
         actions: { template: 'systems/daggerheart/templates/settings/downtime-config/actions.hbs' },
+        effects: { template: 'systems/daggerheart/templates/settings/downtime-config/effects.hbs' },
         footer: { template: 'systems/daggerheart/templates/settings/downtime-config/footer.hbs' }
     };
 
     /** @inheritdoc */
     static TABS = {
         primary: {
-            tabs: [{ id: 'main' }, { id: 'actions' }],
+            tabs: [{ id: 'main' }, { id: 'actions' }, { id: 'effects' }],
             initial: 'main',
             labelPrefix: 'DAGGERHEART.GENERAL.Tabs'
         }
@@ -55,6 +61,9 @@ export default class DowntimeConfig extends HandlebarsApplicationMixin(Applicati
 
     async _prepareContext(_options) {
         const context = await super._prepareContext(_options);
+        context.tabs = this._filterTabs(context.tabs);
+        context.hasIcon = this.hasIcon;
+        context.hasEffects = this.hasEffects;
         context.move = this.move;
         context.move.enrichedDescription = await foundry.applications.ux.TextEditor.enrichHTML(
             context.move.description
@@ -130,13 +139,30 @@ export default class DowntimeConfig extends HandlebarsApplicationMixin(Applicati
     }
 
     static async editItem(_, target) {
-        const actionId = target.dataset.id;
-        const action = this.move.actions.get(actionId);
-        await new DHActionConfig(action, async updatedMove => {
-            await this.settings.updateSource({ [`${this.actionsPath}.${actionId}`]: updatedMove });
+        const { type, id } = target.dataset;
+        if (type === 'effect') {
+            const effectIndex = this.move.effects.findIndex(x => x.id === id);
+            const effect = this.move.effects[effectIndex];
+            const updatedEffect =
+                await game.system.api.applications.sheetConfigs.SettingActiveEffectConfig.configure(effect);
+            if (!updatedEffect) return;
+
+            await this.settings.updateSource({
+                [`${this.movePath}.effects`]: this.move.effects.reduce((acc, effect, index) => {
+                    acc.push(index === effectIndex ? { ...updatedEffect, id: effect.id } : effect);
+                    return acc;
+                }, [])
+            });
             this.move = foundry.utils.getProperty(this.settings, this.movePath);
             this.render();
-        }).render(true);
+        } else {
+            const action = this.move.actions.get(id);
+            await new DHActionConfig(action, async updatedMove => {
+                await this.settings.updateSource({ [`${this.actionsPath}.${id}`]: updatedMove });
+                this.move = foundry.utils.getProperty(this.settings, this.movePath);
+                this.render();
+            }).render(true);
+        }
     }
 
     static async removeItem(_, target) {
@@ -145,16 +171,38 @@ export default class DowntimeConfig extends HandlebarsApplicationMixin(Applicati
         this.render();
     }
 
+    static async addEffect(_, target) {
+        const currentEffects = foundry.utils.getProperty(this.settings, `${this.movePath}.effects`);
+        await this.settings.updateSource({
+            [`${this.movePath}.effects`]: [
+                ...currentEffects,
+                game.system.api.data.activeEffects.BaseEffect.getDefaultObject()
+            ]
+        });
+
+        this.move = foundry.utils.getProperty(this.settings, this.movePath);
+        this.render();
+    }
+
     static resetMoves() {}
 
+    _filterTabs(tabs) {
+        return this.hasEffects
+            ? tabs
+            : Object.keys(tabs).reduce((acc, key) => {
+                  if (key !== 'effects') acc[key] = tabs[key];
+                  return acc;
+              }, {});
+    }
+
     /** @override */
     _onClose(options = {}) {
         if (!options.submitted) this.move = null;
     }
 
-    static async configure(move, movePath, settings, options = {}) {
+    static async configure(move, movePath, settings, optionalParts, options = {}) {
         return new Promise(resolve => {
-            const app = new this(move, movePath, settings, options);
+            const app = new this(move, movePath, settings, optionalParts, options);
             app.addEventListener('close', () => resolve(app.move), { once: true });
             app.render({ force: true });
         });