Merge 503aa712e6 into 0b343c9f52

daggerheart.mjs

@@ -62,6 +62,7 @@ CONFIG.Token.rulerClass = placeables.DhTokenRuler;
 CONFIG.Token.hudClass = applications.hud.DHTokenHUD;
 
 CONFIG.ui.combat = applications.ui.DhCombatTracker;
+CONFIG.ui.nav = applications.ui.DhSceneNavigation;
 CONFIG.ui.chat = applications.ui.DhChatLog;
 CONFIG.ui.effectsDisplay = applications.ui.DhEffectsDisplay;
 CONFIG.ui.hotbar = applications.ui.DhHotbar;

lang/en.json

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

module/applications/scene/sceneConfigSettings.mjs

@@ -1,16 +1,28 @@
+import { RefreshType, socketEvent } from '../../systemRegistration/socket.mjs';
+
 export default class DhSceneConfigSettings extends foundry.applications.sheets.SceneConfig {
-    // static DEFAULT_OPTIONS = {
+    constructor(options) {
-    //     ...super.DEFAULT_OPTIONS,
+        super(options);
-    //     form: {
+
-    //         handler: this.updateData,
+        Hooks.on(socketEvent.Refresh, ({ refreshType }) => {
-    //         closeOnSubmit: true
+            if (refreshType === RefreshType.Scene) {
-    //     }
+                this.daggerheartFlag = new game.system.api.data.scenes.DHScene(this.document.flags.daggerheart);
-    // };
+                this.render();
+            }
+        });
+    }
+
+    static DEFAULT_OPTIONS = {
+        ...super.DEFAULT_OPTIONS,
+        actions: {
+            ...super.DEFAULT_OPTIONS.actions,
+            removeSceneEnvironment: DhSceneConfigSettings.#removeSceneEnvironment
+        }
+    };
 
     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' },
@@ -28,27 +40,45 @@ export default class DhSceneConfigSettings extends foundry.applications.sheets.S
 
     static TABS = DhSceneConfigSettings.buildTabs();
 
+    async _preFirstRender(context, options) {
+        await super._preFirstRender(context, options);
+        this.daggerheartFlag = new game.system.api.data.scenes.DHScene(this.document.flags.daggerheart);
+    }
+
     _attachPartListeners(partId, htmlElement, options) {
         super._attachPartListeners(partId, htmlElement, options);
+
         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();
                 });
+
+                const dragArea = htmlElement.querySelector('.scene-environments');
+                if (dragArea) dragArea.ondrop = this._onDrop.bind(this);
+
                 break;
         }
     }
 
+    async _onDrop(event) {
+        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') {
+            await this.daggerheartFlag.updateSource({
+                sceneEnvironments: [...this.daggerheartFlag.sceneEnvironments, data.uuid]
+            });
+            this.render();
+        }
+    }
+
     /** @inheritDoc */
     async _preparePartContext(partId, context, options) {
         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);
                 break;
         }
@@ -56,8 +86,24 @@ export default class DhSceneConfigSettings extends foundry.applications.sheets.S
         return context;
     }
 
-    // static async updateData(event, _, formData) {
+    static async #removeSceneEnvironment(_event, button) {
-    //     const data = foundry.utils.expandObject(formData.object);
+        await this.daggerheartFlag.updateSource({
-    //     this.close(data);
+            sceneEnvironments: this.daggerheartFlag.sceneEnvironments.filter(
-    // }
+                (_, index) => index !== Number.parseInt(button.dataset.index)
+            )
+        });
+        this.render();
+    }
+
+    /** @override */
+    async _processSubmitData(event, form, submitData, options) {
+        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;
+            }
+        }
+
+        super._processSubmitData(event, form, submitData, options);
+    }
 }

module/applications/ui/_module.mjs

@@ -5,4 +5,5 @@ export { default as DhCombatTracker } from './combatTracker.mjs';
 export { default as DhEffectsDisplay } from './effectsDisplay.mjs';
 export { default as DhFearTracker } from './fearTracker.mjs';
 export { default as DhHotbar } from './hotbar.mjs';
+export { default as DhSceneNavigation } from './sceneNavigation.mjs';
 export { ItemBrowser } from './itemBrowser.mjs';

module/applications/ui/sceneNavigation.mjs

@@ -0,0 +1,89 @@
+import { emitAsGM, GMUpdateEvent } from '../../systemRegistration/socket.mjs';
+
+export default class DhSceneNavigation extends foundry.applications.ui.SceneNavigation {
+    /** @inheritdoc */
+    static DEFAULT_OPTIONS = {
+        ...super.DEFAULT_OPTIONS,
+        classes: ['faded-ui', 'flexcol', 'scene-navigation'],
+        actions: {
+            openSceneEnvironment: DhSceneNavigation.#openSceneEnvironment
+        }
+    };
+
+    /** @inheritdoc */
+    static PARTS = {
+        scenes: {
+            root: true,
+            template: 'systems/daggerheart/templates/ui/sceneNavigation/scene-navigation.hbs'
+        }
+    };
+
+    /** @inheritdoc */
+    async _prepareContext(options) {
+        const context = await super._prepareContext(options);
+
+        const extendScenes = scenes =>
+            scenes.map(x => {
+                const scene = game.scenes.get(x.id);
+                if (!scene.flags.daggerheart) return x;
+
+                const daggerheartInfo = new game.system.api.data.scenes.DHScene(scene.flags.daggerheart);
+                const environments = daggerheartInfo.sceneEnvironments.filter(
+                    x => x && x.testUserPermission(game.user, 'LIMITED')
+                );
+                const hasEnvironments = environments.length > 0;
+                return {
+                    ...x,
+                    hasEnvironments,
+                    environmentImage: hasEnvironments ? environments[0].img : null,
+                    environments: environments
+                };
+            });
+        context.scenes.active = extendScenes(context.scenes.active);
+        context.scenes.inactive = extendScenes(context.scenes.inactive);
+
+        return context;
+    }
+
+    static async #openSceneEnvironment(event, button) {
+        const scene = game.scenes.get(button.dataset.sceneId);
+        const sceneEnvironments = new game.system.api.data.scenes.DHScene(
+            scene.flags.daggerheart
+        ).sceneEnvironments.filter(x => x.testUserPermission(game.user, 'LIMITED'));
+
+        if (sceneEnvironments.length === 1 || event.shiftKey) {
+            sceneEnvironments[0].sheet.render(true);
+        } else {
+            new foundry.applications.ux.ContextMenu.implementation(
+                button,
+                '.scene-environment',
+                sceneEnvironments.map(environment => ({
+                    name: environment.name,
+                    callback: () => {
+                        if (scene.flags.daggerheart.sceneEnvironments[0] !== environment.uuid) {
+                            const newEnvironments = scene.flags.daggerheart.sceneEnvironments;
+                            const newFirst = newEnvironments.splice(
+                                newEnvironments.findIndex(x => x === environment.uuid)
+                            )[0];
+                            newEnvironments.unshift(newFirst);
+                            emitAsGM(
+                                GMUpdateEvent.UpdateDocument,
+                                scene.update.bind(scene),
+                                { 'flags.daggerheart.sceneEnvironments': newEnvironments },
+                                scene.uuid
+                            );
+                        }
+
+                        environment.sheet.render({ force: true });
+                    }
+                })),
+                {
+                    jQuery: false,
+                    fixed: true
+                }
+            );
+
+            CONFIG.ux.ContextMenu.triggerContextMenu(event, '.scene-environment');
+        }
+    }
+}

module/applications/ux/contextMenu.mjs

@@ -96,11 +96,11 @@ export default class DHContextMenu extends foundry.applications.ux.ContextMenu {
      * Trigger a context menu event in response to a normal click on a additional options button.
      * @param {PointerEvent} event
      */
-    static triggerContextMenu(event) {
+    static triggerContextMenu(event, altSelector) {
         event.preventDefault();
         event.stopPropagation();
         const { clientX, clientY } = event;
-        const selector = '[data-item-uuid]';
+        const selector = altSelector ?? '[data-item-uuid]';
         const target = event.target.closest(selector) ?? event.currentTarget.closest(selector);
         target?.dispatchEvent(
             new PointerEvent('contextmenu', {

module/data/actor/environment.mjs

@@ -1,8 +1,11 @@
 import BaseDataActor from './base.mjs';
 import ForeignDocumentUUIDArrayField from '../fields/foreignDocumentUUIDArrayField.mjs';
 import DHEnvironmentSettings from '../../applications/sheets-configs/environment-settings.mjs';
+import { RefreshType, socketEvent } from '../../systemRegistration/socket.mjs';
 
 export default class DhEnvironment extends BaseDataActor {
+    scenes = new Set();
+
     /**@override */
     static LOCALIZATION_PREFIXES = ['DAGGERHEART.ACTORS.Environment'];
 
@@ -53,6 +56,31 @@ export default class DhEnvironment extends BaseDataActor {
     }
 
     isItemValid(source) {
-        return source.type === "feature";
+        return source.type === 'feature';
+    }
+
+    _onUpdate(changes, options, userId) {
+        super._onUpdate(changes, options, userId);
+        for (const scene of this.scenes) {
+            scene.render();
+        }
+    }
+
+    _onDelete(options, userId) {
+        super._onDelete(options, userId);
+        for (const scene of this.scenes) {
+            if (game.user.isActiveGM) {
+                const newSceneEnvironments = scene.flags.daggerheart.sceneEnvironments.filter(
+                    x => x !== this.parent.uuid
+                );
+                scene.update({ 'flags.daggerheart.sceneEnvironments': newSceneEnvironments }).then(() => {
+                    Hooks.callAll(socketEvent.Refresh, { refreshType: RefreshType.Scene });
+                    game.socket.emit(`system.${CONFIG.DH.id}`, {
+                        action: socketEvent.Refresh,
+                        data: { refreshType: RefreshType.TagTeamRoll }
+                    });
+                });
+            }
+        }
     }
 }

module/data/scene/scene.mjs

@@ -1,3 +1,8 @@
+import ForeignDocumentUUIDArrayField from '../fields/foreignDocumentUUIDArrayField.mjs';
+
+/*  Foundry does not add any system data for subtyped Scenes. The data model is therefore used by instantiating a new instance of it for sceneConfigSettings.mjs.
+    Needed dataprep and lifetime hooks are handled in documents/scene.
+*/
 export default class DHScene extends foundry.abstract.DataModel {
     static defineSchema() {
         const fields = foundry.data.fields;
@@ -13,7 +18,8 @@ export default class DHScene extends foundry.abstract.DataModel {
                 veryClose: new fields.NumberField({ integer: true, label: 'DAGGERHEART.CONFIG.Range.veryClose.name' }),
                 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 ForeignDocumentUUIDArrayField({ type: 'Actor', prune: true })
         };
     }
 }

module/documents/scene.mjs

@@ -37,4 +37,30 @@ export default class DhScene extends Scene {
         this.#sizeSyncBatch.clear();
         this.updateEmbeddedDocuments('Token', entries, { animation: { movementSpeed: 1.5 } });
     }, 0);
+
+    prepareBaseData() {
+        super.prepareBaseData();
+
+        if (this instanceof game.system.api.documents.DhScene) {
+            const system = new game.system.api.data.scenes.DHScene(this.flags.daggerheart);
+
+            // Register this scene to all environements
+            for (const environment of system.sceneEnvironments) {
+                environment.system.scenes?.add(this);
+            }
+        }
+    }
+
+    _onDelete(options, userId) {
+        super._onDelete(options, userId);
+
+        if (this instanceof game.system.api.documents.DhScene) {
+            const system = new game.system.api.data.scenes.DHScene(this.flags.daggerheart);
+
+            // Clear this scene from all environments that aren't deleted
+            for (const environement of system.sceneEnvironments) {
+                environement?.system?.scenes?.delete(this);
+            }
+        }
+    }
 }

module/systemRegistration/socket.mjs

@@ -37,7 +37,8 @@ export const GMUpdateEvent = {
 export const RefreshType = {
     Countdown: 'DhCoundownRefresh',
     TagTeamRoll: 'DhTagTeamRollRefresh',
-    EffectsDisplay: 'DhEffectsDisplayRefresh'
+    EffectsDisplay: 'DhEffectsDisplayRefresh',
+    Scene: 'DhSceneRefresh'
 };
 
 export const registerSocketHooks = () => {
@@ -92,6 +93,10 @@ export const registerSocketHooks = () => {
             }
         }
     });
+    Hooks.on(socketEvent.RefreshDocument, async data => {
+        const document = await foundry.utils.fromUuid(data.uuid);
+        document.sheet.render();
+    });
 };
 
 export const registerUserQueries = () => {

styles/less/ui/index.less

@@ -33,3 +33,5 @@
 @import './scene-config/scene-config.less';
 
 @import './effects-display/sheet.less';
+
+@import './scene-navigation/scene-navigation.less';

styles/less/ui/scene-config/scene-config.less

@@ -37,4 +37,63 @@
     .helper-text {
         font-style: italic;
     }
+
+    .scene-environments {
+        display: flex;
+        flex-direction: column;
+        gap: 8px;
+
+        .scene-environment {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+
+            .scene-environment-inner {
+                display: flex;
+                align-items: center;
+                gap: 16px;
+                flex: 1;
+
+                img {
+                    height: 36px;
+                }
+
+                h5 {
+                    margin: 0;
+                }
+
+                .tags {
+                    display: flex;
+                    gap: 4px;
+                    padding-bottom: 0;
+
+                    .tag {
+                        display: flex;
+                        flex-direction: row;
+                        justify-content: center;
+                        align-items: center;
+                        padding: 3px 5px;
+                        font-size: var(--font-size-12);
+                        font: @font-body;
+
+                        background: light-dark(@dark-15, @beige-15);
+                        border: 1px solid light-dark(@dark, @beige);
+                        border-radius: 3px;
+                    }
+
+                    .label {
+                        display: flex;
+                        flex-direction: row;
+                        justify-content: center;
+                        align-items: center;
+                        font-size: var(--font-size-12);
+                    }
+                }
+            }
+
+            .remove-icon {
+                font-size: 16px;
+            }
+        }
+    }
 }

styles/less/ui/scene-navigation/scene-navigation.less

@@ -0,0 +1,36 @@
+#ui-left #ui-left-column-2 {
+    flex: 0 0 230px;
+
+    .scene-navigation {
+        .scene-wrapper {
+            display: flex;
+            gap: 2px;
+            height: var(--control-size);
+            width: 100%;
+
+            .scene-environment {
+                padding: 0;
+
+                img {
+                    border-radius: 4px;
+                }
+            }
+        }
+
+        .scene {
+            justify-content: center;
+            align-content: center;
+            background: var(--control-bg-color);
+            border: 1px solid var(--control-border-color);
+            border-radius: 4px;
+            color: var(--control-icon-color);
+            pointer-events: all;
+            transition:
+                border 0.25s,
+                color 0.25s;
+            text-shadow: none;
+            width: 200px;
+            max-width: 200px;
+        }
+    }
+}

templates/scene/dh-config.hbs

@@ -21,4 +21,39 @@
             <span class="helper-text">{{localize "DAGGERHEART.SETTINGS.Scene.disabledText"}}</span>
         {{/if}}
     </fieldset>
+
+    <fieldset>
+        <legend>
+            <span>{{localize "DAGGERHEART.SETTINGS.Scene.sceneEnvironments"}}</span>
+        </legend>
+
+        <div class="scene-environments">
+            {{#each data.sceneEnvironments as |environment index|}}
+                <div class="scene-environment" data-index="{{index}}">
+                    {{#if environment}}
+                        <div class="scene-environment-inner">
+                            <img src="{{environment.img}}" />
+                            <h5>{{environment.name}}</h5>
+                            <div class="tags">
+                                <div class="tag">
+                                    <span>
+                                        {{localize (concat 'DAGGERHEART.GENERAL.Tiers.' environment.system.tier)}}
+                                    </span>
+                                </div>
+                                {{#if environment.system.type}}
+                                    <div class="tag">
+                                        <span>
+                                            {{localize (concat 'DAGGERHEART.CONFIG.EnvironmentType.' environment.system.type '.label')}}
+                                        </span>
+                                    </div>
+                                {{/if}}
+                            </div>
+                        </div>
+                    {{/if}}
+                    <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>

templates/ui/sceneNavigation/scene-navigation.hbs

@@ -0,0 +1,36 @@
+<nav id="scene-navigation" aria-roledescription="{{localize "SCENE_NAVIGATION.LABEL"}}" data-tooltip-direction="RIGHT">
+    {{#if canExpand}}
+    <a id="scene-navigation-expand" class="ui-control" data-action="toggleExpand">
+        <i class="fa-solid fa-caret-down" inert></i>
+    </a>
+    {{/if}}
+    <menu id="scene-navigation-active" class="scene-navigation-menu flexcol">
+        {{#each scenes.active as |scene|}}
+            <li class="scene-wrapper">
+                <div class="ui-control scene {{scene.cssClass}}" data-scene-id="{{scene.id}}" data-action="viewScene" {{#if scene.tooltip}}data-tooltip-text="{{scene.tooltip}}"{{/if}}>
+                    <span class="scene-name ellipsis">{{scene.name}}</span>
+                    {{#if scene.users}}
+                    <ul class="scene-players">
+                        {{#each scene.users as |user|}}
+                        <li class="scene-player" style="--color-bg:{{user.color}}; --color-border:{{user.border}}"
+                            data-tooltip aria-label="{{user.name}}">{{user.letter}}</li>
+                        {{/each}}
+                    </ul>
+                    {{/if}}
+                </div>
+                {{#if scene.hasEnvironments}}
+                    <button class="ui-control scene-environment {{#if (gt scene.environments.length 1)}}many-environments{{/if}}" data-action="openSceneEnvironment" data-scene-id="{{scene.id}}"><img src="{{scene.environmentImage}}" /> </button>
+                {{/if}}
+            </li>
+        {{/each}}
+    </menu>
+    <menu id="scene-navigation-inactive" class="scene-navigation-menu flexcol">
+        {{#each scenes.inactive as |scene|}}
+            <li class="scene-wrapper">
+                <div class="ui-control scene {{scene.cssClass}}" data-scene-id="{{scene.id}}" data-action="viewScene" {{#if scene.tooltip}}data-tooltip-text="{{scene.tooltip}}"{{/if}}>
+                    <span class="scene-name ellipsis">{{scene.name}}</span>
+                </div>
+            </li>
+        {{/each}}
+    </menu>
+</nav>