REFACTOR: rename folder data/items -> data/item

REFACTOR: rename folder `data/messages` -> `data/chat-message`.
2026-01-12 11:41:08 +01:00 · 2025-06-02 18:00:04 -03:00 · 2025-06-02 18:00:04 -03:00 · 08a21dcb2f
commit 08a21dcb2f
parent a6acbe750a
19 changed files with 25 additions and 16 deletions
--- a/module/data/item/feature.mjs
+++ b/module/data/item/feature.mjs
@ -0,0 +1,141 @@
+import { getTier } from '../../helpers/utils.mjs';
+import DaggerheartAction from '../action.mjs';
+import BaseDataItem from './base.mjs';
+
+export default class DHFeature extends BaseDataItem {
+    /** @inheritDoc */
+    static get metadata() {
+        return foundry.utils.mergeObject(super.metadata, {
+            label: "TYPES.Item.feature",
+            type: "feature",
+            hasDescription: true,
+        });
+    }
+
+    /** @inheritDoc */
+    static defineSchema() {
+        const fields = foundry.data.fields;
+        return {
+            ...super.defineSchema(),
+            type: new fields.StringField({ choices: SYSTEM.ITEM.featureTypes }),
+            actionType: new fields.StringField({
+                choices: SYSTEM.ITEM.actionTypes,
+                initial: SYSTEM.ITEM.actionTypes.passive.id
+            }),
+            featureType: new fields.SchemaField({
+                type: new fields.StringField({
+                    choices: SYSTEM.ITEM.valueTypes,
+                    initial: Object.keys(SYSTEM.ITEM.valueTypes).find(x => x === 'normal')
+                }),
+                data: new fields.SchemaField({
+                    value: new fields.StringField({}),
+                    property: new fields.StringField({
+                        choices: SYSTEM.ACTOR.featureProperties,
+                        initial: Object.keys(SYSTEM.ACTOR.featureProperties).find(x => x === 'spellcastingTrait')
+                    }),
+                    max: new fields.NumberField({ initial: 1, integer: true }),
+                    numbers: new fields.TypedObjectField(
+                        new fields.SchemaField({
+                            value: new fields.NumberField({ integer: true }),
+                            used: new fields.BooleanField({ initial: false })
+                        })
+                    )
+                })
+            }),
+            refreshData: new fields.SchemaField(
+                {
+                    type: new fields.StringField({ choices: SYSTEM.GENERAL.refreshTypes }),
+                    uses: new fields.NumberField({ initial: 1, integer: true }),
+                    refreshed: new fields.BooleanField({ initial: true })
+                },
+                { nullable: true, initial: null }
+            ),
+            multiclass: new fields.NumberField({ initial: null, nullable: true, integer: true }),
+            disabled: new fields.BooleanField({ initial: false }),
+            effects: new fields.TypedObjectField(
+                new fields.SchemaField({
+                    type: new fields.StringField({ choices: SYSTEM.EFFECTS.effectTypes }),
+                    valueType: new fields.StringField({ choices: SYSTEM.EFFECTS.valueTypes }),
+                    parseType: new fields.StringField({ choices: SYSTEM.EFFECTS.parseTypes }),
+                    initiallySelected: new fields.BooleanField({ initial: true }),
+                    options: new fields.ArrayField(
+                        new fields.SchemaField({
+                            name: new fields.StringField({}),
+                            value: new fields.StringField({})
+                        }),
+                        { nullable: true, initial: null }
+                    ),
+                    dataField: new fields.StringField({}),
+                    appliesOn: new fields.StringField({
+                        choices: SYSTEM.EFFECTS.applyLocations,
+                    },
+                        { nullable: true, initial: null }
+                    ),
+                    applyLocationChoices: new fields.TypedObjectField(new fields.StringField({}), {
+                        nullable: true,
+                        initial: null
+                    }),
+                    valueData: new fields.SchemaField({
+                        value: new fields.StringField({}),
+                        fromValue: new fields.StringField({ initial: null, nullable: true }),
+                        type: new fields.StringField({ initial: null, nullable: true }),
+                        hopeIncrease: new fields.StringField({ initial: null, nullable: true })
+                    })
+                })
+            ),
+            actions: new fields.ArrayField(new fields.EmbeddedDataField(DaggerheartAction))
+        };
+    }
+
+    get multiclassTier() {
+        return getTier(this.multiclass);
+    }
+
+    async refresh() {
+        if (this.refreshData) {
+            if (this.featureType.type === SYSTEM.ITEM.valueTypes.dice.id) {
+                const update = { 'system.refreshData.refreshed': true };
+                Object.keys(this.featureType.data.numbers).forEach(
+                    x => (update[`system.featureType.data.numbers.-=${x}`] = null)
+                );
+                await this.parent.update(update);
+            } else {
+                await this.parent.update({ 'system.refreshData.refreshed': true });
+            }
+        }
+    }
+
+    get effectData() {
+        const effectValues = Object.values(this.effects);
+        const effectCategories = Object.keys(SYSTEM.EFFECTS.effectTypes).reduce((acc, effectType) => {
+            acc[effectType] = effectValues.reduce((acc, effect) => {
+                if (effect.type === effectType) {
+                    acc.push({ ...effect, valueData: this.#parseValues(effect.parseType, effect.valueData) });
+                }
+
+                return acc;
+            }, []);
+
+            return acc;
+        }, {});
+
+        return effectCategories;
+    }
+
+    #parseValues(parseType, values) {
+        return Object.keys(values).reduce((acc, prop) => {
+            acc[prop] = this.#parseValue(parseType, values[prop]);
+
+            return acc;
+        }, {});
+    }
+
+    #parseValue(parseType, value) {
+        switch (parseType) {
+            case SYSTEM.EFFECTS.parseTypes.number.id:
+                return Number.parseInt(value);
+            default:
+                return value;
+        }
+    }
+}