Remade to array structure

lang/en.json

@@ -2577,7 +2577,7 @@
                 "disabledText": "Daggerheart Measurements are disabled in System Settings - Variant Rules",
                 "rangeMeasurement": "Range Measurement",
                 "sceneEnvironments": "Scene Environments",
-                "noEnvironmentLinked": "Drag in an environment"
+                "dragEnvironmentHere": "Drag environments here"
             }
         },
         "UI": {

module/applications/scene/sceneConfigSettings.mjs

@@ -1,9 +1,14 @@
 export default class DhSceneConfigSettings extends foundry.applications.sheets.SceneConfig {
+    constructor(options = {}) {
+        super(options);
+
+        this.daggerheartFlag = new game.system.api.data.scenes.DHScene(this.document.flags.daggerheart);
+    }
+
     static DEFAULT_OPTIONS = {
         ...super.DEFAULT_OPTIONS,
         actions: {
             ...super.DEFAULT_OPTIONS.actions,
-            addSceneEnvironment: DhSceneConfigSettings.#addSceneEnvironment,
             removeSceneEnvironment: DhSceneConfigSettings.#removeSceneEnvironment
         }
     };
@@ -11,7 +16,6 @@ export default class DhSceneConfigSettings extends foundry.applications.sheets.S
     static buildParts() {
         const { footer, tabs, ...parts } = super.PARTS;
         const tmpParts = {
-            // tabs,
             tabs: { template: 'systems/daggerheart/templates/scene/tabs.hbs' },
             ...parts,
             dh: { template: 'systems/daggerheart/templates/scene/dh-config.hbs' },
@@ -35,25 +39,12 @@ export default class DhSceneConfigSettings extends foundry.applications.sheets.S
         switch (partId) {
             case 'dh':
                 htmlElement.querySelector('#rangeMeasurementSetting')?.addEventListener('change', async event => {
-                    const flagData = foundry.utils.mergeObject(this.document.flags.daggerheart, {
+                    this.daggerheartFlag.updateSource({ rangeMeasurement: { setting: event.target.value } });
-                        rangeMeasurement: { setting: event.target.value }
-                    });
-                    this.document.flags.daggerheart = flagData;
                     this.render();
                 });
 
-                htmlElement.querySelectorAll('.scene-environment').forEach(element => {
+                const dragArea = htmlElement.querySelector('.scene-environments');
-                    element.querySelector('select')?.addEventListener('change', async event => {
+                if (dragArea) dragArea.ondrop = this._onDrop.bind(this);
-                        const id = event.target.dataset.key;
-                        const flagData = foundry.utils.mergeObject(this.document.flags.daggerheart, {
-                            sceneEnvironments: { [id]: { icon: event.target.value } }
-                        });
-                        this.document.flags.daggerheart = flagData;
-                        this.render();
-                    });
-
-                    element.ondrop = this._onDrop.bind(this);
-                });
 
                 break;
         }
@@ -63,11 +54,9 @@ export default class DhSceneConfigSettings extends foundry.applications.sheets.S
         const data = foundry.applications.ux.TextEditor.implementation.getDragEventData(event);
         const item = await foundry.utils.fromUuid(data.uuid);
         if (item instanceof game.system.api.documents.DhpActor && item.type === 'environment') {
-            const element = event.target.closest('.scene-environment');
+            await this.daggerheartFlag.updateSource({
-            const flagData = foundry.utils.mergeObject(this.document.flags.daggerheart, {
+                sceneEnvironments: [...this.daggerheartFlag.sceneEnvironments, data.uuid]
-                sceneEnvironments: { [element.dataset.key]: { environment: data.uuid } }
             });
-            this.document.flags.daggerheart = flagData;
             this.render();
         }
     }
@@ -77,37 +66,26 @@ export default class DhSceneConfigSettings extends foundry.applications.sheets.S
         context = await super._preparePartContext(partId, context, options);
         switch (partId) {
             case 'dh':
-                context.data = new game.system.api.data.scenes.DHScene(canvas.scene.flags.daggerheart);
+                context.data = this.daggerheartFlag;
                 context.variantRules = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.variantRules);
-                context.environmentIcons = CONFIG.DH.GENERAL.environmentIcons;
                 break;
         }
 
         return context;
     }
 
-    static async #addSceneEnvironment() {
-        const flagData = foundry.utils.mergeObject(this.document.flags.daggerheart, {
-            sceneEnvironments: { [foundry.utils.randomID()]: { icon: CONFIG.DH.GENERAL.environmentIcons.tree.icon } }
-        });
-        this.document.flags.daggerheart = flagData;
-
-        this.render();
-    }
-
     static async #removeSceneEnvironment(_event, button) {
-        this.document.flags.daggerheart.sceneEnvironments = Object.keys(
+        await this.daggerheartFlag.updateSource({
-            this.document.flags.daggerheart.sceneEnvironments
+            sceneEnvironments: this.daggerheartFlag.sceneEnvironments.filter(
-        ).reduce((acc, key) => {
+                (_, index) => index !== Number.parseInt(button.dataset.index)
-            if (key !== button.dataset.key) acc[key] = this.document.flags.daggerheart.sceneEnvironments[key];
+            )
-            return acc;
+        });
-        }, {});
         this.render();
     }
 
     /** @override */
     async _processSubmitData(event, form, submitData, options) {
-        submitData.flags.daggerheart.sceneEnvironments = this.document.flags.daggerheart.sceneEnvironments;
+        submitData.flags.daggerheart = this.daggerheartFlag.toObject();
         for (const key of Object.keys(this.document._source.flags.daggerheart.sceneEnvironments)) {
             if (!submitData.flags.daggerheart.sceneEnvironments[key]) {
                 submitData.flags.daggerheart.sceneEnvironments[`-=${key}`] = null;

module/applications/ui/sceneNavigation.mjs

@@ -32,7 +32,7 @@ export default class DhSceneNavigation extends foundry.applications.ui.SceneNavi
                     ...x,
                     hasEnvironments,
                     environmentImage: hasEnvironments
-                        ? daggerheartInfo.sceneEnvironments[environmentKeys[0]].environment.img
+                        ? daggerheartInfo.sceneEnvironments[environmentKeys[0]].img
                         : null,
                     environments: daggerheartInfo.sceneEnvironments
                 };
@@ -47,7 +47,7 @@ export default class DhSceneNavigation extends foundry.applications.ui.SceneNavi
         const scene = game.scenes.get(button.dataset.sceneId);
         const sceneEnvironments = Object.keys(scene.flags.daggerheart.sceneEnvironments);
         const environment = await foundry.utils.fromUuid(
-            scene.flags.daggerheart.sceneEnvironments[sceneEnvironments[0]].environment
+            scene.flags.daggerheart.sceneEnvironments[sceneEnvironments[0]]
         );
         environment.sheet.render(true);
     }

module/config/generalConfig.mjs

@@ -731,36 +731,3 @@ export const sceneRangeMeasurementSetting = {
         label: 'Custom'
     }
 };
-
-export const environmentIcons = {
-    tree: {
-        name: 'DAGGERHEART.CONFIG.EnvironmentIcons.tree',
-        icon: 'fa-solid fa-tree',
-        unicode: '&#xf1bb'
-    },
-    mountain: {
-        name: 'DAGGERHEART.CONFIG.EnvironmentIcons.mountain',
-        icon: 'fa-solid fa-mountain',
-        unicode: '&#xf6fc'
-    },
-    city: {
-        name: 'DAGGERHEART.CONFIG.EnvironmentIcons.city',
-        icon: 'fa-solid fa-house',
-        unicode: '&#xf015'
-    },
-    dungeon: {
-        name: 'DAGGERHEART.CONFIG.EnvironmentIcons.dungeon',
-        icon: 'fa-solid fa-dungeon',
-        unicode: '&#xf6d9'
-    },
-    water: {
-        name: 'DAGGERHEART.CONFIG.EnvironmentIcons.water',
-        icon: 'fa-solid fa-water',
-        unicode: '&#xf773'
-    },
-    social: {
-        name: 'DAGGERHEART.CONFIG.EnvironmentIcons.social',
-        icon: 'fa-solid fa-masks-theater',
-        unicode: '&#xf630'
-    }
-};

module/data/scene/scene.mjs

@@ -1,4 +1,4 @@
-import ForeignDocumentUUIDField from '../fields/foreignDocumentUUIDField.mjs';
+import ForeignDocumentUUIDArrayField from '../fields/foreignDocumentUUIDArrayField.mjs';
 
 export default class DHScene extends foundry.abstract.DataModel {
     static defineSchema() {
@@ -16,15 +16,7 @@ export default class DHScene extends foundry.abstract.DataModel {
                 close: new fields.NumberField({ integer: true, label: 'DAGGERHEART.CONFIG.Range.close.name' }),
                 far: new fields.NumberField({ integer: true, label: 'DAGGERHEART.CONFIG.Range.far.name' })
             }),
-            sceneEnvironments: new fields.TypedObjectField(
+            sceneEnvironments: new ForeignDocumentUUIDArrayField({ type: 'Actor' })
-                new fields.SchemaField({
-                    environment: new ForeignDocumentUUIDField({ type: 'Actor' }),
-                    icon: new fields.StringField({
-                        required: true,
-                        initial: CONFIG.DH.GENERAL.environmentIcons.tree.icon
-                    })
-                })
-            )
         };
     }
 }

templates/scene/dh-config.hbs

@@ -25,37 +25,35 @@
     <fieldset>
         <legend>
             <span>{{localize "DAGGERHEART.SETTINGS.Scene.sceneEnvironments"}}</span>
-            <a data-action="addSceneEnvironment"><i class="fa-solid fa-plus"></i></a>
         </legend>
 
         <div class="scene-environments">
-            {{#each data.sceneEnvironments as |data key|}}
+            {{#each data.sceneEnvironments as |environment index|}}
-                <div class="scene-environment" data-key="{{key}}">
+                <div class="scene-environment" data-index="{{index}}">
-                    {{#if data.environment}}
+                    {{#if environment}}
                         <div class="scene-environment-inner">
-                            <img src="{{data.environment.img}}" />
+                            <img src="{{environment.img}}" />
-                            <h5>{{data.environment.name}}</h5>
+                            <h5>{{environment.name}}</h5>
                             <div class="tags">
                                 <div class="tag">
                                     <span>
-                                        {{localize (concat 'DAGGERHEART.GENERAL.Tiers.' data.environment.system.tier)}}
+                                        {{localize (concat 'DAGGERHEART.GENERAL.Tiers.' environment.system.tier)}}
                                     </span>
                                 </div>
-                                {{#if data.environment.system.type}}
+                                {{#if environment.system.type}}
                                     <div class="tag">
                                         <span>
-                                            {{localize (concat 'DAGGERHEART.CONFIG.EnvironmentType.' data.environment.system.type '.label')}}
+                                            {{localize (concat 'DAGGERHEART.CONFIG.EnvironmentType.' environment.system.type '.label')}}
                                         </span>
                                     </div>
                                 {{/if}}
                             </div>
                         </div>
-                    {{else}}
-                        <span class="drag-area hint">{{localize "DAGGERHEART.SETTINGS.Scene.noEnvironmentLinked"}}</span>
                     {{/if}}
-                    <a data-action="removeSceneEnvironment" data-key="{{key}}"><i class="fa-solid fa-trash remove-icon"></i></a>
+                    <a data-action="removeSceneEnvironment" data-index="{{index}}"><i class="fa-solid fa-trash remove-icon"></i></a>
                 </div>
             {{/each}}
+            <span class="drag-area">{{localize "DAGGERHEART.SETTINGS.Scene.dragEnvironmentHere"}}</span>
         </div>
     </fieldset>
 </div>