Changed so companion can level up on its own (#879)

module/data/actor/character.mjs

@@ -602,7 +602,20 @@ export default class DhCharacter extends BaseDataActor {
     }
 
     prepareDerivedData() {
-        const baseHope = this.resources.hope.value + (this.companion?.system?.resources?.hope ?? 0);
+        let baseHope = this.resources.hope.value;
+        if (this.companion) {
+            for (let levelKey in this.companion.system.levelData.levelups) {
+                const level = this.companion.system.levelData.levelups[levelKey];
+                for (let selection of level.selections) {
+                    switch (selection.type) {
+                        case 'hope':
+                            this.resources.hope.max += selection.value;
+                            break;
+                    }
+                }
+            }
+        }
+
         this.resources.hope.value = Math.min(baseHope, this.resources.hope.max);
         this.attack.roll.trait = this.rules.attack.roll.trait ?? this.attack.roll.trait;
 

module/data/actor/companion.mjs

@@ -40,12 +40,14 @@ export default class DhCompanion extends BaseDataActor {
             experiences: new fields.TypedObjectField(
                 new fields.SchemaField({
                     name: new fields.StringField({}),
-                    value: new fields.NumberField({ integer: true, initial: 0 })
+                    value: new fields.NumberField({ integer: true, initial: 0 }),
+                    description: new fields.StringField(),
+                    core: new fields.BooleanField({ initial: false })
                 }),
                 {
                     initial: {
-                        experience1: { value: 2 },
-                        experience2: { value: 2 }
+                        experience1: { value: 2, core: true },
+                        experience2: { value: 2, core: true }
                     }
                 }
             ),
@@ -134,6 +136,23 @@ export default class DhCompanion extends BaseDataActor {
         }
     }
 
+    async _preUpdate(changes, options, userId) {
+        const allowed = await super._preUpdate(changes, options, userId);
+        if (allowed === false) return;
+
+        /* The first two experiences are always marked as core */
+        if (changes.system?.experiences && Object.keys(this.experiences).length < 2) {
+            const experiences = new Set(Object.keys(this.experiences));
+            const changeExperiences = new Set(Object.keys(changes.system.experiences));
+            const newExperiences = Array.from(changeExperiences.difference(experiences));
+
+            for (var i = 0; i < Math.min(newExperiences.length, 2 - experiences.size); i++) {
+                const experience = newExperiences[i];
+                changes.system.experiences[experience].core = true;
+            }
+        }
+    }
+
     async _preDelete() {
         if (this.partner) {
             await this.partner.update({ 'system.companion': null });

module/data/levelTier.mjs

@@ -404,7 +404,27 @@ export const defaultCompanionTier = {
                 start: 2,
                 end: 10
             },
-            initialAchievements: {},
+            initialAchievements: {
+                experience: {
+                    nr: 1,
+                    modifier: 2
+                }
+            },
+            /* Improved this. Quick solution for companions */
+            extraAchievements: {
+                5: {
+                    experience: {
+                        nr: 1,
+                        modifier: 2
+                    }
+                },
+                8: {
+                    experience: {
+                        nr: 1,
+                        modifier: 2
+                    }
+                }
+            },
             availableOptions: 1,
             domainCardByLevel: 0,
             options: {

module/data/levelup.mjs

@@ -26,6 +26,7 @@ export class DhLevelup extends foundry.abstract.DataModel {
                               return acc;
                           }, {})
                         : {};
+
                     const domainCards = [...Array(tier.domainCardByLevel).keys()].reduce((acc, _) => {
                         const id = foundry.utils.randomID();
                         acc[id] = { uuid: null, itemUuid: null, level: i };
@@ -42,6 +43,20 @@ export class DhLevelup extends foundry.abstract.DataModel {
                 belongingLevels.push(i);
             }
 
+            /* Improve. Temporary handling for Companion new experiences */
+            Object.keys(tier.extraAchievements ?? {}).forEach(key => {
+                const level = Number(key);
+                if (level >= startLevel && level <= endLevel) {
+                    const levelExtras = tier.extraAchievements[level];
+                    if (levelExtras.experience) {
+                        levels[level].achievements.experiences[foundry.utils.randomID()] = {
+                            name: '',
+                            modifier: levelExtras.experience.modifier
+                        };
+                    }
+                }
+            });
+
             tiers[key] = {
                 name: tier.name,
                 belongingLevels: belongingLevels,