Fixed hybrid

module/data/action/beastformAction.mjs

@@ -48,19 +48,29 @@ export default class DhBeastformAction extends DHBaseAction {
             formData.system.features = [...formData.system.features, ...selectedForm.system.features.map(x => x.uuid)];
         }
 
+        if (selectedForm.system.beastformType === CONFIG.DH.ITEM.beastformTypes.hybrid.id) {
+            formData.system.advantageOn = Object.values(hybridData.advantages).reduce((advantages, formCategory) => {
+                Object.keys(formCategory).forEach(advantageKey => {
+                    advantages[advantageKey] = formCategory[advantageKey];
+                });
+                return advantages;
+            }, {});
+            formData.system.features = [
+                ...formData.system.features,
+                ...Object.values(hybridData.features).flatMap(x => Object.keys(x))
+            ];
+        }
+
         this.actor.createEmbeddedDocuments('Item', [formData]);
     }
 
     async handleActiveTransformations() {
         const beastformEffects = this.actor.effects.filter(x => x.type === 'beastform');
-        if (beastformEffects.length > 0) {
-            for (let effect of beastformEffects) {
-                await effect.delete();
-            }
-
-            return true;
-        }
-
-        return false;
+        const existingEffects = beastformEffects.length > 0;
+        await this.actor.deleteEmbeddedDocuments(
+            'ActiveEffect',
+            beastformEffects.map(x => x.id)
+        );
+        return existingEffects;
     }
 }

module/data/action/damageAction.mjs

@@ -32,7 +32,7 @@ export default class DHDamageAction extends DHBaseAction {
         if (isNaN(formula)) formula = Roll.replaceFormulaData(formula, this.getRollData(systemData));
 
         const config = {
-            title: game.i18n.format('DAGGERHEART.UI.Chat.damageRoll.title', { damage: this.name }),
+            title: game.i18n.format('DAGGERHEART.UI.Chat.damageRoll.title', { damage: game.i18n.localize(this.name) }),
             roll: { formula },
             targets: systemData.targets.filter(t => t.hit) ?? data.targets,
             hasSave: this.hasSave,

module/data/actor/character.mjs

@@ -3,6 +3,7 @@ import ForeignDocumentUUIDField from '../fields/foreignDocumentUUIDField.mjs';
 import DhLevelData from '../levelData.mjs';
 import BaseDataActor from './base.mjs';
 import { attributeField, resourceField, stressDamageReductionRule, bonusField } from '../fields/actorField.mjs';
+import ActionField from '../fields/actionField.mjs';
 
 export default class DhCharacter extends BaseDataActor {
     static LOCALIZATION_PREFIXES = ['DAGGERHEART.ACTORS.Character'];
@@ -87,8 +88,45 @@ export default class DhCharacter extends BaseDataActor {
                 value: new ForeignDocumentUUIDField({ type: 'Item', nullable: true }),
                 subclass: new ForeignDocumentUUIDField({ type: 'Item', nullable: true })
             }),
-            advantageSources: new fields.ArrayField(new fields.StringField()),
-            disadvantageSources: new fields.ArrayField(new fields.StringField()),
+            attack: new ActionField({
+                initial: {
+                    name: 'DAGGERHEART.GENERAL.unarmedStrike',
+                    img: 'icons/skills/melee/unarmed-punch-fist-yellow-red.webp',
+                    _id: foundry.utils.randomID(),
+                    systemPath: 'attack',
+                    type: 'attack',
+                    range: 'melee',
+                    target: {
+                        type: 'any',
+                        amount: 1
+                    },
+                    roll: {
+                        type: 'attack',
+                        trait: 'strength'
+                    },
+                    damage: {
+                        parts: [
+                            {
+                                type: ['physical'],
+                                value: {
+                                    custom: {
+                                        enabled: true,
+                                        formula: '@system.rules.attack.damage.value'
+                                    }
+                                }
+                            }
+                        ]
+                    }
+                }
+            }),
+            advantageSources: new fields.ArrayField(new fields.StringField(), {
+                label: 'DAGGERHEART.ACTORS.Character.advantageSources.label',
+                hint: 'DAGGERHEART.ACTORS.Character.advantageSources.hint'
+            }),
+            disadvantageSources: new fields.ArrayField(new fields.StringField(), {
+                label: 'DAGGERHEART.ACTORS.Character.disadvantageSources.label',
+                hint: 'DAGGERHEART.ACTORS.Character.disadvantageSources.hint'
+            }),
             levelData: new fields.EmbeddedDataField(DhLevelData),
             bonuses: new fields.SchemaField({
                 roll: new fields.SchemaField({
@@ -161,6 +199,15 @@ export default class DhCharacter extends BaseDataActor {
                     magical: new fields.BooleanField({ initial: false }),
                     physical: new fields.BooleanField({ initial: false })
                 }),
+                attack: new fields.SchemaField({
+                    damage: new fields.SchemaField({
+                        value: new fields.StringField({
+                            required: true,
+                            initial: '@profd4',
+                            label: 'DAGGERHEART.GENERAL.Rules.attack.damage.value.label'
+                        })
+                    })
+                }),
                 weapon: new fields.SchemaField({
                     /*  Unimplemented 
                         -> Should remove the lowest damage dice from weapon damage 
@@ -420,11 +467,14 @@ export default class DhCharacter extends BaseDataActor {
         const data = super.getRollData();
         return {
             ...data,
-            ...this.resources.tokens,
-            ...this.resources.dice,
-            ...this.bonuses,
-            tier: this.tier,
-            level: this.levelData.level.current
+            system: {
+                ...this.resources.tokens,
+                ...this.resources.dice,
+                ...this.bonuses,
+                ...this.rules,
+                tier: this.tier,
+                level: this.levelData.level.current
+            }
         };
     }
 

module/data/item/beastform.mjs

@@ -50,7 +50,11 @@ export default class DHBeastform extends BaseDataItem {
                 initial: CONFIG.DH.ACTOR.abilities.agility.id
             }),
             examples: new fields.StringField(),
-            advantageOn: new fields.ArrayField(new fields.StringField()),
+            advantageOn: new fields.TypedObjectField(
+                new fields.SchemaField({
+                    value: new fields.StringField()
+                })
+            ),
             features: new ForeignDocumentUUIDArrayField({ type: 'Item' }),
             evolved: new fields.SchemaField({
                 maximumTier: new fields.NumberField({
@@ -104,7 +108,13 @@ export default class DHBeastform extends BaseDataItem {
         await beastformEffect.updateSource({
             changes: [
                 ...beastformEffect.changes,
-                { key: 'system.advantageSources', mode: 2, value: this.advantageOn.join(', ') }
+                {
+                    key: 'system.advantageSources',
+                    mode: 2,
+                    value: Object.values(this.advantageOn)
+                        .map(x => x.value)
+                        .join(', ')
+                }
             ],
             system: {
                 characterTokenData: {