Duality Roll Followup (#65)

* Moved the roll total to bottom right. A bunch of label fixes
* Fixed broken attack-roll damage button
* Added AppearanceMenu allowing modification of DiceSoNice Duality presets

module/applications/chatMessage.mjs

@@ -1,5 +1,5 @@
-import { DualityRollColor } from '../config/settingsConfig.mjs';
 import DhpDualityRoll from '../data/dualityRoll.mjs';
+import { DualityRollColor } from '../data/settings/Appearance.mjs';
 
 export default class DhpChatMesssage extends ChatMessage {
     async renderHTML() {
@@ -16,7 +16,7 @@ export default class DhpChatMesssage extends ChatMessage {
         const html = await super.renderHTML();
         if (
             this.type === 'dualityRoll' &&
-            game.settings.get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.DualityRollColor) ===
+            game.settings.get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.appearance).dualityColorScheme ===
                 DualityRollColor.colorful.value
         ) {
             html.classList.add('duality');

module/applications/settings.mjs

@@ -1,4 +1,5 @@
-import { DualityRollColor } from '../config/settingsConfig.mjs';
+import DhAppearance from '../data/settings/Appearance.mjs';
+import DHAppearanceSettings from './settings/appearanceSettings.mjs';
 
 class DhpAutomationSettings extends FormApplication {
     constructor(object = {}, options = {}) {
@@ -160,7 +161,7 @@ class DhpRangeSettings extends FormApplication {
     }
 }
 
-export const registerDHPSettings = () => {
+export const registerDHSettings = () => {
     // const debouncedReload = foundry.utils.debounce(() => window.location.reload(), 100);
 
     game.settings.register(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.General.AbilityArray, {
@@ -215,14 +216,11 @@ export const registerDHPSettings = () => {
         }
     });
 
-    game.settings.register(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.DualityRollColor, {
-        name: game.i18n.localize('DAGGERHEART.Settings.DualityRollColor.Name'),
-        hint: game.i18n.localize('DAGGERHEART.Settings.DualityRollColor.Hint'),
-        scope: 'world',
-        config: true,
-        type: Number,
-        choices: Object.values(DualityRollColor),
-        default: DualityRollColor.colorful.value
+    game.settings.register(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.appearance, {
+        scope: 'client',
+        config: false,
+        type: DhAppearance,
+        default: DhAppearance.defaultSchema
     });
 
     game.settings.registerMenu(SYSTEM.id, SYSTEM.SETTINGS.menu.Automation.Name, {
@@ -249,53 +247,13 @@ export const registerDHPSettings = () => {
         type: DhpRangeSettings,
         restricted: true
     });
+
+    game.settings.registerMenu(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.appearance, {
+        name: game.i18n.localize('DAGGERHEART.Settings.Menu.Appearance.title'),
+        label: game.i18n.localize('DAGGERHEART.Settings.Menu.Appearance.label'),
+        hint: game.i18n.localize('DAGGERHEART.Settings.Menu.Appearance.hint'),
+        icon: 'fa-solid fa-palette',
+        type: DHAppearanceSettings,
+        restricted: false
+    });
 };
-
-// const {HandlebarsApplicationMixin, ApplicationV2} = foundry.applications.api;
-
-// export default class DhpSettings extends HandlebarsApplicationMixin(ApplicationV2) {
-//     constructor(actor, shortrest){
-//         super({});
-
-//         this.actor = actor;
-//         this.selectedActivity = null;
-//         this.shortrest = shortrest;
-
-//         this.customActivity = SYSTEM.GENERAL.downtime.custom;
-//     }
-
-//     get title(){
-//         return game.i18n.localize("DAGGERHEART.Application.Settings.Title");
-//     }
-
-//     static DEFAULT_OPTIONS = {
-//         tag: 'form',
-//         classes: ["daggerheart", "application", "settings"],
-//         position: { width: 800, height: 'auto' },
-//         actions: {
-//             selectActivity: this.selectActivity,
-//         },
-//         form: { handler: this.updateData }
-//     };
-
-//     static PARTS = {
-//         application: {
-//             id: "settings",
-//             template: "systems/daggerheart/templates/application/settings.hbs"
-//         }
-//     }
-
-//     async _prepareContext(_options) {
-//         const context = await super._prepareContext(_options);
-
-//         return context;
-//     }
-
-//     static async updateData(event, element, formData){
-//         this.render();
-//     }
-
-//     static close(){
-//         super.close();
-//     }
-// }

module/applications/settings/appearanceSettings.mjs

@@ -0,0 +1,59 @@
+import DhAppearance from '../../data/settings/Appearance.mjs';
+
+const { HandlebarsApplicationMixin, ApplicationV2 } = foundry.applications.api;
+
+export default class DHAppearanceSettings extends HandlebarsApplicationMixin(ApplicationV2) {
+    constructor() {
+        super({});
+
+        this.settings = new DhAppearance(
+            game.settings.get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.appearance).toObject()
+        );
+    }
+
+    get title() {
+        return game.i18n.localize('DAGGERHEART.Settings.Menu.Appearance.name');
+    }
+
+    static DEFAULT_OPTIONS = {
+        tag: 'form',
+        id: 'daggerheart-appearance-settings',
+        classes: ['daggerheart', 'setting', 'dh-style'],
+        position: { width: '600', height: 'auto' },
+        actions: {
+            reset: this.reset,
+            save: this.save
+        },
+        form: { handler: this.updateData, submitOnChange: true }
+    };
+
+    static PARTS = {
+        main: {
+            template: 'systems/daggerheart/templates/settings/appearance-settings.hbs'
+        }
+    };
+
+    async _prepareContext(_options) {
+        const context = await super._prepareContext(_options);
+        context.settingFields = this.settings;
+
+        return context;
+    }
+
+    static async updateData(event, element, formData) {
+        const updatedSettings = foundry.utils.expandObject(formData.object);
+
+        await this.settings.updateSource(updatedSettings);
+        this.render();
+    }
+
+    static async reset() {
+        this.settings = new DhAppearance();
+        this.render();
+    }
+
+    static async save() {
+        await game.settings.set(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.appearance, this.settings.toObject());
+        this.close();
+    }
+}

module/applications/sheets/pc.mjs

@@ -489,7 +489,7 @@ export default class PCSheet extends DaggerheartSheet(ActorSheetV2) {
 
     static async rollAttribute(event, button) {
         const { roll, hope, fear, advantage, disadvantage, modifiers } = await this.document.dualityRoll(
-            { title: 'Attribute Bonus', value: button.dataset.value },
+            { title: game.i18n.localize(abilities[button.dataset.attribute].label), value: button.dataset.value },
             event.shiftKey
         );
 

module/config/generalConfig.mjs

@@ -247,6 +247,45 @@ export const diceTypes = {
     d20: 'd20'
 };
 
+export const getDiceSoNicePresets = () => {
+    const { diceSoNice } = game.settings.get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.appearance);
+
+    return {
+        hope: {
+            ...diceSoNice.hope,
+            colorset: 'inspired',
+            texture: 'bloodmoon',
+            material: 'metal',
+            font: 'Arial Black',
+            system: 'standard'
+        },
+        fear: {
+            ...diceSoNice.fear,
+            colorset: 'bloodmoon',
+            texture: 'bloodmoon',
+            material: 'metal',
+            font: 'Arial Black',
+            system: 'standard'
+        },
+        advantage: {
+            ...diceSoNice.advantage,
+            colorset: 'bloodmoon',
+            texture: 'bloodmoon',
+            material: 'metal',
+            font: 'Arial Black',
+            system: 'standard'
+        },
+        disadvantage: {
+            ...diceSoNice.disadvantage,
+            colorset: 'bloodmoon',
+            texture: 'bloodmoon',
+            material: 'metal',
+            font: 'Arial Black',
+            system: 'standard'
+        }
+    };
+};
+
 export const refreshTypes = {
     session: {
         id: 'session',

module/config/settingsConfig.mjs

@@ -25,16 +25,5 @@ export const gameSettings = {
         AbilityArray: 'AbilityArray',
         RangeMeasurement: 'RangeMeasurement'
     },
-    DualityRollColor: 'DualityRollColor'
-};
-
-export const DualityRollColor = {
-    colorful: {
-        value: 0,
-        label: 'DAGGERHEART.Settings.DualityRollColor.Options.Colorful'
-    },
-    normal: {
-        value: 1,
-        label: 'DAGGERHEART.Settings.DualityRollColor.Options.Normal'
-    }
+    appearance: 'Appearance'
 };

module/data/dualityRoll.mjs

@@ -1,4 +1,4 @@
-import { DualityRollColor } from '../config/settingsConfig.mjs';
+import { DualityRollColor } from './settings/Appearance.mjs';
 
 const fields = foundry.data.fields;
 const diceField = () =>
@@ -81,7 +81,7 @@ export default class DhpDualityRoll extends foundry.abstract.TypeDataModel {
         const total = this.modifiers.reduce((acc, x) => acc + x.value, 0);
         return {
             value: total,
-            label: total > 0 ? `+${total}` : total < 0 ? `-${total}` : ''
+            label: total > 0 ? `+${total}` : total < 0 ? `${total}` : ''
         };
     }
 
@@ -106,7 +106,7 @@ export default class DhpDualityRoll extends foundry.abstract.TypeDataModel {
 
     get colorful() {
         return (
-            game.settings.get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.DualityRollColor) ===
+            game.settings.get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.appearance).dualityColorScheme ===
             DualityRollColor.colorful.value
         );
     }

module/data/settings/Appearance.mjs

@@ -0,0 +1,51 @@
+export default class DhAppearance extends foundry.abstract.DataModel {
+    static defineSchema() {
+        const fields = foundry.data.fields;
+        return {
+            dualityColorScheme: new fields.StringField({
+                required: true,
+                choices: DualityRollColor,
+                initial: DualityRollColor.normal.value
+            }),
+            diceSoNice: new fields.SchemaField({
+                hope: new fields.SchemaField({
+                    foreground: new fields.ColorField({ required: true, initial: '#ffffff' }),
+                    background: new fields.ColorField({ required: true, initial: '#ffe760' }),
+                    outline: new fields.ColorField({ required: true, initial: '#000000' }),
+                    edge: new fields.ColorField({ required: true, initial: '#ffffff' })
+                }),
+                fear: new fields.SchemaField({
+                    foreground: new fields.ColorField({ required: true, initial: '#000000' }),
+                    background: new fields.ColorField({ required: true, initial: '#0032b1' }),
+                    outline: new fields.ColorField({ required: true, initial: '#ffffff' }),
+                    edge: new fields.ColorField({ required: true, initial: '#000000' })
+                }),
+                advantage: new fields.SchemaField({
+                    foreground: new fields.ColorField({ required: true, initial: '#ffffff' }),
+                    background: new fields.ColorField({ required: true, initial: '#008000' }),
+                    outline: new fields.ColorField({ required: true, initial: '#000000' }),
+                    edge: new fields.ColorField({ required: true, initial: '#ffffff' })
+                }),
+                disadvantage: new fields.SchemaField({
+                    foreground: new fields.ColorField({ required: true, initial: '#000000' }),
+                    background: new fields.ColorField({ required: true, initial: '#b30000' }),
+                    outline: new fields.ColorField({ required: true, initial: '#ffffff' }),
+                    edge: new fields.ColorField({ required: true, initial: '#000000' })
+                })
+            })
+        };
+    }
+
+    static defaultSchema = {};
+}
+
+export const DualityRollColor = {
+    colorful: {
+        value: 'colorful',
+        label: 'DAGGERHEART.Settings.DualityRollColor.Options.Colorful'
+    },
+    normal: {
+        value: 'normal',
+        label: 'DAGGERHEART.Settings.DualityRollColor.Options.Normal'
+    }
+};

module/documents/actor.mjs

@@ -2,6 +2,7 @@ import DamageSelectionDialog from '../applications/damageSelectionDialog.mjs';
 import NpcRollSelectionDialog from '../applications/npcRollSelectionDialog.mjs';
 import RollSelectionDialog from '../applications/rollSelectionDialog.mjs';
 import { GMUpdateEvent, socketEvent } from '../helpers/socket.mjs';
+import { setDiceSoNiceForDualityRoll } from '../helpers/utils.mjs';
 
 export default class DhpActor extends Actor {
     _preCreate(data, changes, user) {
@@ -116,16 +117,19 @@ export default class DhpActor extends Actor {
             disadvantageDice = null,
             bonusDamageString = '';
 
-        const modifiers = [
-            {
-                value: modifier.value ? Number.parseInt(modifier.value) : 0,
-                label:
-                    modifier.value >= 0
-                        ? `${modifier.title} +${modifier.value}`
-                        : `${modifier.title} -${modifier.value}`,
-                title: modifier.title
-            }
-        ];
+        const modifiers =
+            modifier.value !== null
+                ? [
+                      {
+                          value: modifier.value ? Number.parseInt(modifier.value) : 0,
+                          label:
+                              modifier.value >= 0
+                                  ? `${modifier.title} +${modifier.value}`
+                                  : `${modifier.title} ${modifier.value}`,
+                          title: modifier.title
+                      }
+                  ]
+                : [];
         if (!shiftKey) {
             const dialogClosed = new Promise((resolve, _) => {
                 new RollSelectionDialog(
@@ -161,53 +165,7 @@ export default class DhpActor extends Actor {
             `1${hopeDice} + 1${fearDice}${advantageDice ? ` + 1${advantageDice}` : disadvantageDice ? ` - 1${disadvantageDice}` : ''} ${modifiers.map(x => `+ ${x.value}`).join(' ')}`
         );
         let rollResult = await roll.evaluate();
-        rollResult.dice[0].options.appearance = {
-            colorset: 'inspired',
-            foreground: '#FFFFFF',
-            background: '#008080',
-            outline: '#000000',
-            edge: '#806400',
-            texture: 'bloodmoon',
-            material: 'metal',
-            font: 'Arial Black',
-            system: 'standard'
-        };
-        if (advantageDice || disadvantageDice) {
-            rollResult.dice[1].options.appearance = {
-                colorset: 'inspired',
-                foreground: disadvantageDice ? '#b30000' : '#FFFFFF',
-                background: '#008080',
-                outline: disadvantageDice ? '#000000' : '#000000',
-                edge: '#806400',
-                texture: 'bloodmoon',
-                material: 'metal',
-                font: 'Arial Black',
-                system: 'standard'
-            };
-            rollResult.dice[2].options.appearance = {
-                colorset: 'bloodmoon',
-                foreground: '#000000',
-                background: '#430070',
-                outline: '#b30000',
-                edge: '#000000',
-                texture: 'bloodmoon',
-                material: 'metal',
-                font: 'Arial Black',
-                system: 'standard'
-            };
-        } else {
-            rollResult.dice[1].options.appearance = {
-                colorset: 'bloodmoon',
-                foreground: '#000000',
-                background: '#430070',
-                outline: '#b30000',
-                edge: '#000000',
-                texture: 'bloodmoon',
-                material: 'metal',
-                font: 'Arial Black',
-                system: 'standard'
-            };
-        }
+        setDiceSoNiceForDualityRoll(rollResult, advantageDice, disadvantageDice);
 
         const hope = rollResult.dice[0].results[0].result;
         const fear = rollResult.dice[1].results[0].result;

module/helpers/utils.mjs

@@ -1,3 +1,5 @@
+import { diceSoNicePresets, getDiceSoNicePresets } from '../config/generalConfig.mjs';
+
 export const loadCompendiumOptions = async compendiums => {
     const compendiumValues = [];
 
@@ -118,3 +120,14 @@ export const getCommandTarget = () => {
 
     return target;
 };
+
+export const setDiceSoNiceForDualityRoll = (rollResult, advantage, disadvantage) => {
+    const diceSoNicePresets = getDiceSoNicePresets();
+    rollResult.dice[0].options.appearance = diceSoNicePresets.hope;
+    rollResult.dice[1].options.appearance = diceSoNicePresets.fear;
+    if (advantage) {
+        rollResult.dice[2].options.appearance = diceSoNicePresets.advantage;
+    } else if (disadvantage) {
+        rollResult.dice[2].options.appearance = diceSoNicePresets.disadvantage;
+    }
+};