148 - Character Setup (#151)

* Added a character setup dialog

* Added optional equipment tab

* Removed temp button to open character setup

* Cleaned up footer from commented code

module/applications/characterCreation.mjs

@@ -0,0 +1,496 @@
+import { abilities } from '../config/actorConfig.mjs';
+import { burden } from '../config/generalConfig.mjs';
+
+const { HandlebarsApplicationMixin, ApplicationV2 } = foundry.applications.api;
+
+export default class DhCharacterCreation extends HandlebarsApplicationMixin(ApplicationV2) {
+    constructor(character) {
+        super({});
+
+        this.character = character;
+
+        this.setup = {
+            traits: this.character.system.traits,
+            ancestry: this.character.system.ancestry ?? {},
+            community: this.character.system.community ?? {},
+            class: this.character.system.class?.value ?? {},
+            subclass: this.character.system.class?.subclass ?? {},
+            experiences: {
+                [foundry.utils.randomID()]: { description: '', value: 2 },
+                [foundry.utils.randomID()]: { description: '', value: 2 }
+            },
+            domainCards: {
+                [foundry.utils.randomID()]: {},
+                [foundry.utils.randomID()]: {}
+            },
+            visibility: 1
+        };
+
+        this.equipment = {
+            armor: {},
+            primaryWeapon: {},
+            secondaryWeapon: {},
+            inventory: {
+                take: {},
+                choiceA: {},
+                choiceB: {}
+            }
+        };
+
+        this._dragDrop = this._createDragDropHandlers();
+    }
+
+    get title() {
+        return game.i18n.format('DAGGERHEART.CharacterCreation.Title', { actor: this.character.name });
+    }
+
+    static DEFAULT_OPTIONS = {
+        tag: 'form',
+        classes: ['daggerheart', 'dialog', 'dh-style', 'character-creation'],
+        position: { width: 800, height: 'auto' },
+        actions: {
+            viewCompendium: this.viewCompendium,
+            viewItem: this.viewItem,
+            useSuggestedTraits: this.useSuggestedTraits,
+            equipmentChoice: this.equipmentChoice,
+            finish: this.finish
+        },
+        form: {
+            handler: this.updateForm,
+            submitOnChange: true,
+            closeOnSubmit: false
+        },
+        dragDrop: [
+            { dragSelector: null, dropSelector: '.ancestry-card' },
+            { dragSelector: null, dropSelector: '.community-card' },
+            { dragSelector: null, dropSelector: '.class-card' },
+            { dragSelector: null, dropSelector: '.subclass-card' },
+            { dragSelector: null, dropSelector: '.domain-card' },
+            { dragSelector: null, dropSelector: '.armor-card' },
+            { dragSelector: null, dropSelector: '.primary-weapon-card' },
+            { dragSelector: null, dropSelector: '.secondary-weapon-card' },
+            { dragSelector: '.suggestion-inner-container', dropSelector: '.selections-container' }
+        ]
+    };
+
+    static PARTS = {
+        tabs: { template: 'systems/daggerheart/templates/views/characterCreation/tabs.hbs' },
+        setup: { template: 'systems/daggerheart/templates/views/characterCreation/tabs/setup.hbs' },
+        equipment: { template: 'systems/daggerheart/templates/views/characterCreation/tabs/equipment.hbs' },
+        // story: { template: 'systems/daggerheart/templates/views/characterCreation/tabs/story.hbs' },
+        footer: { template: 'systems/daggerheart/templates/views/characterCreation/footer.hbs' }
+    };
+
+    static TABS = {
+        setup: {
+            active: true,
+            cssClass: '',
+            group: 'primary',
+            id: 'setup',
+            label: 'DAGGERHEART.CharacterCreation.Tabs.Setup'
+        },
+        equipment: {
+            active: false,
+            cssClass: '',
+            group: 'primary',
+            id: 'equipment',
+            label: 'DAGGERHEART.CharacterCreation.Tabs.Equipment',
+            optional: true
+        }
+        // story: {
+        //     active: false,
+        //     cssClass: '',
+        //     group: 'primary',
+        //     id: 'story',
+        //     label: 'DAGGERHEART.CharacterCreation.Tabs.Story',
+        //     optional: true
+        // }
+    };
+
+    _getTabs(tabs) {
+        for (const v of Object.values(tabs)) {
+            v.active = this.tabGroups[v.group] ? this.tabGroups[v.group] === v.id : v.active;
+            v.cssClass = v.active ? 'active' : '';
+
+            switch (v.id) {
+                case 'setup':
+                    const classFinished = this.setup.class.uuid && this.setup.subclass.uuid;
+                    const heritageFinished = this.setup.ancestry.uuid && this.setup.community.uuid;
+                    const traitsFinished = Object.values(this.setup.traits).every(x => x.value !== null);
+                    const experiencesFinished = Object.values(this.setup.experiences).every(x => x.description);
+                    const domainCardsFinished = Object.values(this.setup.domainCards).every(x => x.uuid);
+                    v.finished =
+                        classFinished &&
+                        heritageFinished &&
+                        traitsFinished &&
+                        experiencesFinished &&
+                        domainCardsFinished;
+                    break;
+                case 'equipment':
+                    const armorFinished = this.equipment.armor?.uuid;
+                    const primaryFinished = this.equipment.primaryWeapon?.uuid;
+                    const secondaryFinished =
+                        this.equipment.secondaryWeapon?.uuid ||
+                        (primaryFinished && this.equipment.primaryWeapon.system.burden == burden.twoHanded.value);
+                    const choiceAFinished = this.equipment.inventory.choiceA?.uuid;
+                    const choiceBFinished = this.equipment.inventory.choiceB?.uuid;
+
+                    v.finished =
+                        armorFinished && primaryFinished && secondaryFinished && choiceAFinished && choiceBFinished;
+            }
+        }
+
+        tabs.equipment.cssClass = tabs.setup.finished ? tabs.equipment.cssClass : 'disabled';
+        // tabs.story.cssClass = tabs.setup.finished ? tabs.story.cssClass : 'disabled';
+
+        return tabs;
+    }
+
+    changeTab(tab, group, options) {
+        super.changeTab(tab, group, options);
+
+        for (var listTab of Object.keys(this.constructor.TABS)) {
+            const marker = options.navElement.querySelector(`a[data-action="tab"].${listTab} .finish-marker`);
+            if (listTab === tab) {
+                marker.classList.add('active');
+            } else {
+                marker.classList.remove('active');
+            }
+        }
+    }
+
+    _attachPartListeners(partId, htmlElement, options) {
+        super._attachPartListeners(partId, htmlElement, options);
+
+        this._dragDrop.forEach(d => d.bind(htmlElement));
+    }
+
+    async _prepareContext(_options) {
+        const context = await super._prepareContext(_options);
+        context.tabs = this._getTabs(this.constructor.TABS);
+
+        return context;
+    }
+
+    async _preparePartContext(partId, context) {
+        switch (partId) {
+            case 'setup':
+                const availableTraitModifiers = game.settings
+                    .get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.Homebrew)
+                    .traitArray.map(trait => ({ key: trait, name: trait }));
+                for (let trait of Object.values(this.setup.traits).filter(x => x.value !== null)) {
+                    const index = availableTraitModifiers.findIndex(x => x.key === trait.value);
+                    if (index !== -1) {
+                        availableTraitModifiers.splice(index, 1);
+                    }
+                }
+
+                context.suggestedTraits = this.setup.class.system
+                    ? Object.keys(this.setup.class.system.characterGuide.suggestedTraits).map(traitKey => {
+                          const trait = this.setup.class.system.characterGuide.suggestedTraits[traitKey];
+                          return `${game.i18n.localize(`DAGGERHEART.Abilities.${traitKey}.short`)} ${trait > 0 ? `+${trait}` : trait}`;
+                      })
+                    : [];
+                context.traits = {
+                    values: Object.keys(this.setup.traits).map(traitKey => {
+                        const trait = this.setup.traits[traitKey];
+                        const options = [...availableTraitModifiers];
+                        if (trait.value !== null && !options.some(x => x.key === trait.value))
+                            options.push({ key: trait.value, name: trait.value });
+
+                        return {
+                            ...trait,
+                            key: traitKey,
+                            name: game.i18n.localize(abilities[traitKey].label),
+                            options: options
+                        };
+                    })
+                };
+                context.traits.nrTotal = Object.keys(context.traits.values).length;
+                context.traits.nrSelected = Object.values(context.traits.values).reduce(
+                    (acc, trait) => acc + (trait.value !== null ? 1 : 0),
+                    0
+                );
+
+                context.experience = {
+                    values: this.setup.experiences,
+                    nrTotal: Object.keys(this.setup.experiences).length,
+                    nrSelected: Object.values(this.setup.experiences).reduce(
+                        (acc, exp) => acc + (exp.description ? 1 : 0),
+                        0
+                    )
+                };
+
+                context.ancestry = { ...this.setup.ancestry, compendium: 'ancestries' };
+                context.community = { ...this.setup.community, compendium: 'communities' };
+                context.class = { ...this.setup.class, compendium: 'classes' };
+                context.subclass = { ...this.setup.subclass, compendium: 'subclasses' };
+                context.domainCards = Object.keys(this.setup.domainCards).reduce((acc, x) => {
+                    acc[x] = { ...this.setup.domainCards[x], compendium: 'domains' };
+                    return acc;
+                }, {});
+
+                context.visibility = this.setup.visibility;
+                break;
+            case 'equipment':
+                const suggestions = await this.getEquipmentSuggestions(
+                    this.equipment.inventory.choiceA,
+                    this.equipment.inventory.choiceB
+                );
+                context.armor = {
+                    ...this.equipment.armor,
+                    suggestion: { ...suggestions.armor, taken: suggestions.armor?.uuid === this.equipment.armor?.uuid },
+                    compendium: 'armors'
+                };
+                context.primaryWeapon = {
+                    ...this.equipment.primaryWeapon,
+                    suggestion: {
+                        ...suggestions.primaryWeapon,
+                        taken: suggestions.primaryWeapon?.uuid === this.equipment.primaryWeapon?.uuid
+                    },
+                    compendium: 'weapons'
+                };
+                context.secondaryWeapon = {
+                    ...this.equipment.secondaryWeapon,
+                    suggestion: {
+                        ...suggestions.secondaryWeapon,
+                        taken: suggestions.secondaryWeapon?.uuid === this.equipment.secondaryWeapon?.uuid
+                    },
+                    disabled: this.equipment.primaryWeapon?.system?.burden === burden.twoHanded.value,
+                    compendium: 'weapons'
+                };
+                context.inventory = {
+                    take: suggestions.inventory.take,
+                    choiceA: { suggestions: suggestions.inventory.choiceA, compendium: 'consumables' },
+                    choiceB: { suggestions: suggestions.inventory.choiceB, compendium: 'general-items' }
+                };
+
+                break;
+        }
+
+        return context;
+    }
+
+    static async updateForm(event, _, formData) {
+        this.setup = foundry.utils.mergeObject(this.setup, formData.object);
+
+        this.setup.visibility = this.getUpdateVisibility();
+        this.render();
+    }
+
+    getUpdateVisibility() {
+        switch (this.setup.visibility) {
+            case 5:
+                return 5;
+            case 4:
+                return Object.values(this.setup.experiences).every(x => x.description) ? 5 : 4;
+            case 3:
+                return Object.values(this.setup.traits).every(x => x.value !== null) ? 4 : 3;
+            case 2:
+                return this.setup.ancestry.uuid && this.setup.community.uuid ? 3 : 2;
+            case 1:
+                return this.setup.class.uuid && this.setup.subclass.uuid ? 2 : 1;
+        }
+    }
+
+    async getEquipmentSuggestions(choiceA, choiceB) {
+        if (!this.setup.class.uuid) return { inventory: { take: [] } };
+
+        const { inventory, characterGuide } = this.setup.class.system;
+        return {
+            armor: characterGuide.suggestedArmor ?? null,
+            primaryWeapon: characterGuide.suggestedPrimaryWeapon ?? null,
+            secondaryWeapon:
+                { ...characterGuide.suggestedSecondaryWeapon, uuid: characterGuide.suggestedSecondaryWeapon.uuid } ??
+                null,
+            inventory: {
+                take: inventory.take ?? [],
+                choiceA:
+                    inventory.choiceA?.map(x => ({ ...x, uuid: x.uuid, selected: x.uuid === choiceA?.uuid })) ?? [],
+                choiceB: inventory.choiceB?.map(x => ({ ...x, uuid: x.uuid, selected: x.uuid === choiceB?.uuid })) ?? []
+            }
+        };
+    }
+
+    _createDragDropHandlers() {
+        return this.options.dragDrop.map(d => {
+            d.callbacks = {
+                dragstart: this._onDragStart.bind(this),
+                drop: this._onDrop.bind(this)
+            };
+            return new foundry.applications.ux.DragDrop.implementation(d);
+        });
+    }
+
+    static async viewCompendium(_, target) {
+        (await game.packs.get(`daggerheart.${target.dataset.compendium}`))?.render(true);
+    }
+
+    static async viewItem(_, target) {
+        (await foundry.utils.fromUuid(target.dataset.uuid)).sheet.render(true);
+    }
+
+    static useSuggestedTraits() {
+        this.setup.traits = Object.keys(this.setup.traits).reduce((acc, traitKey) => {
+            acc[traitKey] = {
+                ...this.setup.traits[traitKey],
+                value: this.setup.class.system.characterGuide.suggestedTraits[traitKey]
+            };
+            return acc;
+        }, {});
+
+        this.setup.visibility = this.getUpdateVisibility();
+        this.render();
+    }
+
+    static async equipmentChoice(_, target) {
+        this.equipment.inventory[target.dataset.path] = await foundry.utils.fromUuid(target.dataset.uuid);
+        this.render();
+    }
+
+    static async finish() {
+        const embeddedAncestries = await this.character.createEmbeddedDocuments('Item', [this.setup.ancestry]);
+        const embeddedCommunities = await this.character.createEmbeddedDocuments('Item', [this.setup.community]);
+        await this.character.createEmbeddedDocuments('Item', [this.setup.class]);
+        await this.character.createEmbeddedDocuments('Item', [this.setup.subclass]);
+        await this.character.createEmbeddedDocuments('Item', Object.values(this.setup.domainCards));
+
+        if (this.equipment.armor.uuid)
+            await this.character.createEmbeddedDocuments('Item', [
+                { ...this.equipment.armor, system: { ...this.equipment.armor.system, equipped: true } }
+            ]);
+        if (this.equipment.primaryWeapon.uuid)
+            await this.character.createEmbeddedDocuments('Item', [
+                { ...this.equipment.primaryWeapon, system: { ...this.equipment.primaryWeapon.system, equipped: true } }
+            ]);
+        if (this.equipment.secondaryWeapon.uuid)
+            await this.character.createEmbeddedDocuments('Item', [
+                {
+                    ...this.equipment.secondaryWeapon,
+                    system: { ...this.equipment.secondaryWeapon.system, equipped: true }
+                }
+            ]);
+        if (this.equipment.inventory.choiceA.uuid)
+            await this.character.createEmbeddedDocuments('Item', [this.equipment.inventory.choiceA]);
+        if (this.equipment.inventory.choiceB.uuid)
+            await this.character.createEmbeddedDocuments('Item', [this.equipment.inventory.choiceB]);
+        await this.character.createEmbeddedDocuments('Item', this.setup.class.system.inventory.take);
+
+        await this.character.update({
+            system: {
+                traits: this.setup.traits,
+                experiences: this.setup.experiences,
+                ancestry: embeddedAncestries[0].uuid,
+                community: embeddedCommunities[0].uuid
+            }
+        });
+
+        this.close();
+    }
+
+    async _onDragStart(event) {
+        const target = event.currentTarget;
+
+        event.dataTransfer.setData('text/plain', JSON.stringify(target.dataset));
+        event.dataTransfer.setDragImage(target, 60, 0);
+    }
+
+    async _onDrop(event) {
+        const data = TextEditor.getDragEventData(event);
+        const item = await foundry.utils.fromUuid(data.uuid);
+        if (item.type === 'ancestry' && event.target.closest('.ancestry-card')) {
+            this.setup.ancestry = { ...item, uuid: item.uuid };
+        } else if (item.type === 'community' && event.target.closest('.community-card')) {
+            this.setup.community = { ...item, uuid: item.uuid };
+        } else if (item.type === 'class' && event.target.closest('.class-card')) {
+            this.setup.class = { ...item, uuid: item.uuid };
+            this.setup.subclass = {};
+            this.setup.domainCards = {
+                [foundry.utils.randomID()]: {},
+                [foundry.utils.randomID()]: {}
+            };
+        } else if (item.type === 'subclass' && event.target.closest('.subclass-card')) {
+            if (this.setup.class.system.subclasses.every(subclass => subclass.uuid !== item.uuid)) {
+                ui.notifications.error(
+                    game.i18n.localize('DAGGERHEART.CharacterCreation.Notifications.SubclassNotInClass')
+                );
+                return;
+            }
+
+            this.setup.subclass = { ...item, uuid: item.uuid };
+        } else if (item.type === 'domainCard' && event.target.closest('.domain-card')) {
+            if (!this.setup.class.uuid) {
+                ui.notifications.error(game.i18n.localize('DAGGERHEART.CharacterCreation.Notifications.MissingClass'));
+                return;
+            }
+
+            if (!this.setup.class.system.domains.includes(item.system.domain)) {
+                ui.notifications.error(game.i18n.localize('DAGGERHEART.CharacterCreation.Notifications.WrongDomain'));
+                return;
+            }
+
+            if (item.system.level > 1) {
+                ui.notifications.error(
+                    game.i18n.localize('DAGGERHEART.CharacterCreation.Notifications.CardTooHighLevel')
+                );
+                return;
+            }
+
+            if (Object.values(this.setup.domainCards).some(card => card.uuid === item.uuid)) {
+                ui.notifications.error(game.i18n.localize('DAGGERHEART.CharacterCreation.Notifications.DuplicateCard'));
+                return;
+            }
+
+            this.setup.domainCards[event.target.closest('.domain-card').dataset.card] = { ...item, uuid: item.uuid };
+        } else if (item.type === 'armor' && event.target.closest('.armor-card')) {
+            if (item.system.tier > 1) {
+                ui.notifications.error(
+                    game.i18n.localize('DAGGERHEART.CharacterCreation.Notifications.ItemTooHighTier')
+                );
+                return;
+            }
+
+            this.equipment.armor = { ...item, uuid: item.uuid };
+        } else if (item.type === 'weapon' && event.target.closest('.primary-weapon-card')) {
+            if (item.system.secondary) {
+                ui.notifications.error(game.i18n.localize('DAGGERHEART.CharacterCreation.Notifications.NotPrimary'));
+                return;
+            }
+
+            if (item.system.tier > 1) {
+                ui.notifications.error(
+                    game.i18n.localize('DAGGERHEART.CharacterCreation.Notifications.ItemTooHighTier')
+                );
+                return;
+            }
+
+            this.equipment.primaryWeapon = { ...item, uuid: item.uuid };
+        } else if (item.type === 'weapon' && event.target.closest('.secondary-weapon-card')) {
+            if (this.equipment.primaryWeapon?.system?.burden === burden.twoHanded.value) {
+                ui.notifications.error(
+                    game.i18n.localize('DAGGERHEART.CharacterCreation.Notifications.PrimaryIsTwoHanded')
+                );
+                return;
+            }
+
+            if (!item.system.secondary) {
+                ui.notifications.error(game.i18n.localize('DAGGERHEART.CharacterCreation.Notifications.NotSecondary'));
+                return;
+            }
+
+            if (item.system.tier > 1) {
+                ui.notifications.error(
+                    game.i18n.localize('DAGGERHEART.CharacterCreation.Notifications.ItemTooHighTier')
+                );
+                return;
+            }
+
+            this.equipment.secondaryWeapon = { ...item, uuid: item.uuid };
+        } else {
+            return;
+        }
+
+        this.setup.visibility = this.getUpdateVisibility();
+        this.render();
+    }
+}

module/applications/sheets/activeEffectConfig.mjs

@@ -1,4 +1,4 @@
-export default class DhActiveEffectConfig extends ActiveEffectConfig {
+export default class DhActiveEffectConfig extends foundry.applications.sheets.ActiveEffectConfig {
     static DEFAULT_OPTIONS = {
         classes: ['daggerheart', 'sheet', 'dh-style']
     };

module/applications/sheets/items/class.mjs

@@ -221,46 +221,53 @@ export default class ClassSheet extends DaggerheartSheet(ItemSheetV2) {
     async _onDrop(event) {
         const data = TextEditor.getDragEventData(event);
         const item = await fromUuid(data.uuid);
+        const target = event.target.closest('fieldset.drop-section');
         if (item.type === 'subclass') {
             await this.document.update({
                 'system.subclasses': [...this.document.system.subclasses.map(x => x.uuid), item.uuid]
             });
         } else if (item.type === 'weapon') {
-            if (event.currentTarget.classList.contains('primary-weapon-section')) {
+            if (target.classList.contains('primary-weapon-section')) {
                 if (!this.document.system.characterGuide.suggestedPrimaryWeapon && !item.system.secondary)
                     await this.document.update({
                         'system.characterGuide.suggestedPrimaryWeapon': item.uuid
                     });
-            } else if (event.currentTarget.classList.contains('secondary-weapon-section')) {
+            } else if (target.classList.contains('secondary-weapon-section')) {
                 if (!this.document.system.characterGuide.suggestedSecondaryWeapon && item.system.secondary)
                     await this.document.update({
                         'system.characterGuide.suggestedSecondaryWeapon': item.uuid
                     });
             }
         } else if (item.type === 'armor') {
-            if (event.currentTarget.classList.contains('armor-section')) {
+            if (target.classList.contains('armor-section')) {
                 if (!this.document.system.characterGuide.suggestedArmor)
                     await this.document.update({
                         'system.characterGuide.suggestedArmor': item.uuid
                     });
             }
-        } else if (event.currentTarget.classList.contains('choice-a-section')) {
+        } else if (target.classList.contains('choice-a-section')) {
             if (item.type === 'miscellaneous' || item.type === 'consumable') {
                 if (this.document.system.inventory.choiceA.length < 2)
                     await this.document.update({
-                        'system.inventory.choiceA': [...this.document.system.inventory.choiceA, item.uuid]
+                        'system.inventory.choiceA': [
+                            ...this.document.system.inventory.choiceA.map(x => x.uuid),
+                            item.uuid
+                        ]
                     });
             }
         } else if (item.type === 'miscellaneous') {
-            if (event.currentTarget.classList.contains('take-section')) {
+            if (target.classList.contains('take-section')) {
                 if (this.document.system.inventory.take.length < 3)
                     await this.document.update({
-                        'system.inventory.take': [...this.document.system.inventory.take, item.uuid]
+                        'system.inventory.take': [...this.document.system.inventory.take.map(x => x.uuid), item.uuid]
                     });
-            } else if (event.currentTarget.classList.contains('choice-b-section')) {
+            } else if (target.classList.contains('choice-b-section')) {
                 if (this.document.system.inventory.choiceB.length < 2)
                     await this.document.update({
-                        'system.inventory.choiceB': [...this.document.system.inventory.choiceB, item.uuid]
+                        'system.inventory.choiceB': [
+                            ...this.document.system.inventory.choiceB.map(x => x.uuid),
+                            item.uuid
+                        ]
                     });
             }
         }