159 - Companion (#224)

* Initial datamodel

* Fixed attack

* Temp

* Fixed normal levelup

* Fixed showing summary of new experiences

* Touchups

* level sync fixes

* Reworked Action storage

* Companions now take stress when damaged

* Fixed Feature flow

* Removed retroactive companion levelup

* Restored delevel on partner removal

* PR fixes

* Added a check for card duplicates on character

module/data/actor/_module.mjs

@@ -1,11 +1,13 @@
 import DhCharacter from './character.mjs';
+import DhCompanion from './companion.mjs';
 import DhAdversary from './adversary.mjs';
 import DhEnvironment from './environment.mjs';
 
-export { DhCharacter, DhAdversary, DhEnvironment };
+export { DhCharacter, DhCompanion, DhAdversary, DhEnvironment };
 
 export const config = {
     character: DhCharacter,
+    companion: DhCompanion,
     adversary: DhAdversary,
     environment: DhEnvironment
 };

module/data/actor/character.mjs

@@ -1,6 +1,7 @@
 import { burden } from '../../config/generalConfig.mjs';
+import ActionField from '../fields/actionField.mjs';
 import ForeignDocumentUUIDField from '../fields/foreignDocumentUUIDField.mjs';
-import { LevelOptionType } from '../levelTier.mjs';
+import DhLevelData from '../levelData.mjs';
 import BaseDataActor from './base.mjs';
 
 const attributeField = () =>
@@ -96,7 +97,8 @@ export default class DhCharacter extends BaseDataActor {
                 value: new ForeignDocumentUUIDField({ type: 'Item', nullable: true }),
                 subclass: new ForeignDocumentUUIDField({ type: 'Item', nullable: true })
             }),
-            levelData: new fields.EmbeddedDataField(DhPCLevelData),
+            actions: new fields.ArrayField(new ActionField()),
+            levelData: new fields.EmbeddedDataField(DhLevelData),
             bonuses: new fields.SchemaField({
                 armorScore: new fields.NumberField({ integer: true, initial: 0 }),
                 damageThresholds: new fields.SchemaField({
@@ -115,6 +117,7 @@ export default class DhCharacter extends BaseDataActor {
                     magic: new fields.NumberField({ integer: true, initial: 0 })
                 })
             }),
+            companion: new ForeignDocumentUUIDField({ type: 'Actor', nullable: true, initial: null }),
             rules: new fields.SchemaField({
                 maxArmorMarked: new fields.SchemaField({
                     value: new fields.NumberField({ required: true, integer: true, initial: 1 }),
@@ -154,10 +157,25 @@ export default class DhCharacter extends BaseDataActor {
         return this.parent.items.find(x => x.type === 'community') ?? null;
     }
 
+    get features() {
+        return this.parent.items.filter(x => x.type === 'feature') ?? [];
+    }
+
+    get companionFeatures() {
+        return this.companion ? this.companion.items.filter(x => x.type === 'feature') : [];
+    }
+
     get needsCharacterSetup() {
         return !this.class.value || !this.class.subclass;
     }
 
+    get spellcastingModifiers() {
+        return {
+            main: this.class.subclass?.system?.spellcastingTrait,
+            multiclass: this.multiclass.subclass?.system?.spellcastingTrait
+        };
+    }
+
     get domains() {
         const classDomains = this.class.value ? this.class.value.system.domains : [];
         const multiclassDomains = this.multiclass.value ? this.multiclass.value.system.domains : [];
@@ -197,6 +215,12 @@ export default class DhCharacter extends BaseDataActor {
               : null;
     }
 
+    get deathMoveViable() {
+        return (
+            this.resources.hitPoints.maxTotal > 0 && this.resources.hitPoints.value >= this.resources.hitPoints.maxTotal
+        );
+    }
+
     static async unequipBeforeEquip(itemToEquip) {
         const primary = this.primaryWeapon,
             secondary = this.secondaryWeapon;
@@ -307,58 +331,10 @@ export default class DhCharacter extends BaseDataActor {
             level: this.levelData.level.current
         };
     }
-}
 
-class DhPCLevelData extends foundry.abstract.DataModel {
-    static defineSchema() {
-        const fields = foundry.data.fields;
-
-        return {
-            level: new fields.SchemaField({
-                current: new fields.NumberField({ required: true, integer: true, initial: 1 }),
-                changed: new fields.NumberField({ required: true, integer: true, initial: 1 })
-            }),
-            levelups: new fields.TypedObjectField(
-                new fields.SchemaField({
-                    achievements: new fields.SchemaField(
-                        {
-                            experiences: new fields.TypedObjectField(
-                                new fields.SchemaField({
-                                    name: new fields.StringField({ required: true }),
-                                    modifier: new fields.NumberField({ required: true, integer: true })
-                                })
-                            ),
-                            domainCards: new fields.ArrayField(
-                                new fields.SchemaField({
-                                    uuid: new fields.StringField({ required: true }),
-                                    itemUuid: new fields.StringField({ required: true })
-                                })
-                            ),
-                            proficiency: new fields.NumberField({ integer: true })
-                        },
-                        { nullable: true, initial: null }
-                    ),
-                    selections: new fields.ArrayField(
-                        new fields.SchemaField({
-                            tier: new fields.NumberField({ required: true, integer: true }),
-                            level: new fields.NumberField({ required: true, integer: true }),
-                            optionKey: new fields.StringField({ required: true }),
-                            type: new fields.StringField({ required: true, choices: LevelOptionType }),
-                            checkboxNr: new fields.NumberField({ required: true, integer: true }),
-                            value: new fields.NumberField({ integer: true }),
-                            minCost: new fields.NumberField({ integer: true }),
-                            amount: new fields.NumberField({ integer: true }),
-                            data: new fields.ArrayField(new fields.StringField({ required: true })),
-                            secondaryData: new fields.TypedObjectField(new fields.StringField({ required: true })),
-                            itemUuid: new fields.StringField({ required: true })
-                        })
-                    )
-                })
-            )
-        };
-    }
-
-    get canLevelUp() {
-        return this.level.current < this.level.changed;
+    async _preDelete() {
+        if (this.companion) {
+            this.companion.updateLevel(1);
+        }
     }
 }

module/data/actor/companion.mjs

@@ -0,0 +1,139 @@
+import BaseDataActor from './base.mjs';
+import DhLevelData from '../levelData.mjs';
+import ForeignDocumentUUIDField from '../fields/foreignDocumentUUIDField.mjs';
+import ActionField from '../fields/actionField.mjs';
+import { adjustDice, adjustRange } from '../../helpers/utils.mjs';
+
+export default class DhCompanion extends BaseDataActor {
+    static LOCALIZATION_PREFIXES = ['DAGGERHEART.Sheets.Companion'];
+
+    static get metadata() {
+        return foundry.utils.mergeObject(super.metadata, {
+            label: 'TYPES.Actor.companion',
+            type: 'companion'
+        });
+    }
+
+    static defineSchema() {
+        const fields = foundry.data.fields;
+
+        return {
+            partner: new ForeignDocumentUUIDField({ type: 'Actor' }),
+            resources: new fields.SchemaField({
+                stress: new fields.SchemaField({
+                    value: new fields.NumberField({ initial: 0, integer: true }),
+                    bonus: new fields.NumberField({ initial: 0, integer: true }),
+                    max: new fields.NumberField({ initial: 3, integer: true })
+                }),
+                hope: new fields.NumberField({ initial: 0, integer: true })
+            }),
+            evasion: new fields.SchemaField({
+                value: new fields.NumberField({ required: true, min: 1, initial: 10, integer: true }),
+                bonus: new fields.NumberField({ initial: 0, integer: true })
+            }),
+            experiences: new fields.TypedObjectField(
+                new fields.SchemaField({
+                    name: new fields.StringField({}),
+                    value: new fields.NumberField({ integer: true, initial: 0 }),
+                    bonus: new fields.NumberField({ integer: true, initial: 0 })
+                }),
+                {
+                    initial: {
+                        experience1: { value: 2 },
+                        experience2: { value: 2 }
+                    }
+                }
+            ),
+            attack: new ActionField({
+                initial: {
+                    name: 'Attack',
+                    _id: foundry.utils.randomID(),
+                    systemPath: 'attack',
+                    type: 'attack',
+                    range: 'melee',
+                    target: {
+                        type: 'any',
+                        amount: 1
+                    },
+                    roll: {
+                        type: 'weapon',
+                        bonus: 0
+                    },
+                    damage: {
+                        parts: [
+                            {
+                                multiplier: 'flat',
+                                value: {
+                                    dice: 'd6',
+                                    multiplier: 'flat'
+                                }
+                            }
+                        ]
+                    }
+                }
+            }),
+            actions: new fields.ArrayField(new ActionField()),
+            levelData: new fields.EmbeddedDataField(DhLevelData)
+        };
+    }
+
+    get attackBonus() {
+        return this.attack.roll.bonus ?? 0;
+    }
+
+    prepareBaseData() {
+        const partnerSpellcastingModifier = this.partner?.system?.spellcastingModifiers?.main;
+        const spellcastingModifier = this.partner?.system?.traits?.[partnerSpellcastingModifier]?.total;
+        this.attack.roll.bonus = spellcastingModifier ?? 0; // Needs to expand on which modifier it is that should be used because of multiclassing;
+
+        for (let levelKey in this.levelData.levelups) {
+            const level = this.levelData.levelups[levelKey];
+            for (let selection of level.selections) {
+                switch (selection.type) {
+                    case 'hope':
+                        this.resources.hope += selection.value;
+                        break;
+                    case 'vicious':
+                        if (selection.data[0] === 'damage') {
+                            this.attack.damage.parts[0].value.dice = adjustDice(this.attack.damage.parts[0].value.dice);
+                        } else {
+                            this.attack.range = adjustRange(this.attack.range);
+                        }
+                        break;
+                    case 'stress':
+                        this.resources.stress.bonus += selection.value;
+                        break;
+                    case 'evasion':
+                        this.evasion.bonus += selection.value;
+                        break;
+                    case 'experience':
+                        Object.keys(this.experiences).forEach(key => {
+                            const experience = this.experiences[key];
+                            experience.bonus += selection.value;
+                        });
+                        break;
+                }
+            }
+        }
+    }
+
+    prepareDerivedData() {
+        for (var experienceKey in this.experiences) {
+            var experience = this.experiences[experienceKey];
+            experience.total = experience.value + experience.bonus;
+        }
+
+        if (this.partner) {
+            this.partner.system.resources.hope.max += this.resources.hope;
+        }
+
+        this.resources.stress.maxTotal = this.resources.stress.max + this.resources.stress.bonus;
+        this.evasion.total = this.evasion.value + this.evasion.bonus;
+    }
+
+    async _preDelete() {
+        if (this.partner) {
+            await this.partner.update({ 'system.companion': null });
+        }
+    }
+}