Feature/112 items use action datamodel (#194)

* Fix action for items

* Cost & Range #1

* remove log

* actions

* Split methods

* Roll classes

* Begin damage

* g

* Actions

* before main merge

* Fix d20RollDialog costs check

* Fix submit on close

* Add uses in action dialog

* Adversary Attack

* 166 - Damage Reduction (#180)

* Temp

* Fixed Stress Reductions

* Changed from index based to object

* Fixed stress resources management for DamageReduction

* Fix Adversary attack multiplier

* Auto add Attack action to newly created weapon

* Few fixes

* 164 - Add Hope/Fear formula

* 163 - Actor Sub Datas (#182)

* Added rules/bonuses for all classes and subclasses

* More

* Add Save

* Fix delete action button

---------

Co-authored-by: WBHarry <williambjrklund@gmail.com>
Co-authored-by: WBHarry <89362246+WBHarry@users.noreply.github.com>

module/data/action/_module.mjs

@@ -5,16 +5,16 @@ import {
     DHEffectAction,
     DHHealingAction,
     DHMacroAction,
-    DHResourceAction,
-    DHSpellCastAction,
+    // DHResourceAction,
+    // DHSpellCastAction,
     DHSummonAction
 } from './action.mjs';
 
 export const actionsTypes = {
     base: DHBaseAction,
     attack: DHAttackAction,
-    spellcast: DHSpellCastAction,
-    resource: DHResourceAction,
+    // spellcast: DHSpellCastAction,
+    // resource: DHResourceAction,
     damage: DHDamageAction,
     healing: DHHealingAction,
     summon: DHSummonAction,

module/data/action/action.mjs

@@ -1,64 +1,38 @@
-import { abilities } from '../../config/actorConfig.mjs';
+import CostSelectionDialog from '../../applications/costSelectionDialog.mjs';
 import { DHActionDiceData, DHDamageData, DHDamageField } from './actionDice.mjs';
-
-export default class DHAction extends foundry.abstract.DataModel {
-    static defineSchema() {
-        const fields = foundry.data.fields;
-        return {
-            id: new fields.DocumentIdField(),
-            name: new fields.StringField({ initial: 'New Action' }),
-            damage: new fields.SchemaField({
-                type: new fields.StringField({ choices: SYSTEM.GENERAL.damageTypes, nullable: true, initial: null }),
-                value: new fields.StringField({})
-            }),
-            healing: new fields.SchemaField({
-                type: new fields.StringField({ choices: SYSTEM.GENERAL.healingTypes, nullable: true, initial: null }),
-                value: new fields.StringField()
-            }),
-            conditions: new fields.ArrayField(
-                new fields.SchemaField({
-                    name: new fields.StringField(),
-                    icon: new fields.StringField(),
-                    description: new fields.StringField()
-                })
-            ),
-            cost: new fields.SchemaField({
-                type: new fields.StringField({ choices: SYSTEM.GENERAL.abilityCosts, nullable: true, initial: null }),
-                value: new fields.NumberField({ nullable: true, initial: null })
-            }),
-            target: new fields.SchemaField({
-                type: new fields.StringField({
-                    choices: SYSTEM.ACTIONS.targetTypes,
-                    initial: SYSTEM.ACTIONS.targetTypes.other.id
-                })
-            })
-        };
-    }
-}
+import DhpActor from '../../documents/actor.mjs';
+import D20RollDialog from '../../dialogs/d20RollDialog.mjs';
 
 const fields = foundry.data.fields;
 
+/*
+    !!! I'm currently refactoring the whole Action thing, it's a WIP !!!
+*/
+
 /*
     ToDo
-    - Apply ActiveEffect => Add to Chat message like Damage Button ?
-    - Add Drag & Drop for documentUUID field (Macro & Summon)
-    - Add optionnal Role for Healing ?
-    - Handle Roll result as part of formula if needed
-    - Target Check
-    - Cost Check
+    - Add setting and/or checkbox for cost and damage like
+    - Target Check / Target Picker
     - Range Check
     - Area of effect and measurement placement
-    - Auto use costs and action
+    - Summon Action create method
+
+    Other
+    - Auto use action   <= Into Roll
 */
 
 export class DHBaseAction extends foundry.abstract.DataModel {
+    static extraSchemas = [];
+
     static defineSchema() {
         return {
             _id: new fields.DocumentIdField(),
             systemPath: new fields.StringField({ required: true, initial: 'actions' }),
             type: new fields.StringField({ initial: undefined, readonly: true, required: true }),
             name: new fields.StringField({ initial: undefined }),
+            description: new fields.HTMLField(),
             img: new fields.FilePathField({ initial: undefined, categories: ['IMAGE'], base64: false }),
+            chatDisplay: new fields.BooleanField({ initial: true, label: 'Display in chat' }),
             actionType: new fields.StringField({ choices: SYSTEM.ITEM.actionTypes, initial: 'action', nullable: true }),
             cost: new fields.ArrayField(
                 new fields.SchemaField({
@@ -84,35 +58,85 @@ export class DHBaseAction extends foundry.abstract.DataModel {
             }),
             range: new fields.StringField({
                 choices: SYSTEM.GENERAL.range,
-                required: true,
-                blank: false,
-                initial: 'self'
-            })
+                required: false,
+                blank: true
+                // initial: null
+            }),
+            ...this.defineExtraSchema()
         };
     }
 
+    static defineExtraSchema() {
+        const extraFields = {
+                damage: new DHDamageField(),
+                roll: new fields.SchemaField({
+                    type: new fields.StringField({ nullable: true, initial: null, choices: SYSTEM.GENERAL.rollTypes }),
+                    trait: new fields.StringField({ nullable: true, initial: null, choices: SYSTEM.ACTOR.abilities }),
+                    difficulty: new fields.NumberField({ nullable: true, initial: null, integer: true, min: 0 }),
+                    bonus: new fields.NumberField({ nullable: true, initial: null, integer: true, min: 0 })
+                }),
+                save: new fields.SchemaField({
+                    trait: new fields.StringField({ nullable: true, initial: null, choices: SYSTEM.ACTOR.abilities }),
+                    difficulty: new fields.NumberField({ nullable: true, initial: 10, integer: true, min: 0 }),
+                    damageMod: new fields.StringField({ initial: SYSTEM.ACTIONS.damageOnSave.none.id, choices: SYSTEM.ACTIONS.damageOnSave })
+                }),
+                target: new fields.SchemaField({
+                    type: new fields.StringField({
+                        choices: SYSTEM.ACTIONS.targetTypes,
+                        initial: SYSTEM.ACTIONS.targetTypes.any.id,
+                        nullable: true,
+                        initial: null
+                    }),
+                    amount: new fields.NumberField({ nullable: true, initial: null, integer: true, min: 0 })
+                }),
+                effects: new fields.ArrayField( // ActiveEffect
+                    new fields.SchemaField({
+                        _id: new fields.DocumentIdField(),
+                        onSave: new fields.BooleanField({ initial: false })
+                    })
+                ),
+                healing: new fields.SchemaField({
+                    type: new fields.StringField({
+                        choices: SYSTEM.GENERAL.healingTypes,
+                        required: true,
+                        blank: false,
+                        initial: SYSTEM.GENERAL.healingTypes.hitPoints.id,
+                        label: 'Healing'
+                    }),
+                    resultBased: new fields.BooleanField({ initial: false, label: "DAGGERHEART.Actions.Settings.ResultBased.label" }),
+                    value: new fields.EmbeddedDataField(DHActionDiceData),
+                    valueAlt: new fields.EmbeddedDataField(DHActionDiceData),
+                })
+            },
+            extraSchemas = {};
+
+        this.extraSchemas.forEach(s => (extraSchemas[s] = extraFields[s]));
+        return extraSchemas;
+    }
+
     prepareData() {}
 
     get index() {
         return foundry.utils.getProperty(this.parent, this.systemPath).indexOf(this);
     }
 
+    get id() {
+        return this._id;
+    }
+
     get item() {
         return this.parent.parent;
     }
 
     get actor() {
-        return this.item?.actor;
+        return this.item instanceof DhpActor ? this.item : this.item?.actor;
     }
 
     get chatTemplate() {
         return 'systems/daggerheart/templates/chat/duality-roll.hbs';
     }
-    get chatTitle() {
-        return this.item.name;
-    }
 
-    static getRollType() {
+    static getRollType(parent) {
         return 'ability';
     }
 
@@ -121,96 +145,425 @@ export class DHBaseAction extends foundry.abstract.DataModel {
         updateSource.img ??= parent?.img ?? parent?.system?.img;
         if (parent?.system?.trait) {
             updateSource['roll'] = {
-                type: this.getRollType(),
+                type: this.getRollType(parent),
                 trait: parent.system.trait
             };
         }
+        if (parent?.type === 'weapon' && !!this.schema.fields.damage) {
+            updateSource['damage'] = { includeBase: true };
+        }
         if (parent?.system?.range) {
             updateSource['range'] = parent?.system?.range;
         }
         return updateSource;
     }
 
-    async use(event) {
-        if (this.roll.type && this.roll.trait) {
-            const modifierValue =
-                this.actor.system.traits[this.roll.trait].value + (this.actor.system.bonuses.attack ?? 0);
-            const config = {
-                event: event,
-                title: this.chatTitle,
-                roll: {
-                    modifier: modifierValue,
-                    label: game.i18n.localize(abilities[this.roll.trait].label),
-                    type: this.actionType,
-                    difficulty: this.roll?.difficulty
-                },
-                chatMessage: {
-                    template: this.chatTemplate
+    getRollData() {
+        const actorData = this.actor.getRollData(false);
+
+        // Remove when included directly in Actor getRollData
+        actorData.prof = actorData.proficiency?.value ?? 1,
+        actorData.cast = actorData.spellcast?.value ?? 1,
+        actorData.scale = this.cost.length
+                ? this.cost.reduce((a, c) => {
+                      a[c.type] = c.value;
+                      return a;
+                  }, {})
+                : 1,
+        actorData.roll = {}
+
+        return actorData;
+    }
+
+    async use(event, ...args) {
+        const isFastForward = event.shiftKey || (!this.hasRoll && !this.hasSave);
+        // Prepare base Config
+        const initConfig = this.initActionConfig(event);
+        // let config = this.initActionConfig(event);
+
+        // Prepare Targets
+        const targetConfig = this.prepareTarget();
+        if (isFastForward && !targetConfig) return ui.notifications.warn('Too many targets selected for that actions.');
+        // config = this.prepareTarget(config);
+
+        // Prepare Range
+        const rangeConfig = this.prepareRange();
+        // config = this.prepareRange(config);
+
+        // Prepare Costs
+        const costsConfig = this.prepareCost();
+        if(isFastForward && !this.hasCost(costsConfig)) return ui.notifications.warn("You don't have the resources to use that action.");
+        // config = this.prepareUseCost(config)
+
+        // Prepare Uses
+        const usesConfig = this.prepareUse();
+        if(isFastForward && !this.hasUses(usesConfig)) return ui.notifications.warn("That action doesn't have remaining uses.");
+        // config = this.prepareUseCost(config)
+
+        // Prepare Roll Data
+        const actorData = this.getRollData();
+
+        let config = {
+            ...initConfig,
+            targets: targetConfig,
+            range: rangeConfig,
+            costs: costsConfig,
+            uses: usesConfig,
+            data: actorData
+        }
+        
+        if ( Hooks.call(`${SYSTEM.id}.preUseAction`, this, config) === false ) return;
+
+        // Display configuration window if necessary
+        if ( config.dialog.configure && this.requireConfigurationDialog(config) ) {
+            config = await D20RollDialog.configure(config);
+            if (!config) return;
+        }
+
+        if ( this.hasRoll ) {
+            const rollConfig = this.prepareRoll(config);
+            config.roll = rollConfig;
+            config = await this.actor.diceRoll(config);
+            if (!config) return;
+        }
+
+        if( this.hasSave ) {
+            /* config.targets.forEach((t) => {
+                if(t.hit) {
+                    const target = game.canvas.tokens.get(t.id),
+                        actor = target?.actor;
+                    console.log(actor)
+                    if(!actor) return;
+                    actor.saveRoll({
+                        event,
+                        title: 'Roll Save',
+                        roll: {
+                            trait: this.save.trait,
+                            difficulty: this.save.difficulty
+                        },
+                        dialog: {
+                            configure: false
+                        },
+                        data: actor.getRollData()
+                    }).then(async (result) => {
+                        t.saved = result;
+                        setTimeout(async () => {
+                            const message = ui.chat.collection.get(config.message.id),
+                                msgTargets = message.system.targets,
+                                msgTarget = msgTargets.find(mt => mt.id === t.id);
+                            msgTarget.saved = result;
+                            await message.update({'system.targets': msgTargets});
+                        },100)
+                    })
                 }
-            };
-            if (this.target?.type) config.checkTarget = true;
-            if (this.damage.parts.length) {
-                config.damage = {
-                    value: this.damage.parts.map(p => p.getFormula(this.actor)).join(' + '),
-                    type: this.damage.parts[0].type
-                };
-            }
-            if (this.effects.length) {
-                // Apply Active Effects. In Chat Message ?
-            }
-            return this.actor.diceRoll(config);
+            }) */
+        }
+
+        if ( this.doFollowUp() ) {
+            if(this.rollDamage) await this.rollDamage(event, config);
+            if(this.rollHealing) await this.rollHealing(event, config);
+            if(this.trigger) await this.trigger(event, config);
+        }
+
+        // Consume resources
+        await this.consume(config);
+        
+        if ( Hooks.call(`${SYSTEM.id}.postUseAction`, this, config) === false ) return;
+
+        return config;
+    }
+
+    /* */
+    initActionConfig(event) {
+        return {
+            event,
+            title: this.item.name,
+            source: {
+                item: this.item._id,
+                action: this._id
+                // action: this
+            },
+            dialog: {
+                configure: true
+            },
+            type: this.type,
+            hasDamage: !!this.damage?.parts?.length,
+            hasHealing: !!this.healing,
+            hasEffect: !!this.effects?.length,
+            hasSave: this.hasSave
         }
     }
-}
 
-const extraDefineSchema = (field, option) => {
-    return {
-        [field]: {
-            // damage: new fields.SchemaField({
-            //     parts: new fields.ArrayField(new fields.EmbeddedDataField(DHDamageData))
-            // }),
-            damage: new DHDamageField(option),
-            roll: new fields.SchemaField({
-                type: new fields.StringField({ nullable: true, initial: null, choices: SYSTEM.GENERAL.rollTypes }),
-                trait: new fields.StringField({ nullable: true, initial: null, choices: SYSTEM.ACTOR.abilities }),
-                difficulty: new fields.NumberField({ nullable: true, initial: null, integer: true, min: 0 })
-            }),
-            target: new fields.SchemaField({
-                type: new fields.StringField({
-                    choices: SYSTEM.ACTIONS.targetTypes,
-                    initial: SYSTEM.ACTIONS.targetTypes.other.id
-                })
-            }),
-            effects: new fields.ArrayField( // ActiveEffect
-                new fields.SchemaField({
-                    _id: new fields.DocumentIdField()
-                })
-            )
-        }[field]
-    };
-};
+    requireConfigurationDialog(config) {
+        return !config.event.shiftkey && !this.hasRoll && (config.costs?.length || config.uses);
+    }
 
-export class DHAttackAction extends DHBaseAction {
-    static defineSchema() {
+    prepareCost() {
+        const costs = this.cost?.length ? foundry.utils.deepClone(this.cost) : [];
+        return costs;
+    }
+
+    prepareUse() {
+        const uses = this.uses?.max ? foundry.utils.deepClone(this.uses) : null;
+        if (uses && !uses.value) uses.value = 0;
+        return uses;
+    }
+
+    prepareTarget() {
+        let targets;
+        if (this.target?.type === SYSTEM.ACTIONS.targetTypes.self.id)
+            targets = this.formatTarget(this.actor.token ?? this.actor.prototypeToken);
+        targets = Array.from(game.user.targets);
+        // foundry.CONST.TOKEN_DISPOSITIONS.FRIENDLY
+        if (this.target?.type && this.target.type !== SYSTEM.ACTIONS.targetTypes.any.id) {
+            targets = targets.filter(t => this.isTargetFriendly(t));
+            if (this.target.amount && targets.length > this.target.amount) targets = [];
+        }
+        targets = targets.map(t => this.formatTarget(t));
+        return targets;
+
+    }
+
+    prepareRange() {
+        const range = this.range ?? null;
+        return range;
+    }
+
+    prepareRoll() {
+       const roll = {
+            modifiers: [],
+            trait: this.roll?.trait,
+            label: 'Attack',
+            type: this.actionType,
+            difficulty: this.roll?.difficulty
+        };
+        return roll;
+    }
+
+    doFollowUp(config) {
+        return !this.hasRoll;
+    }
+
+    async consume(config) {
+        const resources = config.costs.filter(c => c.enabled !== false).map(c => {
+            return { type: c.type, value: c.total * -1 };
+        });
+        await this.actor.modifyResource(resources);
+        if(config.uses?.enabled) {
+            const newActions = foundry.utils.getProperty(this.item.system, this.systemPath).map(x => x.toObject());
+            newActions[this.index].uses.value++;
+            await this.item.update({ [`system.${this.systemPath}`]: newActions });
+        }
+    }
+    /* */
+
+    /* ROLL */
+    get hasRoll() {
+        return !!this.roll?.type;
+    }
+    /* ROLL */
+
+    /* SAVE */
+    get hasSave() {
+        return !!this.save?.trait;
+    }
+    /* SAVE */
+
+    /* COST */
+
+    getRealCosts(costs) {
+        const realCosts = costs?.length ? costs.filter(c => c.enabled) : [];
+        return realCosts;
+    }
+
+    calcCosts(costs) {
+        return costs.map(c => {
+            c.scale = c.scale ?? 1;
+            c.step = c.step ?? 1;
+            c.total = c.value * c.scale * c.step;
+            c.enabled = c.hasOwnProperty('enabled') ? c.enabled : true;
+            return c;
+        });
+    }
+
+    hasCost(costs) {
+        const realCosts = this.getRealCosts(costs);
+        return realCosts.reduce((a, c) => a && this.actor.system.resources[c.type]?.value >= (c.total ?? c.value), true);
+    }
+    /* COST */
+
+    /* USES */
+    calcUses(uses) {
+        if(!uses) return null;
         return {
-            ...super.defineSchema(),
-            ...extraDefineSchema('damage', true),
-            ...extraDefineSchema('roll'),
-            ...extraDefineSchema('target'),
-            ...extraDefineSchema('effects')
+            ...uses,
+            enabled: uses.hasOwnProperty('enabled') ? uses.enabled : true
         };
     }
 
-    static getRollType() {
-        return 'weapon';
+    hasUses(uses) {
+        if(!uses) return true;
+        return (uses.hasOwnProperty('enabled') && !uses.enabled) || uses.value + 1 <= uses.max;
+    }
+    /* USES */
+
+    /* TARGET */
+    isTargetFriendly(target) {
+        const actorDisposition = this.actor.token
+                ? this.actor.token.disposition
+                : this.actor.prototypeToken.disposition,
+            targetDisposition = target.document.disposition;
+        return (
+            (this.target.type === SYSTEM.ACTIONS.targetTypes.friendly.id && actorDisposition === targetDisposition) ||
+            (this.target.type === SYSTEM.ACTIONS.targetTypes.hostile.id && actorDisposition + targetDisposition === 0)
+        );
     }
 
-    get chatTitle() {
-        return game.i18n.format('DAGGERHEART.Chat.AttackRoll.Title', {
-            attack: this.item.name
+    formatTarget(actor) {
+        return {
+            id: actor.id,
+            actorId: actor.actor.uuid,
+            name: actor.actor.name,
+            img: actor.actor.img,
+            difficulty: actor.actor.system.difficulty,
+            evasion: actor.actor.system.evasion?.total
+        };
+    }
+    /* TARGET */
+
+    /* RANGE */
+    
+    /* RANGE */
+
+    /* EFFECTS */
+    async applyEffects(event, data, force = false) {
+        if (!this.effects?.length || !data.system.targets.length) return;
+        let effects = this.effects;
+        data.system.targets.forEach(async token => {
+            if (!token.hit && !force) return;
+            if(this.hasSave && token.saved.success === true) {
+                effects = this.effects.filter(e => e.onSave === true)
+            }
+            if(!effects.length) return;
+            effects.forEach(async e => {
+                const actor = canvas.tokens.get(token.id)?.actor,
+                    effect = this.item.effects.get(e._id);
+                if (!actor || !effect) return;
+                await this.applyEffect(effect, actor);
+            });
         });
     }
 
+    async applyEffect(effect, actor) {
+        // Enable an existing effect on the target if it originated from this effect
+        const existingEffect = actor.effects.find(e => e.origin === origin.uuid);
+        if (existingEffect) {
+            return existingEffect.update(
+                foundry.utils.mergeObject({
+                    ...effect.constructor.getInitialDuration(),
+                    disabled: false
+                })
+            );
+        }
+
+        // Otherwise, create a new effect on the target
+        const effectData = foundry.utils.mergeObject({
+            ...effect.toObject(),
+            disabled: false,
+            transfer: false,
+            origin: origin.uuid
+        });
+        await ActiveEffect.implementation.create(effectData, { parent: actor });
+    }
+    /* EFFECTS */
+
+    /* SAVE */
+    async rollSave(target, event, message) {
+        if(!target?.actor) return;
+        target.actor.diceRoll({
+            event,
+            title: 'Roll Save',
+            roll: {
+                trait: this.save.trait,
+                difficulty: this.save.difficulty,
+                type: "reaction"
+            },
+            data: target.actor.getRollData()
+        }).then(async (result) => {
+            this.updateChatMessage(message, target.id, {result: result.roll.total, success: result.roll.success});
+        })
+    }
+
+    async updateChatMessage(message, targetId, changes, chain=true) {
+        setTimeout(async () => {
+            const chatMessage = ui.chat.collection.get(message._id),
+                msgTargets = chatMessage.system.targets,
+                msgTarget = msgTargets.find(mt => mt.id === targetId);
+            msgTarget.saved = changes;
+            await chatMessage.update({'system.targets': msgTargets});
+        },100);
+        if(chain) {
+            if(message.system.source.message) this.updateChatMessage(ui.chat.collection.get(message.system.source.message), targetId, changes, false);
+            const relatedChatMessages = ui.chat.collection.filter(c => c.system.source.message === message._id);
+            relatedChatMessages.forEach(c => {
+                this.updateChatMessage(c, targetId, changes, false);
+            })
+        }
+    }
+    /* SAVE */
+}
+
+export class DHDamageAction extends DHBaseAction {
+    static extraSchemas = ['damage', 'target', 'effects'];
+
+    /* async use(event, ...args) {
+        const config = await super.use(event, args);
+        if (!config || ['error', 'warning'].includes(config.type)) return;
+        if (!this.directDamage) return;
+        return await this.rollDamage(event, config);
+    } */
+
+    getFormulaValue(part, data) {
+        let formulaValue = part.value;
+        if(this.hasRoll && part.resultBased && data.system.roll.result.duality === -1) return part.valueAlt;
+        return formulaValue;
+    }
+
+    async rollDamage(event, data) {
+        let formula = this.damage.parts.map(p => this.getFormulaValue(p, data).getFormula(this.actor)).join(' + ');
+
+        if (!formula || formula == '') return;
+        let roll = { formula: formula, total: formula },
+            bonusDamage = [];
+        
+        const config = {
+            title: game.i18n.format('DAGGERHEART.Chat.DamageRoll.Title', { damage: this.name }),
+            formula,
+            targets: (data.system?.targets.filter(t => t.hit) ?? data.targets),
+            hasSave: this.hasSave,
+            source: data.system?.source
+        };
+        if(this.hasSave) config.onSave = this.save.damageMod;
+        if(data.system) {
+            config.source.message = data._id;
+            config.directDamage = false;
+        }
+
+        roll = CONFIG.Dice.daggerheart.DamageRoll.build(config);
+    }
+}
+
+export class DHAttackAction extends DHDamageAction {
+    static extraSchemas = [...super.extraSchemas, ...['roll', 'save']];
+
+    static getRollType(parent) {
+        return parent.type === 'weapon' ? 'weapon' : 'spellcast';
+    }
+
+    get chatTemplate() {
+        return 'systems/daggerheart/templates/chat/duality-roll.hbs';
+    }
+
     prepareData() {
         super.prepareData();
         if (this.damage.includeBase && !!this.item?.system?.damage) {
@@ -221,115 +574,49 @@ export class DHAttackAction extends DHBaseAction {
 
     getParentDamage() {
         return {
-            multiplier: 'proficiency',
-            dice: this.item?.system?.damage.value,
-            bonus: this.item?.system?.damage.bonus ?? 0,
+            value: {
+                multiplier: 'proficiency',
+                dice: this.item?.system?.damage.value,
+                bonus: this.item?.system?.damage.bonus ?? 0
+            },
             type: this.item?.system?.damage.type,
             base: true
         };
     }
-
-    // Temporary until full formula parser
-    // getDamageFormula() {
-    //     return this.damage.parts.map(p => p.formula).join(' + ');
-    // }
-}
-
-export class DHSpellCastAction extends DHBaseAction {
-    static defineSchema() {
-        return {
-            ...super.defineSchema(),
-            ...extraDefineSchema('damage'),
-            ...extraDefineSchema('roll'),
-            ...extraDefineSchema('target'),
-            ...extraDefineSchema('effects')
-        };
-    }
-
-    static getRollType() {
-        return 'spellcast';
-    }
-}
-
-export class DHDamageAction extends DHBaseAction {
-    static defineSchema() {
-        return {
-            ...super.defineSchema(),
-            ...extraDefineSchema('damage', false),
-            ...extraDefineSchema('target'),
-            ...extraDefineSchema('effects')
-        };
-    }
-
-    async use(event) {
-        const formula = this.damage.parts.map(p => p.getFormula(this.actor)).join(' + ');
-        if (!formula || formula == '') return;
-
-        let roll = { formula: formula, total: formula };
-        if (isNaN(formula)) {
-            roll = await new Roll(formula).evaluate();
-        }
-
-        const cls = getDocumentClass('ChatMessage');
-        const msg = new cls({
-            user: game.user.id,
-            content: await foundry.applications.handlebars.renderTemplate(
-                'systems/daggerheart/templates/chat/damage-roll.hbs',
-                {
-                    roll: roll.formula,
-                    total: roll.total,
-                    type: this.damage.parts.map(p => p.type)
-                }
-            )
-        });
-
-        cls.create(msg.toObject());
-    }
 }
 
 export class DHHealingAction extends DHBaseAction {
-    static defineSchema() {
-        return {
-            ...super.defineSchema(),
-            healing: new fields.SchemaField({
-                type: new fields.StringField({
-                    choices: SYSTEM.GENERAL.healingTypes,
-                    required: true,
-                    blank: false,
-                    initial: SYSTEM.GENERAL.healingTypes.health.id,
-                    label: 'Healing'
-                }),
-                value: new fields.EmbeddedDataField(DHActionDiceData)
-            }),
-            ...extraDefineSchema('target'),
-            ...extraDefineSchema('effects')
-        };
+    static extraSchemas = ['target', 'effects', 'healing', 'roll'];
+
+    static getRollType(parent) {
+        return 'spellcast';
     }
 
-    async use(event) {
-        const formula = this.healing.value.getFormula(this.actor);
+    getFormulaValue(data) {
+        let formulaValue = this.healing.value;
+        if(this.hasRoll && this.healing.resultBased && data.system.roll.result.duality === -1) return this.healing.valueAlt;
+        return formulaValue;
+    }
+
+    async rollHealing(event, data) {
+        let formulaValue = this.getFormulaValue(data),
+            formula = formulaValue.getFormula(this.actor);
+
         if (!formula || formula == '') return;
+        let roll = { formula: formula, total: formula },
+            bonusDamage = [];
+        
+        const config = {
+            title: game.i18n.format('DAGGERHEART.Chat.HealingRoll.Title', {
+                healing: game.i18n.localize(SYSTEM.GENERAL.healingTypes[this.healing.type].label)
+            }),
+            formula,
+            targets: (data.system?.targets ?? data.targets).filter(t => t.hit),
+            messageType: 'healing',
+            type: this.healing.type
+        };
 
-        // const roll = await super.use(event);
-        let roll = { formula: formula, total: formula };
-        if (isNaN(formula)) {
-            roll = await new Roll(formula).evaluate();
-        }
-
-        const cls = getDocumentClass('ChatMessage');
-        const msg = new cls({
-            user: game.user.id,
-            content: await foundry.applications.handlebars.renderTemplate(
-                'systems/daggerheart/templates/chat/healing-roll.hbs',
-                {
-                    roll: roll.formula,
-                    total: roll.total,
-                    type: this.healing.type
-                }
-            )
-        });
-
-        cls.create(msg.toObject());
+        roll = CONFIG.Dice.daggerheart.DamageRoll.build(config);
     }
 
     get chatTemplate() {
@@ -337,42 +624,60 @@ export class DHHealingAction extends DHBaseAction {
     }
 }
 
-export class DHResourceAction extends DHBaseAction {
-    static defineSchema() {
-        return {
-            ...super.defineSchema(),
-            // ...extraDefineSchema('roll'),
-            ...extraDefineSchema('target'),
-            ...extraDefineSchema('effects'),
-            resource: new fields.SchemaField({
-                type: new fields.StringField({
-                    choices: [],
-                    blank: true,
-                    required: false,
-                    initial: '',
-                    label: 'Resource'
-                }),
-                value: new fields.NumberField({ initial: 0, label: 'Value' })
-            })
-        };
-    }
-}
-
 export class DHSummonAction extends DHBaseAction {
     static defineSchema() {
         return {
             ...super.defineSchema(),
-            documentUUID: new fields.StringField({ blank: true, initial: '', placeholder: 'Enter a Creature UUID' })
+            documentUUID: new fields.DocumentUUIDField({ type: 'Actor' })
         };
     }
+
+    async trigger(event, ...args) {
+        if (!this.canSummon || !canvas.scene) return;
+        // const config = await super.use(event, args);
+    }
+
+    get canSummon() {
+        return game.user.can('TOKEN_CREATE');
+    }
 }
 
 export class DHEffectAction extends DHBaseAction {
-    static defineSchema() {
-        return {
-            ...super.defineSchema(),
-            ...extraDefineSchema('effects')
-        };
+    static extraSchemas = ['effects', 'target'];
+
+    async use(event, ...args) {
+        const config = await super.use(event, args);
+        if (['error', 'warning'].includes(config.type)) return;
+        return await this.chatApplyEffects(event, config);
+    }
+
+    async chatApplyEffects(event, data) {
+        const cls = getDocumentClass('ChatMessage'),
+            systemData = {
+                title: game.i18n.format('DAGGERHEART.Chat.ApplyEffect.Title', { name: this.name }),
+                origin: this.actor._id,
+                description: '',
+                targets: data.targets.map(x => ({ id: x.id, name: x.name, img: x.img, hit: true })),
+                action: {
+                    itemId: this.item._id,
+                    actionId: this._id
+                }
+            },
+            msg = new cls({
+                type: 'applyEffect',
+                user: game.user.id,
+                system: systemData,
+                content: await foundry.applications.handlebars.renderTemplate(
+                    'systems/daggerheart/templates/chat/apply-effects.hbs',
+                    systemData
+                )
+            });
+
+        cls.create(msg.toObject());
+    }
+
+    get chatTemplate() {
+        return 'systems/daggerheart/templates/chat/apply-effects.hbs';
     }
 }
 
@@ -380,11 +685,13 @@ export class DHMacroAction extends DHBaseAction {
     static defineSchema() {
         return {
             ...super.defineSchema(),
-            documentUUID: new fields.StringField({ blank: true, initial: '', placeholder: 'Enter a macro UUID' })
+            documentUUID: new fields.DocumentUUIDField({ type: 'Macro' })
         };
     }
 
-    async use(event) {
+    async trigger(event, ...args) {
+        // const config = await super.use(event, args);
+        // if (['error', 'warning'].includes(config.type)) return;
         const fixUUID = !this.documentUUID.includes('Macro.') ? `Macro.${this.documentUUID}` : this.documentUUID,
             macro = await fromUuid(fixUUID);
         try {

module/data/action/actionDice.mjs

@@ -11,6 +11,7 @@ export class DHActionDiceData extends foundry.abstract.DataModel {
                 initial: 'proficiency',
                 label: 'Multiplier'
             }),
+            flatMultiplier: new fields.NumberField({ nullable: true, initial: 1, label: 'Flat Multiplier' }),
             dice: new fields.StringField({ choices: SYSTEM.GENERAL.diceTypes, initial: 'd6', label: 'Formula' }),
             bonus: new fields.NumberField({ nullable: true, initial: null, label: 'Bonus' }),
             custom: new fields.SchemaField({
@@ -21,27 +22,29 @@ export class DHActionDiceData extends foundry.abstract.DataModel {
     }
 
     getFormula(actor) {
+        const multiplier = this.multiplier === 'flat' ? this.flatMultiplier : actor.system[this.multiplier]?.total;
         return this.custom.enabled
             ? this.custom.formula
-            : `${actor.system[this.multiplier]?.total ?? 1}${this.dice}${this.bonus ? (this.bonus < 0 ? ` - ${Math.abs(this.bonus)}` : ` + ${this.bonus}`) : ''}`;
+            : `${multiplier ?? 1}${this.dice}${this.bonus ? (this.bonus < 0 ? ` - ${Math.abs(this.bonus)}` : ` + ${this.bonus}`) : ''}`;
     }
 }
 
 export class DHDamageField extends fields.SchemaField {
-    constructor(hasBase, options, context = {}) {
+    constructor(options, context = {}) {
         const damageFields = {
-            parts: new fields.ArrayField(new fields.EmbeddedDataField(DHDamageData))
+            parts: new fields.ArrayField(new fields.EmbeddedDataField(DHDamageData)),
+            includeBase: new fields.BooleanField({ initial: false })
         };
-        if (hasBase) damageFields.includeBase = new fields.BooleanField({ initial: true });
+        // if (hasBase) damageFields.includeBase = new fields.BooleanField({ initial: true });
         super(damageFields, options, context);
     }
 }
 
-export class DHDamageData extends DHActionDiceData {
+export class DHDamageData extends foundry.abstract.DataModel {
     /** @override */
     static defineSchema() {
         return {
-            ...super.defineSchema(),
+            // ...super.defineSchema(),
             base: new fields.BooleanField({ initial: false, readonly: true, label: 'Base' }),
             type: new fields.StringField({
                 choices: SYSTEM.GENERAL.damageTypes,
@@ -49,7 +52,10 @@ export class DHDamageData extends DHActionDiceData {
                 label: 'Type',
                 nullable: false,
                 required: true
-            })
+            }),
+            resultBased: new fields.BooleanField({ initial: false, label: "DAGGERHEART.Actions.Settings.ResultBased.label" }),
+            value: new fields.EmbeddedDataField(DHActionDiceData),
+            valueAlt: new fields.EmbeddedDataField(DHActionDiceData),
         };
     }
 }

module/data/actor/adversary.mjs

@@ -1,3 +1,4 @@
+import ActionField from '../fields/actionField.mjs';
 import BaseDataActor from './base.mjs';
 
 const resourceField = () =>
@@ -39,30 +40,41 @@ export default class DhpAdversary extends BaseDataActor {
                 hitPoints: resourceField(),
                 stress: resourceField()
             }),
-            attack: new fields.SchemaField({
-                name: new fields.StringField({}),
-                modifier: new fields.NumberField({ required: true, integer: true, initial: 0 }),
-                range: new fields.StringField({
-                    required: true,
-                    choices: SYSTEM.GENERAL.range,
-                    initial: SYSTEM.GENERAL.range.melee.id
-                }),
-                damage: new fields.SchemaField({
-                    value: new fields.StringField(),
-                    type: new fields.StringField({
-                        required: true,
-                        choices: SYSTEM.GENERAL.damageTypes,
-                        initial: SYSTEM.GENERAL.damageTypes.physical.id
-                    })
-                })
+            attack: new ActionField({
+                initial: {
+                    name: 'Attack',
+                    _id: foundry.utils.randomID(),
+                    systemPath: 'attack',
+                    type: 'attack',
+                    range: 'melee',
+                    target: {
+                        type: 'any',
+                        amount: 1
+                    },
+                    roll: {
+                        type: 'weapon'
+                    },
+                    damage: {
+                        parts: [
+                            {
+                                multiplier: 'flat'
+                            }
+                        ]
+                    }
+                }
             }),
             experiences: new fields.TypedObjectField(
                 new fields.SchemaField({
                     name: new fields.StringField(),
                     value: new fields.NumberField({ required: true, integer: true, initial: 1 })
                 })
-            )
-            /* Features waiting on pseudo-document data model addition */
+            ),
+            bonuses: new fields.SchemaField({
+                difficulty: new fields.SchemaField({
+                    all: new fields.NumberField({ integer: true, initial: 0 }),
+                    reaction: new fields.NumberField({ integer: true, initial: 0 })
+                })
+            })
         };
     }
 }

module/data/actor/character.mjs

@@ -17,6 +17,12 @@ const resourceField = max =>
         max: new foundry.data.fields.NumberField({ initial: max, integer: true })
     });
 
+const stressDamageReductionRule = () =>
+    new foundry.data.fields.SchemaField({
+        enabled: new foundry.data.fields.BooleanField({ required: true, initial: false }),
+        cost: new foundry.data.fields.NumberField({ integer: true })
+    });
+
 export default class DhCharacter extends BaseDataActor {
     static get metadata() {
         return foundry.utils.mergeObject(super.metadata, {
@@ -35,7 +41,9 @@ export default class DhCharacter extends BaseDataActor {
                     bonus: new foundry.data.fields.NumberField({ initial: 0, integer: true })
                 }),
                 stress: resourceField(6),
-                hope: resourceField(6)
+                hope: resourceField(6),
+                tokens: new fields.ObjectField(),
+                dice: new fields.ObjectField()
             }),
             traits: new fields.SchemaField({
                 agility: attributeField(),
@@ -90,9 +98,42 @@ export default class DhCharacter extends BaseDataActor {
             }),
             levelData: new fields.EmbeddedDataField(DhPCLevelData),
             bonuses: new fields.SchemaField({
-                attack: new fields.NumberField({ integer: true, initial: 0 }),
-                spellcast: new fields.NumberField({ integer: true, initial: 0 }),
-                armorScore: new fields.NumberField({ integer: true, initial: 0 })
+                armorScore: new fields.NumberField({ integer: true, initial: 0 }),
+                damageThresholds: new fields.SchemaField({
+                    severe: new fields.NumberField({ integer: true, initial: 0 }),
+                    major: new fields.NumberField({ integer: true, initial: 0 })
+                }),
+                roll: new fields.SchemaField({
+                    attack: new fields.NumberField({ integer: true, initial: 0 }),
+                    spellcast: new fields.NumberField({ integer: true, initial: 0 }),
+                    action: new fields.NumberField({ integer: true, initial: 0 }),
+                    hopeOrFear: new fields.NumberField({ integer: true, initial: 0 })
+                }),
+                damage: new fields.SchemaField({
+                    all: new fields.NumberField({ integer: true, initial: 0 }),
+                    physical: new fields.NumberField({ integer: true, initial: 0 }),
+                    magic: new fields.NumberField({ integer: true, initial: 0 })
+                })
+            }),
+            rules: new fields.SchemaField({
+                maxArmorMarked: new fields.SchemaField({
+                    value: new fields.NumberField({ required: true, integer: true, initial: 1 }),
+                    bonus: new fields.NumberField({ required: true, integer: true, initial: 0 }),
+                    stressExtra: new fields.NumberField({ required: true, integer: true, initial: 0 })
+                }),
+                stressDamageReduction: new fields.SchemaField({
+                    severe: stressDamageReductionRule(),
+                    major: stressDamageReductionRule(),
+                    minor: stressDamageReductionRule()
+                }),
+                strangePatterns: new fields.NumberField({
+                    integer: true,
+                    min: 1,
+                    max: 12,
+                    nullable: true,
+                    initial: null
+                }),
+                runeWard: new fields.BooleanField({ initial: false })
             })
         };
     }
@@ -246,6 +287,9 @@ export default class DhCharacter extends BaseDataActor {
             experience.total = experience.value + experience.bonus;
         }
 
+        this.rules.maxArmorMarked.total = this.rules.maxArmorMarked.value + this.rules.maxArmorMarked.bonus;
+
+        this.armorScore = this.armor ? this.armor.system.baseScore + (this.bonuses.armorScore ?? 0) : 0;
         this.resources.hitPoints.maxTotal = (this.class.value?.system?.hitPoints ?? 0) + this.resources.hitPoints.bonus;
         this.resources.stress.maxTotal = this.resources.stress.max + this.resources.stress.bonus;
         this.evasion.total = (this.class?.evasion ?? 0) + this.evasion.bonus;
@@ -256,7 +300,11 @@ export default class DhCharacter extends BaseDataActor {
         const data = super.getRollData();
         return {
             ...data,
-            tier: this.tier
+            ...this.resources.tokens,
+            ...this.resources.dice,
+            ...this.bonuses,
+            tier: this.tier,
+            level: this.levelData.level.current
         };
     }
 }

module/data/chat-message/_modules.mjs

@@ -1,13 +1,21 @@
-import DHAbilityUse from './abilityUse.mjs';
-import DHAdversaryRoll from './adversaryRoll.mjs';
-import DHDamageRoll from './damageRoll.mjs';
-import DHDualityRoll from './dualityRoll.mjs';
+import DHAbilityUse from "./abilityUse.mjs";
+import DHAdversaryRoll from "./adversaryRoll.mjs";
+import DHDamageRoll from "./damageRoll.mjs";
+import DHDualityRoll from "./dualityRoll.mjs";
+import DHApplyEffect from './applyEffects.mjs'
 
-export { DHAbilityUse, DHAdversaryRoll, DHDamageRoll, DHDualityRoll };
+export {
+  DHAbilityUse,
+  DHAdversaryRoll,
+  DHDamageRoll,
+  DHDualityRoll,
+  DHApplyEffect
+}
 
 export const config = {
-    abilityUse: DHAbilityUse,
-    adversaryRoll: DHAdversaryRoll,
-    damageRoll: DHDamageRoll,
-    dualityRoll: DHDualityRoll
+  abilityUse: DHAbilityUse,
+  adversaryRoll: DHAdversaryRoll,
+  damageRoll: DHDamageRoll,
+  dualityRoll: DHDualityRoll,
+  applyEffect: DHApplyEffect
 };

module/data/chat-message/adversaryRoll.mjs

@@ -4,43 +4,35 @@ export default class DHAdversaryRoll extends foundry.abstract.TypeDataModel {
 
         return {
             title: new fields.StringField(),
-            origin: new fields.StringField({ required: true }),
-            dice: new fields.DataField(),
             roll: new fields.DataField(),
-            modifiers: new fields.ArrayField(
-                new fields.SchemaField({
-                    value: new fields.NumberField({ integer: true }),
-                    label: new fields.StringField({})
-                })
-            ),
-            advantageState: new fields.BooleanField({ nullable: true, initial: null }),
-            advantage: new fields.SchemaField({
-                dice: new fields.StringField({}),
-                value: new fields.NumberField({ integer: true })
-            }),
             targets: new fields.ArrayField(
                 new fields.SchemaField({
                     id: new fields.StringField({}),
+                    actorId: new fields.StringField({}),
                     name: new fields.StringField({}),
                     img: new fields.StringField({}),
                     difficulty: new fields.NumberField({ integer: true, nullable: true }),
                     evasion: new fields.NumberField({ integer: true }),
-                    hit: new fields.BooleanField({ initial: false })
+                    hit: new fields.BooleanField({ initial: false }),
+                    saved: new fields.SchemaField({
+                        result: new fields.NumberField(),
+                        success: new fields.BooleanField({ nullable: true, initial: null })
+                    })
                 })
             ),
-            damage: new fields.SchemaField(
-                {
-                    value: new fields.StringField({}),
-                    type: new fields.StringField({ choices: Object.keys(SYSTEM.GENERAL.damageTypes), integer: false })
-                },
-                { nullable: true, initial: null }
-            )
+            hasDamage: new fields.BooleanField({ initial: false }),
+            hasHealing: new fields.BooleanField({ initial: false }),
+            hasEffect: new fields.BooleanField({ initial: false }),
+            hasSave: new fields.BooleanField({ initial: false }),
+            source: new fields.SchemaField({
+                actor: new fields.StringField(),
+                item: new fields.StringField(),
+                action: new fields.StringField()
+            })
         };
     }
 
-    prepareDerivedData() {
-        this.targets.forEach(target => {
-            target.hit = target.difficulty ? this.total >= target.difficulty : this.total >= target.evasion;
-        });
+    get messageTemplate() {
+        return 'systems/daggerheart/templates/chat/adversary-roll.hbs';
     }
 }

module/data/chat-message/applyEffects.mjs

@@ -0,0 +1,23 @@
+export default class DHApplyEffect extends foundry.abstract.TypeDataModel {
+    static defineSchema() {
+        const fields = foundry.data.fields;
+
+        return {
+            title: new fields.StringField(),
+            origin: new fields.StringField({}),
+            description: new fields.StringField({}),
+            targets: new fields.ArrayField(
+                new fields.SchemaField({
+                    id: new fields.StringField({ required: true }),
+                    name: new fields.StringField(),
+                    img: new fields.StringField(),
+                    hit: new fields.BooleanField({ initial: false })
+                })
+            ),
+            action: new fields.SchemaField({
+                itemId: new fields.StringField(),
+                actionId: new fields.StringField()
+            })
+        };
+    }
+}

module/data/chat-message/damageRoll.mjs

@@ -3,32 +3,35 @@ export default class DHDamageRoll extends foundry.abstract.TypeDataModel {
         const fields = foundry.data.fields;
 
         return {
+            messageType: new fields.StringField({initial: 'damage'}),
             title: new fields.StringField(),
-            roll: new fields.StringField({ required: true }),
-            damage: new fields.SchemaField({
-                total: new fields.NumberField({ required: true, integer: true }),
-                type: new fields.StringField({ choices: Object.keys(SYSTEM.GENERAL.damageTypes), integer: false })
-            }),
-            dice: new fields.ArrayField(
-                new fields.SchemaField({
-                    type: new fields.StringField({ required: true }),
-                    rolls: new fields.ArrayField(new fields.NumberField({ required: true, integer: true })),
-                    total: new fields.NumberField({ integer: true })
-                })
-            ),
-            modifiers: new fields.ArrayField(
-                new fields.SchemaField({
-                    value: new fields.NumberField({ required: true, integer: true }),
-                    operator: new fields.StringField({ required: true, choices: ['+', '-', '*', '/'] })
-                })
-            ),
+            roll: new fields.DataField({}),
             targets: new fields.ArrayField(
                 new fields.SchemaField({
                     id: new fields.StringField({ required: true }),
+                    actorId: new fields.StringField({}),
                     name: new fields.StringField(),
-                    img: new fields.StringField()
+                    img: new fields.StringField(),
+                    hit: new fields.BooleanField({ initial: false }),
+                    saved: new fields.SchemaField({
+                        result: new fields.NumberField(),
+                        success: new fields.BooleanField({ nullable: true, initial: null })
+                    })
                 })
-            )
+            ),
+            hasSave: new fields.BooleanField({ initial: false }),
+            onSave: new fields.StringField(),
+            source: new fields.SchemaField({
+                actor: new fields.StringField(),
+                item: new fields.StringField(),
+                action: new fields.StringField(),
+                message: new fields.StringField()
+            }),
+            directDamage: new fields.BooleanField({initial: true})
         };
     }
+
+    get messageTemplate() {
+        return `systems/daggerheart/templates/chat/${this.messageType}-roll.hbs`;
+    }
 }

module/data/chat-message/dualityRoll.mjs

@@ -1,11 +1,4 @@
-import { DualityRollColor } from '../settings/Appearance.mjs';
-
 const fields = foundry.data.fields;
-const diceField = () =>
-    new fields.SchemaField({
-        dice: new fields.StringField({}),
-        value: new fields.NumberField({ integer: true })
-    });
 
 export default class DHDualityRoll extends foundry.abstract.TypeDataModel {
     static dualityResult = {
@@ -17,92 +10,35 @@ export default class DHDualityRoll extends foundry.abstract.TypeDataModel {
     static defineSchema() {
         return {
             title: new fields.StringField(),
-            origin: new fields.StringField({ required: true }),
             roll: new fields.DataField({}),
-            modifiers: new fields.ArrayField(
-                new fields.SchemaField({
-                    value: new fields.NumberField({ integer: true }),
-                    label: new fields.StringField({})
-                })
-            ),
-            hope: diceField(),
-            fear: diceField(),
-            advantageState: new fields.BooleanField({ nullable: true, initial: null }),
-            advantage: diceField(),
             targets: new fields.ArrayField(
                 new fields.SchemaField({
                     id: new fields.StringField({}),
+                    actorId: new fields.StringField({}),
                     name: new fields.StringField({}),
                     img: new fields.StringField({}),
                     difficulty: new fields.NumberField({ integer: true, nullable: true }),
                     evasion: new fields.NumberField({ integer: true }),
-                    hit: new fields.BooleanField({ initial: false })
+                    hit: new fields.BooleanField({ initial: false }),
+                    saved: new fields.SchemaField({
+                        result: new fields.NumberField(),
+                        success: new fields.BooleanField({ nullable: true, initial: null })
+                    })
                 })
             ),
-            damage: new fields.SchemaField({
-                value: new fields.StringField({}),
-                type: new fields.StringField({ choices: Object.keys(SYSTEM.GENERAL.damageTypes), integer: false }),
-                bonusDamage: new fields.ArrayField(
-                    new fields.SchemaField({
-                        value: new fields.StringField({}),
-                        type: new fields.StringField({
-                            choices: Object.keys(SYSTEM.GENERAL.damageTypes),
-                            integer: false
-                        }),
-                        initiallySelected: new fields.BooleanField(),
-                        appliesOn: new fields.StringField(
-                            { choices: Object.keys(SYSTEM.EFFECTS.applyLocations) },
-                            { nullable: true, initial: null }
-                        ),
-                        description: new fields.StringField({}),
-                        hopeIncrease: new fields.StringField({ nullable: true })
-                    }),
-                    { nullable: true, initial: null }
-                )
+            hasDamage: new fields.BooleanField({ initial: false }),
+            hasHealing: new fields.BooleanField({ initial: false }),
+            hasEffect: new fields.BooleanField({ initial: false }),
+            hasSave: new fields.BooleanField({ initial: false }),
+            source: new fields.SchemaField({
+                actor: new fields.StringField(),
+                item: new fields.StringField(),
+                action: new fields.StringField()
             })
         };
     }
 
-    get diceTotal() {
-        return this.hope.value + this.fear.value;
-    }
-
-    get modifierTotal() {
-        const total = this.modifiers.reduce((acc, x) => acc + x.value, 0);
-        return {
-            value: total,
-            label: total > 0 ? `+${total}` : total < 0 ? `${total}` : ''
-        };
-    }
-
-    get dualityResult() {
-        return this.hope.value > this.fear.value
-            ? this.constructor.dualityResult.hope
-            : this.fear.value > this.hope.value
-              ? this.constructor.dualityResult.fear
-              : this.constructor.dualityResult.critical;
-    }
-
-    get totalLabel() {
-        const label =
-            this.hope.value > this.fear.value
-                ? 'DAGGERHEART.General.Hope'
-                : this.fear.value > this.hope.value
-                  ? 'DAGGERHEART.General.Fear'
-                  : 'DAGGERHEART.General.CriticalSuccess';
-
-        return game.i18n.localize(label);
-    }
-
-    get colorful() {
-        return (
-            game.settings.get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.appearance).dualityColorScheme ===
-            DualityRollColor.colorful.value
-        );
-    }
-
-    prepareDerivedData() {
-        this.hope.discarded = this.hope.value < this.fear.value;
-        this.fear.discarded = this.fear.value < this.hope.value;
+    get messageTemplate() {
+        return 'systems/daggerheart/templates/chat/duality-roll.hbs';
     }
 }

module/data/item/armor.mjs

@@ -29,7 +29,6 @@ export default class DHArmor extends BaseDataItem {
                 })
             ),
             marks: new fields.SchemaField({
-                max: new fields.NumberField({ initial: 6, integer: true }),
                 value: new fields.NumberField({ initial: 0, integer: true })
             }),
             baseThresholds: new fields.SchemaField({

module/data/item/base.mjs

@@ -1,3 +1,5 @@
+import { actionsTypes } from '../action/_module.mjs';
+
 /**
  * Describes metadata about the item data model type
  * @typedef {Object} ItemDataModelMetadata
@@ -50,4 +52,24 @@ export default class BaseDataItem extends foundry.abstract.TypeDataModel {
         const data = { ...actorRollData, item: { ...this } };
         return data;
     }
+    
+    async _preCreate(data, options, user) {
+        if(!this.constructor.metadata.hasInitialAction || !foundry.utils.isEmpty(this.actions)) return;
+        const actionType = {
+                weapon: 'attack'
+            }[this.constructor.metadata.type],
+            cls = actionsTypes.attack,
+            action = new cls(
+                {
+                    _id: foundry.utils.randomID(),
+                    type: actionType,
+                    name: game.i18n.localize(SYSTEM.ACTIONS.actionTypes[actionType].name),
+                    ...cls.getSourceConfig(this.parent)
+                },
+                {
+                    parent: this.parent
+                }
+            );
+        this.updateSource({actions: [action]});
+    }
 }

module/data/item/feature.mjs

@@ -1,5 +1,4 @@
 import { getTier } from '../../helpers/utils.mjs';
-import DHAction from '../action/action.mjs';
 import BaseDataItem from './base.mjs';
 import ActionField from '../fields/actionField.mjs';
 

module/data/item/weapon.mjs

@@ -2,7 +2,7 @@ import BaseDataItem from './base.mjs';
 import FormulaField from '../fields/formulaField.mjs';
 import ActionField from '../fields/actionField.mjs';
 import { weaponFeatures } from '../../config/itemConfig.mjs';
-import { actionsTypes } from '../../data/_module.mjs';
+import { actionsTypes } from '../action/_module.mjs'; 
 
 export default class DHWeapon extends BaseDataItem {
     /** @inheritDoc */
@@ -14,7 +14,8 @@ export default class DHWeapon extends BaseDataItem {
             isQuantifiable: true,
             embedded: {
                 feature: 'featureTest'
-            }
+            },
+            hasInitialAction: true
         });
     }