cosmo/daggerheart
1
0
Fork 0
mirror of https://github.com/Foundryborne/daggerheart.git synced 2026-01-12 03:31:07 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Initial

Browse source
This commit is contained in:
WBHarry 2025-12-31 17:16:28 +01:00
parent bca7e0d3c9
commit 6140b4baaf
12 changed files with 345 additions and 13 deletions
Download patch file Download diff file Expand all files Collapse all files

78
module/applications/scene/sceneConfigSettings.mjs
View file

@ -1,11 +1,12 @@
export default class DhSceneConfigSettings extends foundry.applications.sheets.SceneConfig {
// static DEFAULT_OPTIONS = {
// ...super.DEFAULT_OPTIONS,
// form: {
// handler: this.updateData,
// closeOnSubmit: true
// }
// };
static DEFAULT_OPTIONS = {
...super.DEFAULT_OPTIONS,
actions: {
...super.DEFAULT_OPTIONS.actions,
addSceneEnvironment: DhSceneConfigSettings.#addSceneEnvironment,
removeSceneEnvironment: DhSceneConfigSettings.#removeSceneEnvironment
}
};
static buildParts() {
const { footer, tabs, ...parts } = super.PARTS;
@ -30,6 +31,7 @@ export default class DhSceneConfigSettings extends foundry.applications.sheets.S
_attachPartListeners(partId, htmlElement, options) {
super._attachPartListeners(partId, htmlElement, options);
switch (partId) {
case 'dh':
htmlElement.querySelector('#rangeMeasurementSetting')?.addEventListener('change', async event => {
@ -39,10 +41,37 @@ export default class DhSceneConfigSettings extends foundry.applications.sheets.S
this.document.flags.daggerheart = flagData;
this.render();
});
htmlElement.querySelectorAll('.scene-environment').forEach(element => {
element.querySelector('select')?.addEventListener('change', async event => {
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;
}
}
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') {
const element = event.target.closest('.scene-environment');
const flagData = foundry.utils.mergeObject(this.document.flags.daggerheart, {
sceneEnvironments: { [element.dataset.key]: { environment: data.uuid } }
});
this.document.flags.daggerheart = flagData;
this.render();
}
}
/** @inheritDoc */
async _preparePartContext(partId, context, options) {
context = await super._preparePartContext(partId, context, options);
@ -50,14 +79,41 @@ export default class DhSceneConfigSettings extends foundry.applications.sheets.S
case 'dh':
context.data = new game.system.api.data.scenes.DHScene(canvas.scene.flags.daggerheart);
context.variantRules = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.variantRules);
context.environmentIcons = CONFIG.DH.GENERAL.environmentIcons;
break;
}
return context;
}
// static async updateData(event, _, formData) {
// const data = foundry.utils.expandObject(formData.object);
// this.close(data);
// }
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(
this.document.flags.daggerheart.sceneEnvironments
).reduce((acc, key) => {
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;
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);
}
}

1
module/applications/ui/_module.mjs
View file

@ -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';

54
module/applications/ui/sceneNavigation.mjs Normal file
View file

@ -0,0 +1,54 @@
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 environmentKeys = Object.keys(daggerheartInfo.sceneEnvironments);
const hasEnvironments = environmentKeys.length;
return {
...x,
hasEnvironments,
environmentImage: hasEnvironments
? daggerheartInfo.sceneEnvironments[environmentKeys[0]].environment.img
: null,
environments: daggerheartInfo.sceneEnvironments
};
});
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 = Object.keys(scene.flags.daggerheart.sceneEnvironments);
const environment = await foundry.utils.fromUuid(
scene.flags.daggerheart.sceneEnvironments[sceneEnvironments[0]].environment
);
environment.sheet.render(true);
}
}

33
module/config/generalConfig.mjs
View file

@ -731,3 +731,36 @@ 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'
}
};

13
module/data/scene/scene.mjs
View file

@ -1,3 +1,5 @@
import ForeignDocumentUUIDField from '../fields/foreignDocumentUUIDField.mjs';
export default class DHScene extends foundry.abstract.DataModel {
static defineSchema() {
const fields = foundry.data.fields;
@ -13,7 +15,16 @@ 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 fields.TypedObjectField(
new fields.SchemaField({
environment: new ForeignDocumentUUIDField({ type: 'Actor' }),
icon: new fields.StringField({
required: true,
initial: CONFIG.DH.GENERAL.environmentIcons.tree.icon
})
})
)
};
}
}