cosmo/daggerheart
1
0
Fork 0
mirror of https://github.com/Foundryborne/daggerheart.git synced 2026-07-21 18:09:54 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Merge branch 'main' into feature/combo-dice-modifier

Browse source
This commit is contained in:
WBHarry 2026-07-12 19:57:21 +02:00
commit 0779443d4a
421 changed files with 2867 additions and 4508 deletions
Download patch file Download diff file Expand all files Collapse all files

6
module/applications/dialogs/beastformDialog.mjs
View file

@ -315,15 +315,15 @@ export default class BeastformDialog extends HandlebarsApplicationMixin(Applicat
const beastformEffect = selected.effects.find(x => x.type === 'beastform');
for (const traitBonus of app.modifications.traitBonuses) {
const existingChange = beastformEffect.changes.find(
const existingChange = beastformEffect.system.changes.find(
x => x.key === `system.traits.${traitBonus.trait}.value`
);
if (existingChange) {
existingChange.value = Number.parseInt(existingChange.value) + traitBonus.bonus;
} else {
beastformEffect.changes.push({
beastformEffect.system.changes.push({
key: `system.traits.${traitBonus.trait}.value`,
mode: 2,
type: 'add',
priority: null,
value: traitBonus.bonus
});

16
module/applications/dialogs/deathMove.mjs
View file

@ -139,13 +139,15 @@ export default class DhDeathMove extends HandlebarsApplicationMixin(ApplicationV
name: game.i18n.localize('DAGGERHEART.CONFIG.DeathMoves.blazeOfGlory.name'),
description: game.i18n.localize('DAGGERHEART.CONFIG.DeathMoves.blazeOfGlory.description'),
img: CONFIG.DH.GENERAL.deathMoves.blazeOfGlory.img,
changes: [
{
key: 'system.rules.roll.guaranteedCritical',
mode: 2,
value: 'true'
}
]
system: {
changes: [
{
key: 'system.rules.roll.guaranteedCritical',
type: 'add',
value: 'true'
}
]
}
}
]);

4
module/applications/dialogs/groupRollDialog.mjs
View file

@ -1,7 +1,7 @@
import { ResourceUpdateMap } from '../../data/action/baseAction.mjs';
import { shouldUseHopeFearAutomation } from '../../helpers/utils.mjs';
import { emitGMUpdate, GMUpdateEvent, RefreshType, socketEvent } from '../../systemRegistration/socket.mjs';
import Party from '../sheets/actors/party.mjs';
import PartySheet from '../sheets/actors/party.mjs';
const { HandlebarsApplicationMixin, ApplicationV2 } = foundry.applications.api;
@ -11,7 +11,7 @@ export default class GroupRollDialog extends HandlebarsApplicationMixin(Applicat
this.party = party;
this.partyMembers = party.system.partyMembers
.filter(x => Party.DICE_ROLL_ACTOR_TYPES.includes(x.type))
.filter(x => PartySheet.DICE_ROLL_ACTOR_TYPES.includes(x.type))
.map(member => ({
...member.toObject(),
uuid: member.uuid,

14
module/applications/dialogs/tagTeamDialog.mjs
View file

@ -2,7 +2,7 @@ import { ResourceUpdateMap } from '../../data/action/baseAction.mjs';
import { MemberData } from '../../data/tagTeamData.mjs';
import { getCritDamageBonus, shouldUseHopeFearAutomation } from '../../helpers/utils.mjs';
import { emitGMUpdate, GMUpdateEvent, RefreshType, socketEvent } from '../../systemRegistration/socket.mjs';
import Party from '../sheets/actors/party.mjs';
import PartySheet from '../sheets/actors/party.mjs';
const { HandlebarsApplicationMixin, ApplicationV2 } = foundry.applications.api;
@ -13,7 +13,7 @@ export default class TagTeamDialog extends HandlebarsApplicationMixin(Applicatio
this.usesTagTeamHopeCost = true;
this.party = party;
this.partyMembers = party.system.partyMembers
.filter(x => Party.DICE_ROLL_ACTOR_TYPES.includes(x.type))
.filter(x => PartySheet.DICE_ROLL_ACTOR_TYPES.includes(x.type))
.map(member => ({
...member.toObject(),
uuid: member.uuid,
@ -208,6 +208,16 @@ export default class TagTeamDialog extends HandlebarsApplicationMixin(Applicatio
const rollOptions = [];
const damageRollOptions = [];
if (actor?.system.usedUnarmed) {
damageRollOptions.push({
value: actor.system.attack.uuid,
label: actor.system.usedUnarmed.name,
group: actor.name,
baseAction: actor.system.attack
});
}
for (const item of actor?.items ?? []) {
if (!item.system.metadata.hasActions) continue;
const actions = [...item.system.actions, ...(item.system.attack ? [item.system.attack] : [])];

18
module/applications/sheets-configs/activeEffectConfig.mjs
View file

@ -155,6 +155,10 @@ export default class DhActiveEffectConfig extends foundry.applications.sheets.Ac
.querySelector('.stacking-change-checkbox')
?.addEventListener('change', this.stackingChangeToggle.bind(this));
htmlElement
.querySelector('.range-dependence-change-checkbox')
?.addEventListener('change', this.rangeDependenceChangeToggle.bind(this));
htmlElement
.querySelector('.armor-change-checkbox')
?.addEventListener('change', this.armorChangeToggle.bind(this));
@ -224,6 +228,20 @@ export default class DhActiveEffectConfig extends foundry.applications.sheets.Ac
return this.submit({ updateData: { system: systemData } });
}
rangeDependenceChangeToggle(event) {
const rangeFields = this.document.system.schema.fields.rangeDependence.fields;
const systemData = {
rangeDependence: event.target.checked
? _replace({
type: rangeFields.type.initial,
target: rangeFields.target.initial,
range: rangeFields.range.initial
})
: null
};
return this.submit({ updateData: { system: systemData } });
}
armorChangeToggle(event) {
if (event.target.checked) {
this.addArmorChange();

10
module/applications/sheets/actors/_types.d.ts vendored
View file

@ -1,8 +1,18 @@
import DhCompanion from '../../../data/actor/companion.mjs';
import DhParty from '../../../data/actor/party.mjs';
import DhpActor from '../../../documents/actor.mjs';
declare module './companion.mjs' {
export default interface DhCompanionSheet {
actor: DhpActor<DhCompanion>;
document: DhpActor<DhCompanion>;
}
}
declare module './party.mjs' {
export default interface PartySheet {
actor: DhpActor<DhParty>;
document: DhpActor<DhParty>;
}
}

16
module/applications/sheets/actors/character.mjs
View file

@ -914,7 +914,7 @@ export default class CharacterSheet extends DHBaseActorSheet {
const doc = await getDocFromElement(button);
const { available } = this.document.system.loadoutSlot;
if (doc.system.inVault && !available && !doc.system.loadoutIgnore) {
return ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.loadoutMaxReached'));
return ui.notifications.warn('DAGGERHEART.UI.Notifications.loadoutMaxReached', { localize: true });
}
await doc?.update({ 'system.inVault': !doc.system.inVault });
@ -1206,10 +1206,22 @@ export default class CharacterSheet extends DHBaseActorSheet {
if (!confirmed) return;
}
if (this.document.uuid === item.parent?.uuid) {
// Check for same actor drag/drop attempts
const isSameActor = this.document.uuid === item.parent?.uuid;
const loadoutFieldset = event.target.closest('[data-in-vault]');
const vaulting = loadoutFieldset?.dataset.inVault === 'true';
if (isSameActor && loadoutFieldset && item.type === 'domainCard' && vaulting !== item.system.inVault) {
// This is likely an attempt to vault or unvault an item
const { available } = this.document.system.loadoutSlot;
if (!vaulting && !available && !item.system.loadoutIgnore) {
return ui.notifications.warn('DAGGERHEART.UI.Notifications.loadoutMaxReached', { localize: true });
}
return item.update({ 'system.inVault': vaulting });
} else if (isSameActor) {
return super._onDropItem(event, item);
}
// Handle beastforms
if (item.type === 'beastform') {
if (this.document.effects.find(x => x.type === 'beastform')) {
return ui.notifications.warn(

143
module/applications/sheets/actors/party.mjs
View file

@ -6,7 +6,9 @@ import DaggerheartMenu from '../../sidebar/tabs/daggerheartMenu.mjs';
import { socketEvent } from '../../../systemRegistration/socket.mjs';
import DhpActor from '../../../documents/actor.mjs';
export default class Party extends DHBaseActorSheet {
/**@typedef {import('@client/applications/_types.mjs').ApplicationClickAction} ApplicationClickAction */
export default class PartySheet extends DHBaseActorSheet {
constructor(options) {
super(options);
@ -24,17 +26,17 @@ export default class Party extends DHBaseActorSheet {
resizable: true
},
actions: {
openDocument: Party.#openDocument,
deletePartyMember: Party.#deletePartyMember,
toggleHope: Party.#toggleHope,
toggleHitPoints: Party.#toggleHitPoints,
toggleStress: Party.#toggleStress,
toggleArmorSlot: Party.#toggleArmorSlot,
tempBrowser: Party.#tempBrowser,
refeshActions: Party.#refeshActions,
triggerRest: Party.#triggerRest,
tagTeamRoll: Party.#tagTeamRoll,
groupRoll: Party.#groupRoll
openDocument: PartySheet.#onOpenDocument,
deletePartyMember: PartySheet.#onDeletePartyMember,
toggleHope: PartySheet.#onToggleHope,
toggleHitPoints: PartySheet.#onToggleHitPoints,
toggleStress: PartySheet.#onToggleStress,
toggleArmorSlot: PartySheet.#onToggleArmorSlot,
tempBrowser: PartySheet.#onTempBrowser,
refreshActions: PartySheet.#onRefreshActions,
triggerRest: PartySheet.#onTriggerRest,
tagTeamRoll: PartySheet.#onTagTeamRoll,
groupRoll: PartySheet.#onGroupRoll
},
dragDrop: [{ dragSelector: '[data-item-id]', dropSelector: null }]
};
@ -72,6 +74,23 @@ export default class Party extends DHBaseActorSheet {
this._createSearchFilter();
}
/** @inheritdoc */
_toggleDisabled(disabled) {
// Overriden to only disable text inputs by default if the user is a member
const isMember = this.actor.system.partyMembers.some(
m => m.testUserPermission(game.user, CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER)
);
if (!isMember) return super._toggleDisabled(disabled);
const form = this.form;
for (const input of form.querySelectorAll('input:not([type=search]), .editor.prosemirror')) {
input.disabled = disabled;
}
for (const element of form.querySelectorAll('.input[contenteditable]')) {
element.classList.toggle('disabled', disabled);
}
}
/* -------------------------------------------- */
/* Prepare Context */
/* -------------------------------------------- */
@ -198,8 +217,16 @@ export default class Party extends DHBaseActorSheet {
};
}
}
/* -------------------------------------------- */
/* Event handlers */
/* -------------------------------------------- */
static async #openDocument(_, target) {
/**
* @this PartySheet
* @type {ApplicationClickAction}
*/
static async #onOpenDocument(_, target) {
const uuid = target.dataset.uuid;
const document = await foundry.utils.fromUuid(uuid);
document?.sheet?.render(true);
@ -207,9 +234,10 @@ export default class Party extends DHBaseActorSheet {
/**
* Toggles a hope resource value.
* @this PartySheet
* @type {ApplicationClickAction}
*/
static async #toggleHope(_, target) {
static async #onToggleHope(_, target) {
const hopeValue = Number.parseInt(target.dataset.value);
const actor = await foundry.utils.fromUuid(target.dataset.actorId);
const newValue = actor.system.resources.hope.value >= hopeValue ? hopeValue - 1 : hopeValue;
@ -219,9 +247,10 @@ export default class Party extends DHBaseActorSheet {
/**
* Toggles a hp resource value.
* @this PartySheet
* @type {ApplicationClickAction}
*/
static async #toggleHitPoints(_, target) {
static async #onToggleHitPoints(_, target) {
const hitPointsValue = Number.parseInt(target.dataset.value);
const actor = await foundry.utils.fromUuid(target.dataset.actorId);
const newValue = actor.system.resources.hitPoints.value >= hitPointsValue ? hitPointsValue - 1 : hitPointsValue;
@ -231,9 +260,10 @@ export default class Party extends DHBaseActorSheet {
/**
* Toggles a stress resource value.
* @this PartySheet
* @type {ApplicationClickAction}
*/
static async #toggleStress(_, target) {
static async #onToggleStress(_, target) {
const stressValue = Number.parseInt(target.dataset.value);
const actor = await foundry.utils.fromUuid(target.dataset.actorId);
const newValue = actor.system.resources.stress.value >= stressValue ? stressValue - 1 : stressValue;
@ -243,9 +273,10 @@ export default class Party extends DHBaseActorSheet {
/**
* Toggles a armor slot resource value.
* @this PartySheet
* @type {ApplicationClickAction}
*/
static async #toggleArmorSlot(_, target) {
static async #onToggleArmorSlot(_, target) {
const actor = await foundry.utils.fromUuid(target.dataset.actorId);
const { value, max } = actor.system.armorScore;
const inputValue = Number.parseInt(target.dataset.value);
@ -258,12 +289,19 @@ export default class Party extends DHBaseActorSheet {
/**
* Opens Compedium Browser
* @this PartySheet
* @type {ApplicationClickAction}
*/
static async #tempBrowser(_, target) {
static async #onTempBrowser(_, target) {
new ItemBrowser().render({ force: true });
}
static async #refeshActions() {
/**
* @todo Is this unused?
* @this PartySheet
* @type {ApplicationClickAction}
*/
static async #onRefreshActions() {
const confirmed = await foundry.applications.api.DialogV2.confirm({
window: {
title: 'New Section',
@ -281,7 +319,11 @@ export default class Party extends DHBaseActorSheet {
if (!confirmed) return;
}
static async #triggerRest(_, button) {
/**
* @this PartySheet
* @type {ApplicationClickAction}
*/
static async #onTriggerRest(_, button) {
const confirmed = await foundry.applications.api.DialogV2.confirm({
window: {
title: game.i18n.localize(`DAGGERHEART.APPLICATIONS.Downtime.${button.dataset.type}.title`),
@ -304,6 +346,30 @@ export default class Party extends DHBaseActorSheet {
});
}
/**
* @this PartySheet
* @type {ApplicationClickAction}
*/
static async #onDeletePartyMember(event, target) {
const doc = await foundry.utils.fromUuid(target.closest('[data-uuid]')?.dataset.uuid);
if (!event.shiftKey) {
const confirmed = await foundry.applications.api.DialogV2.confirm({
window: {
title: game.i18n.format('DAGGERHEART.ACTORS.Party.RemoveConfirmation.title', {
name: doc.name
})
},
content: game.i18n.format('DAGGERHEART.ACTORS.Party.RemoveConfirmation.text', { name: doc.name })
});
if (!confirmed) return;
}
const currentMembers = this.document.system.partyMembers.map(x => x.uuid);
const newMembersList = currentMembers.filter(uuid => uuid !== doc.uuid);
await this.document.update({ 'system.partyMembers': newMembersList });
}
static async downtimeMoveQuery({ actorId, downtimeType }) {
const actor = await foundry.utils.fromUuid(actorId);
if (!actor || !actor?.isOwner) return;
@ -312,11 +378,19 @@ export default class Party extends DHBaseActorSheet {
});
}
static async #tagTeamRoll() {
/**
* @this PartySheet
* @type {ApplicationClickAction}
*/
static async #onTagTeamRoll() {
new game.system.api.applications.dialogs.TagTeamDialog(this.document).render({ force: true });
}
static async #groupRoll(_params) {
/**
* @this PartySheet
* @type {ApplicationClickAction}
*/
static async #onGroupRoll(_params) {
new game.system.api.applications.dialogs.GroupRollDialog(this.document).render({ force: true });
}
@ -460,11 +534,10 @@ export default class Party extends DHBaseActorSheet {
}
}
/* -------------------------------------------- */
/** @inheritdoc */
async _onDropActor(event, document) {
const data = foundry.applications.ux.TextEditor.implementation.getDragEventData(event);
if (document instanceof DhpActor && Party.ALLOWED_ACTOR_TYPES.includes(document.type)) {
if (document instanceof DhpActor && PartySheet.ALLOWED_ACTOR_TYPES.includes(document.type)) {
const currentMembers = this.document.system.partyMembers.map(x => x.uuid);
if (currentMembers.includes(data.uuid)) {
return ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.duplicateCharacter'));
@ -477,24 +550,4 @@ export default class Party extends DHBaseActorSheet {
return null;
}
static async #deletePartyMember(event, target) {
const doc = await foundry.utils.fromUuid(target.closest('[data-uuid]')?.dataset.uuid);
if (!event.shiftKey) {
const confirmed = await foundry.applications.api.DialogV2.confirm({
window: {
title: game.i18n.format('DAGGERHEART.ACTORS.Party.RemoveConfirmation.title', {
name: doc.name
})
},
content: game.i18n.format('DAGGERHEART.ACTORS.Party.RemoveConfirmation.text', { name: doc.name })
});
if (!confirmed) return;
}
const currentMembers = this.document.system.partyMembers.map(x => x.uuid);
const newMembersList = currentMembers.filter(uuid => uuid !== doc.uuid);
await this.document.update({ 'system.partyMembers': newMembersList });
}
}

26
module/config/encounterConfig.mjs
View file

@ -90,18 +90,20 @@ export const BPModifiers = {
name: 'DAGGERHEART.CONFIG.BPModifiers.increaseDamage.effect.name',
description: 'DAGGERHEART.CONFIG.BPModifiers.increaseDamage.effect.description',
img: 'icons/magic/control/buff-flight-wings-red.webp',
changes: [
{
key: 'system.bonuses.damage.physical.dice',
mode: 2,
value: '1d4'
},
{
key: 'system.bonuses.damage.magical.dice',
mode: 2,
value: '1d4'
}
]
system: {
changes: [
{
key: 'system.bonuses.damage.physical.dice',
type: 'add',
value: '1d4'
},
{
key: 'system.bonuses.damage.magical.dice',
type: 'add',
value: '1d4'
}
]
}
}
]
}

551
module/config/itemConfig.mjs
View file

@ -37,13 +37,15 @@ export const armorFeatures = {
name: 'DAGGERHEART.CONFIG.ArmorFeature.channeling.effects.channeling.name',
description: 'DAGGERHEART.CONFIG.ArmorFeature.channeling.effects.channeling.description',
img: 'icons/magic/symbols/rune-sigil-horned-blue.webp',
changes: [
{
key: 'system.bonuses.roll.spellcast',
mode: 2,
value: '1'
}
]
system: {
changes: [
{
key: 'system.bonuses.roll.spellcast',
type: 'add',
value: '1'
}
]
}
}
]
},
@ -55,43 +57,45 @@ export const armorFeatures = {
name: 'DAGGERHEART.CONFIG.ArmorFeature.difficult.effects.difficult.name',
description: 'DAGGERHEART.CONFIG.ArmorFeature.difficult.effects.difficult.description',
img: 'icons/magic/control/buff-flight-wings-red.webp',
changes: [
{
key: 'system.traits.agility.value',
mode: 2,
value: '-1'
},
{
key: 'system.traits.strength.value',
mode: 2,
value: '-1'
},
{
key: 'system.traits.finesse.value',
mode: 2,
value: '-1'
},
{
key: 'system.traits.instinct.value',
mode: 2,
value: '-1'
},
{
key: 'system.traits.presence.value',
mode: 2,
value: '-1'
},
{
key: 'system.traits.knowledge.value',
mode: 2,
value: '-1'
},
{
key: 'system.evasion',
mode: 2,
value: '-1'
}
]
system: {
changes: [
{
key: 'system.traits.agility.value',
type: 'add',
value: '-1'
},
{
key: 'system.traits.strength.value',
type: 'add',
value: '-1'
},
{
key: 'system.traits.finesse.value',
type: 'add',
value: '-1'
},
{
key: 'system.traits.instinct.value',
type: 'add',
value: '-1'
},
{
key: 'system.traits.presence.value',
type: 'add',
value: '-1'
},
{
key: 'system.traits.knowledge.value',
type: 'add',
value: '-1'
},
{
key: 'system.evasion',
type: 'add',
value: '-1'
}
]
}
}
]
},
@ -103,13 +107,15 @@ export const armorFeatures = {
name: 'DAGGERHEART.CONFIG.ArmorFeature.flexible.effects.flexible.name',
description: 'DAGGERHEART.CONFIG.ArmorFeature.flexible.effects.flexible.description',
img: 'icons/magic/movement/abstract-ribbons-red-orange.webp',
changes: [
{
key: 'system.evasion',
mode: 2,
value: '1'
}
]
system: {
changes: [
{
key: 'system.evasion',
type: 'add',
value: '1'
}
]
}
}
]
},
@ -121,13 +127,15 @@ export const armorFeatures = {
name: 'DAGGERHEART.CONFIG.ArmorFeature.fortified.effects.fortified.name',
description: 'DAGGERHEART.CONFIG.ArmorFeature.fortified.effects.fortified.description',
img: 'icons/magic/defensive/shield-barrier-glowing-blue.webp',
changes: [
{
key: 'system.rules.damageReduction.increasePerArmorMark',
mode: 5,
value: '2'
}
]
system: {
changes: [
{
key: 'system.rules.damageReduction.increasePerArmorMark',
type: 'override',
value: '2'
}
]
}
}
]
},
@ -139,13 +147,15 @@ export const armorFeatures = {
name: 'DAGGERHEART.CONFIG.ArmorFeature.gilded.effects.gilded.name',
description: 'DAGGERHEART.CONFIG.ArmorFeature.gilded.effects.gilded.description',
img: 'icons/magic/control/control-influence-crown-gold.webp',
changes: [
{
key: 'system.traits.presence.value',
mode: 2,
value: '1'
}
]
system: {
changes: [
{
key: 'system.traits.presence.value',
type: 'add',
value: '1'
}
]
}
}
]
},
@ -157,13 +167,15 @@ export const armorFeatures = {
name: 'DAGGERHEART.CONFIG.ArmorFeature.heavy.effects.heavy.name',
description: 'DAGGERHEART.CONFIG.ArmorFeature.heavy.effects.heavy.description',
img: 'icons/commodities/metal/ingot-worn-iron.webp',
changes: [
{
key: 'system.evasion',
mode: 2,
value: '-1'
}
]
system: {
changes: [
{
key: 'system.evasion',
type: 'add',
value: '-1'
}
]
}
}
]
},
@ -212,13 +224,15 @@ export const armorFeatures = {
name: 'DAGGERHEART.CONFIG.ArmorFeature.magical.effects.magical.name',
description: 'DAGGERHEART.CONFIG.ArmorFeature.magical.effects.magical.description',
img: 'icons/magic/defensive/barrier-shield-dome-blue-purple.webp',
changes: [
{
key: 'system.rules.damageReduction.magical',
mode: 5,
value: 1
}
]
system: {
changes: [
{
key: 'system.rules.damageReduction.magical',
type: 'override',
value: 1
}
]
}
}
]
},
@ -249,13 +263,15 @@ export const armorFeatures = {
name: 'DAGGERHEART.CONFIG.ArmorFeature.physical.effects.physical.name',
description: 'DAGGERHEART.CONFIG.ArmorFeature.physical.effects.physical.description',
img: 'icons/commodities/stone/ore-pile-tan.webp',
changes: [
{
key: 'system.rules.damageReduction.physical',
mode: 5,
value: 1
}
]
system: {
changes: [
{
key: 'system.rules.damageReduction.physical',
type: 'override',
value: 1
}
]
}
}
]
},
@ -280,18 +296,20 @@ export const armorFeatures = {
name: 'DAGGERHEART.CONFIG.ArmorFeature.reinforced.effects.reinforced.name',
description: 'DAGGERHEART.CONFIG.ArmorFeature.reinforced.effects.reinforced.description',
img: 'icons/magic/defensive/shield-barrier-glowing-triangle-green.webp',
changes: [
{
key: 'system.bunuses.damageThresholds.major',
mode: 2,
value: '2'
},
{
key: 'system.bunuses.damageThresholds.severe',
mode: 2,
value: '2'
}
]
system: {
changes: [
{
key: 'system.bunuses.damageThresholds.major',
type: 'add',
value: '2'
},
{
key: 'system.bunuses.damageThresholds.severe',
type: 'add',
value: '2'
}
]
}
}
]
},
@ -326,18 +344,20 @@ export const armorFeatures = {
name: 'DAGGERHEART.CONFIG.ArmorFeature.sharp.effects.sharp.name',
description: 'DAGGERHEART.CONFIG.ArmorFeature.sharp.effects.sharp.description',
img: 'icons/magic/defensive/shield-barrier-glowing-triangle-green.webp',
changes: [
{
key: 'system.bonuses.damage.primaryWeapon.dice',
mode: 2,
value: '1d4'
},
{
key: 'system.bonuses.damage.secondaryWeapon.dice',
mode: 2,
value: '1d4'
}
]
system: {
changes: [
{
key: 'system.bonuses.damage.primaryWeapon.dice',
type: 'add',
value: '1d4'
},
{
key: 'system.bonuses.damage.secondaryWeapon.dice',
type: 'add',
value: '1d4'
}
]
}
}
]
},
@ -408,18 +428,20 @@ export const armorFeatures = {
name: 'DAGGERHEART.CONFIG.ArmorFeature.veryHeavy.effects.veryHeavy.name',
description: 'DAGGERHEART.CONFIG.ArmorFeature.veryHeavy.effects.veryHeavy.description',
img: 'icons/commodities/metal/ingot-stamped-steel.webp',
changes: [
{
key: 'system.evasion',
mode: 2,
value: '-2'
},
{
key: 'system.traits.agility.value',
mode: 2,
value: '-1'
}
]
system: {
changes: [
{
key: 'system.evasion',
type: 'add',
value: '-2'
},
{
key: 'system.traits.agility.value',
type: 'add',
value: '-1'
}
]
}
}
]
},
@ -431,14 +453,16 @@ export const armorFeatures = {
name: 'DAGGERHEART.CONFIG.ArmorFeature.warded.effects.warded.name',
description: 'DAGGERHEART.CONFIG.ArmorFeature.warded.effects.warded.description',
img: 'icons/magic/defensive/barrier-shield-dome-pink.webp',
changes: [
{
key: 'system.resistance.magical.reduction',
mode: 2,
value: '@system.armorScore',
priority: 21
}
]
system: {
changes: [
{
key: 'system.resistance.magical.reduction',
type: 'add',
value: '@system.armorScore',
priority: 21
}
]
}
}
]
}
@ -488,21 +512,23 @@ export const weaponFeatures = {
name: 'DAGGERHEART.CONFIG.WeaponFeature.barrier.effects.barrier.name',
description: 'DAGGERHEART.CONFIG.WeaponFeature.barrier.effects.barrier.description',
img: 'icons/skills/melee/shield-block-bash-blue.webp',
changes: [
{
key: 'system.evasion',
mode: 2,
value: '-1'
},
{
key: 'Armor',
type: 'armor',
typeData: {
system: {
changes: [
{
key: 'system.evasion',
type: 'add',
value: '-1'
},
{
key: 'Armor',
type: 'armor',
max: 'ITEM.@system.tier + 1'
typeData: {
type: 'armor',
max: 'ITEM.@system.tier + 1'
}
}
}
]
]
}
}
]
},
@ -514,13 +540,15 @@ export const weaponFeatures = {
name: 'DAGGERHEART.CONFIG.WeaponFeature.bonded.effects.damage.name',
description: 'DAGGERHEART.CONFIG.WeaponFeature.bonded.effects.damage.description',
img: 'icons/magic/symbols/chevron-elipse-circle-blue.webp',
changes: [
{
key: 'system.bonuses.damage.primaryWeapon.bonus',
mode: 2,
value: '@system.levelData.level.current'
}
]
system: {
changes: [
{
key: 'system.bonuses.damage.primaryWeapon.bonus',
type: 'add',
value: '@system.levelData.level.current'
}
]
}
}
]
},
@ -553,18 +581,20 @@ export const weaponFeatures = {
name: 'DAGGERHEART.CONFIG.WeaponFeature.brave.effects.brave.name',
description: 'DAGGERHEART.CONFIG.WeaponFeature.brave.effects.brave.description',
img: 'icons/magic/life/heart-cross-strong-flame-purple-orange.webp',
changes: [
{
key: 'system.evasion',
mode: 2,
value: '-1'
},
{
key: 'system.damageThresholds.severe',
mode: 2,
value: 'ITEM.@system.tier'
}
]
system: {
changes: [
{
key: 'system.evasion',
type: 'add',
value: '-1'
},
{
key: 'system.damageThresholds.severe',
type: 'add',
value: 'ITEM.@system.tier'
}
]
}
}
]
},
@ -618,13 +648,15 @@ export const weaponFeatures = {
name: 'DAGGERHEART.CONFIG.WeaponFeature.charged.name',
description: 'DAGGERHEART.CONFIG.WeaponFeature.charged.description',
img: 'icons/magic/lightning/claws-unarmed-strike-teal.webp',
changes: [
{
key: 'system.proficiency',
mode: 2,
value: '1'
}
]
system: {
changes: [
{
key: 'system.proficiency',
type: 'add',
value: '1'
}
]
}
}
]
}
@ -660,13 +692,15 @@ export const weaponFeatures = {
name: 'DAGGERHEART.CONFIG.WeaponFeature.cumbersome.effects.cumbersome.name',
description: 'DAGGERHEART.CONFIG.WeaponFeature.cumbersome.effects.cumbersome.description',
img: 'icons/commodities/metal/mail-plate-steel.webp',
changes: [
{
key: 'system.traits.finesse.value',
mode: 2,
value: '-1'
}
]
system: {
changes: [
{
key: 'system.traits.finesse.value',
type: 'add',
value: '-1'
}
]
}
}
]
},
@ -707,14 +741,16 @@ export const weaponFeatures = {
name: 'DAGGERHEART.CONFIG.WeaponFeature.deflecting.effects.deflecting.name',
description: 'DAGGERHEART.CONFIG.WeaponFeature.deflecting.effects.deflecting.description',
img: 'icons/skills/melee/hand-grip-sword-strike-orange.webp',
changes: [
{
key: 'system.evasion',
mode: 2,
value: '@system.armorScore',
priority: 21
}
]
system: {
changes: [
{
key: 'system.evasion',
type: 'add',
value: '@system.armorScore',
priority: 21
}
]
}
}
]
}
@ -754,13 +790,15 @@ export const weaponFeatures = {
name: 'DAGGERHEART.CONFIG.WeaponFeature.destructive.name',
description: 'DAGGERHEART.CONFIG.WeaponFeature.destructive.effects.agility',
img: 'icons/skills/melee/strike-flail-spiked-pink.webp',
changes: [
{
key: 'system.traits.agility.value',
mode: 2,
value: '-1'
}
]
system: {
changes: [
{
key: 'system.traits.agility.value',
type: 'add',
value: '-1'
}
]
}
}
]
},
@ -791,14 +829,14 @@ export const weaponFeatures = {
name: 'DAGGERHEART.CONFIG.WeaponFeature.doubleDuty.effects.doubleDuty.name',
description: 'DAGGERHEART.CONFIG.WeaponFeature.doubleDuty.effects.doubleDuty.description',
img: 'icons/skills/melee/sword-shield-stylized-white.webp',
changes: [
{
key: 'system.bonuses.damage.primaryWeapon.bonus',
mode: 2,
value: '1'
}
],
system: {
changes: [
{
key: 'system.bonuses.damage.primaryWeapon.bonus',
type: 'add',
value: '1'
}
],
rangeDependence: {
enabled: true,
range: 'melee',
@ -902,13 +940,15 @@ export const weaponFeatures = {
name: 'DAGGERHEART.CONFIG.WeaponFeature.greedy.actions.greed.name',
description: 'DAGGERHEART.CONFIG.WeaponFeature.greedy.actions.greed.description',
img: 'icons/commodities/currency/coins-crown-stack-gold.webp',
changes: [
{
key: 'system.proficiency',
mode: 2,
value: '1'
}
]
system: {
changes: [
{
key: 'system.proficiency',
type: 'add',
value: '1'
}
]
}
}
]
}
@ -951,13 +991,15 @@ export const weaponFeatures = {
name: 'DAGGERHEART.CONFIG.WeaponFeature.heavy.effects.heavy.name',
description: 'DAGGERHEART.CONFIG.WeaponFeature.heavy.effects.heavy.description',
img: 'icons/commodities/metal/ingot-worn-iron.webp',
changes: [
{
key: 'system.evasion',
mode: 2,
value: '-1'
}
]
system: {
changes: [
{
key: 'system.evasion',
type: 'add',
value: '-1'
}
]
}
}
]
},
@ -1066,13 +1108,15 @@ export const weaponFeatures = {
name: 'DAGGERHEART.CONFIG.WeaponFeature.massive.effects.massive.name',
description: 'DAGGERHEART.CONFIG.WeaponFeature.massive.effects.massive.description',
img: 'icons/skills/melee/strike-flail-destructive-yellow.webp',
changes: [
{
key: 'system.evasion',
mode: 2,
value: '-1'
}
]
system: {
changes: [
{
key: 'system.evasion',
type: 'add',
value: '-1'
}
]
}
}
]
},
@ -1103,14 +1147,14 @@ export const weaponFeatures = {
name: 'DAGGERHEART.CONFIG.WeaponFeature.paired.effects.paired.name',
description: 'DAGGERHEART.CONFIG.WeaponFeature.paired.effects.paired.description',
img: 'icons/skills/melee/weapons-crossed-swords-yellow-teal.webp',
changes: [
{
key: 'system.bonuses.damage.primaryWeapon.bonus',
mode: 2,
value: 'ITEM.@system.tier + 1'
}
],
system: {
changes: [
{
key: 'system.bonuses.damage.primaryWeapon.bonus',
type: 'add',
value: 'ITEM.@system.tier + 1'
}
],
rangeDependence: {
enabled: true,
range: 'melee',
@ -1158,13 +1202,15 @@ export const weaponFeatures = {
name: 'DAGGERHEART.CONFIG.WeaponFeature.persuasive.effects.persuasive.name',
description: 'DAGGERHEART.CONFIG.WeaponFeature.persuasive.effects.persuasive.description',
img: 'icons/magic/control/hypnosis-mesmerism-eye.webp',
changes: [
{
key: 'system.traits.presence.value',
mode: 2,
value: '2'
}
]
system: {
changes: [
{
key: 'system.traits.presence.value',
type: 'add',
value: '2'
}
]
}
}
]
}
@ -1203,17 +1249,20 @@ export const weaponFeatures = {
name: 'DAGGERHEART.CONFIG.WeaponFeature.protective.effects.protective.name',
description: 'DAGGERHEART.CONFIG.WeaponFeature.protective.effects.protective.description',
img: 'icons/skills/melee/shield-block-gray-orange.webp',
changes: [
{
key: 'Armor',
type: 'armor',
value: 0,
typeData: {
system: {
changes: [
{
key: 'Armor',
type: 'armor',
max: 'ITEM.@system.tier'
value: 0,
typeData: {
type: 'armor',
max: 'ITEM.@system.tier'
}
}
}
]
]
}
}
]
},
@ -1244,13 +1293,15 @@ export const weaponFeatures = {
name: 'DAGGERHEART.CONFIG.WeaponFeature.reliable.effects.reliable.name',
description: 'DAGGERHEART.CONFIG.WeaponFeature.reliable.effects.reliable.description',
img: 'icons/skills/melee/strike-sword-slashing-red.webp',
changes: [
{
key: 'system.bonuses.roll.primaryWeapon.bonus',
mode: 2,
value: 1
}
]
system: {
changes: [
{
key: 'system.bonuses.roll.primaryWeapon.bonus',
type: 'add',
value: 1
}
]
}
}
]
},
@ -1341,7 +1392,7 @@ export const weaponFeatures = {
changes: [
{
key: 'system.bonuses.damage.primaryWeapon.bonus',
mode: 2,
type: 'add',
value: '@system.traits.agility.value',
priority: 21
}

23
module/data/activeEffect/baseEffect.mjs
View file

@ -57,11 +57,6 @@ export default class BaseEffect extends foundry.data.ActiveEffectTypeDataModel {
description: new fields.HTMLField({ label: 'DAGGERHEART.GENERAL.description' })
}),
rangeDependence: new fields.SchemaField({
enabled: new fields.BooleanField({
required: true,
initial: false,
label: 'DAGGERHEART.GENERAL.enabled'
}),
type: new fields.StringField({
required: true,
choices: CONFIG.DH.GENERAL.rangeInclusion,
@ -80,7 +75,7 @@ export default class BaseEffect extends foundry.data.ActiveEffectTypeDataModel {
initial: CONFIG.DH.GENERAL.range.melee.id,
label: 'DAGGERHEART.GENERAL.range'
})
}),
}, { nullable: true, initial: null }),
stacking: new fields.SchemaField(
{
value: new fields.NumberField({
@ -146,14 +141,8 @@ export default class BaseEffect extends foundry.data.ActiveEffectTypeDataModel {
description: '',
transfer: options.transfer,
statuses: [],
changes: [],
system: {
rangeDependence: {
enabled: false,
type: CONFIG.DH.GENERAL.rangeInclusion.withinRange.id,
target: CONFIG.DH.GENERAL.otherTargetTypes.hostile.id,
range: CONFIG.DH.GENERAL.range.melee.id
}
changes: []
}
};
}
@ -185,4 +174,12 @@ export default class BaseEffect extends foundry.data.ActiveEffectTypeDataModel {
if (this.parent.actor && options.scrollingTextData)
this.parent.actor.queueScrollText(options.scrollingTextData);
}
static migrateData(source) {
if (source.rangeDependence?.enabled === false) {
source.rangeDependence = null;
}
return super.migrateData(source);
}
}

3
module/data/item/armor.mjs
View file

@ -8,7 +8,8 @@ export default class DHArmor extends AttachableItem {
type: 'armor',
hasDescription: true,
isInventoryItem: true,
hasActions: true
hasActions: true,
hasResource: true
});
}

7
module/dice/d20Roll.mjs
View file

@ -185,8 +185,10 @@ export default class D20Roll extends DHRoll {
return changeKeys;
}
static postEvaluate(roll, config = {}) {
const data = super.postEvaluate(roll, config);
static async buildEvaluate(roll, config = {}, message = {}) {
await super.buildEvaluate(roll, config, message);
const data = config.roll;
data.type = config.actionType;
data.difficulty = config.roll.difficulty;
if (config.targets?.length) {
@ -222,7 +224,6 @@ export default class D20Roll extends DHRoll {
};
});
data.modifierTotal = roll.modifierTotal;
return data;
}
resetFormula() {

36
module/dice/damageRoll.mjs
View file

@ -13,32 +13,38 @@ export default class DamageRoll extends DHRoll {
static DefaultDialog = DamageDialog;
/** @inheritdoc */
static async buildEvaluate(roll, config = {}, message = {}) {
if (config.dialog.configure === false) roll.constructFormula(config);
if (config.evaluate !== false) for (const roll of config.roll) await roll.roll.evaluate();
for (const roll of config.roll) await roll.roll.evaluate();
roll._evaluated = true;
const parts = [];
for (const roll of config.roll) {
parts.push(this.postEvaluate(roll));
roll.roll = JSON.stringify(roll.roll.toJSON());
for (const rollData of config.roll) {
const roll = rollData.roll;
parts.push({
...rollData,
...roll.options.roll,
total: roll.total,
formula: roll.formula,
dice: roll.dice.map(d => ({
dice: d.denomination,
total: d.total,
formula: d.formula,
results: d.results
})),
damageTypes: [...(rollData.damageTypes ?? [])],
roll,
type: config.type,
modifierTotal: this.calculateTotalModifiers(roll)
});
rollData.roll = JSON.stringify(roll.toJSON());
}
config.damage = this.unifyDamageRoll(parts);
}
static postEvaluate(roll, config = {}) {
return {
...roll,
...super.postEvaluate(roll.roll, config),
damageTypes: [...(roll.damageTypes ?? [])],
roll: roll.roll,
type: config.type,
modifierTotal: this.calculateTotalModifiers(roll.roll)
};
}
static async buildPost(roll, config, message) {
const chatMessage = config.source?.message
? ui.chat.collection.get(config.source.message)

47
module/dice/dhRoll.mjs
View file

@ -33,7 +33,9 @@ export default class DHRoll extends Roll {
if (config.skips?.createMessage) config.messageRoll = roll;
await this.buildEvaluate(roll, config, (message = {}));
if (config.evaluate !== false) {
await this.buildEvaluate(roll, config, (message = {}));
}
await this.buildPost(roll, config, (message = {}));
return config;
}
@ -72,27 +74,14 @@ export default class DHRoll extends Roll {
return roll;
}
/**
* Evaluates the roll and assigns roll data into the config.
* This is only called if config.evaluate is not set to false
* @protected
*/
static async buildEvaluate(roll, config = {}, message = {}) {
if (config.evaluate !== false) {
await roll.evaluate();
config.roll = this.postEvaluate(roll, config);
}
}
static async buildPost(roll, config, message) {
for (const hook of config.hooks) {
if (Hooks.call(`${CONFIG.DH.id}.postRoll${hook.capitalize()}`, config, message) === false) return null;
}
if (config.skips?.createMessage) {
await triggerChatRollFx([roll]);
} else if (!config.source?.message) {
config.message = await this.toMessage(roll, config);
}
}
static postEvaluate(roll, config = {}) {
return {
await roll.evaluate();
config.roll = {
...roll.options.roll,
total: roll.total,
formula: roll.formula,
@ -105,6 +94,22 @@ export default class DHRoll extends Roll {
};
}
/**
* Runs any post configuration events that need to happen towards the end, such as hooks and dice so nice
* @protected
*/
static async buildPost(roll, config, message) {
for (const hook of config.hooks) {
if (Hooks.call(`${CONFIG.DH.id}.postRoll${hook.capitalize()}`, config, message) === false) return null;
}
if (config.skips?.createMessage) {
await triggerChatRollFx([roll]);
} else if (!config.source?.message) {
config.message = await this.toMessage(roll, config);
}
}
static async toMessage(roll, config) {
const item = config.data.parent?.items?.get?.(config.source.item) ?? null;
const action = item ? item.system.actions.get(config.source.action) : null;

35
module/dice/dualityRoll.mjs
View file

@ -232,22 +232,10 @@ export default class DualityRoll extends D20Roll {
return changeKeys;
}
/** @inheritdoc */
static async buildEvaluate(roll, config = {}, message = {}) {
await super.buildEvaluate(roll, config, message);
await setDiceSoNiceForDualityRoll(
roll,
config.roll.advantage.type,
config.roll.hope.dice,
config.roll.fear.dice,
config.roll.advantage.dice
);
}
static postEvaluate(roll, config = {}) {
const data = super.postEvaluate(roll, config);
data.hope = {
config.roll.hope = {
dice: roll.dHope.denomination,
value: this.guaranteedCritical ? 0 : roll.dHope.total,
rerolled: {
@ -255,7 +243,7 @@ export default class DualityRoll extends D20Roll {
rerolls: roll.dHope.results.filter(x => x.rerolled)
}
};
data.fear = {
config.roll.fear = {
dice: roll.dFear.denomination,
value: this.guaranteedCritical ? 0 : roll.dFear.total,
rerolled: {
@ -263,11 +251,11 @@ export default class DualityRoll extends D20Roll {
rerolls: roll.dFear.results.filter(x => x.rerolled)
}
};
data.rally = {
config.roll.rally = {
dice: roll.dRally?.denomination,
value: roll.dRally?.total
};
data.result = {
config.roll.result = {
duality: roll.withHope ? 1 : roll.withFear ? -1 : 0,
total: this.guaranteedCritical ? 0 : roll.dHope.total + roll.dFear.total,
label: roll.totalLabel
@ -275,11 +263,18 @@ export default class DualityRoll extends D20Roll {
if (roll._rallyIndex && roll.data?.parent)
roll.data.parent.deleteEmbeddedDocuments('ActiveEffect', [roll._rallyIndex]);
return data;
}
/** @inheritdoc */
static async buildPost(roll, config, message) {
await setDiceSoNiceForDualityRoll(
roll,
config.roll.advantage.type,
config.roll.hope.dice,
config.roll.fear.dice,
config.roll.advantage.dice
);
await super.buildPost(roll, config, message);
await DualityRoll.dualityUpdate(config);

22
module/dice/fateRoll.mjs
View file

@ -75,25 +75,23 @@ export default class FateRoll extends D20Roll {
this.terms[0] = new foundry.dice.terms.Die({ faces: 12 });
}
/** @inheritdoc */
static async buildEvaluate(roll, config = {}, message = {}) {
await super.buildEvaluate(roll, config, message);
config.roll.fate = {
dice: roll.fateDie === 'Hope' ? roll.dHope.denomination : roll.dFear.denomination,
value: roll.fateDie === 'Hope' ? roll.dHope.total : roll.dFear.total,
fateDie: roll.fateDie
};
}
/** @inheritdoc */
static async buildPost(roll, config, message) {
if (roll.fateDie === 'Hope') {
await setDiceSoNiceForHopeFateRoll(roll, config.roll.fate.dice);
} else {
await setDiceSoNiceForFearFateRoll(roll, config.roll.fate.dice);
}
}
static postEvaluate(roll, config = {}) {
const data = super.postEvaluate(roll, config);
data.fate = {
dice: roll.fateDie === 'Hope' ? roll.dHope.denomination : roll.dFear.denomination,
value: roll.fateDie === 'Hope' ? roll.dHope.total : roll.dFear.total,
fateDie: roll.fateDie
};
return data;
return super.buildPost(roll, config, message);
}
}

16
module/documents/actor.mjs
View file

@ -622,22 +622,30 @@ export default class DhpActor extends Actor {
return rollData;
}
#canReduceDamage(hpDamage, type) {
const { stressDamageReduction, disabledArmor } = this.system.rules.damageReduction;
#canReduceDamage(hpDamage, types) {
const { stressDamageReduction, disabledArmor, reduceSeverity, thresholdImmunities } =
this.system.rules.damageReduction;
if (disabledArmor) return false;
const availableStress = this.system.resources.stress.max - this.system.resources.stress.value;
const canUseArmor =
this.system.armorScore.value < this.system.armorScore.max &&
type.every(t => this.system.armorApplicableDamageTypes[t] === true);
types.every(t => this.system.armorApplicableDamageTypes[t] === true);
const canUseStress = Object.keys(stressDamageReduction).reduce((acc, x) => {
const rule = stressDamageReduction[x];
if (damageKeyToNumber(x) <= hpDamage) return acc || (rule.enabled && availableStress >= rule.cost);
return acc;
}, false);
return canUseArmor || canUseStress;
const hasReduceSeverity = types.some(t => reduceSeverity[t]);
const hasThresholdImmunity = Object.entries(thresholdImmunities)
.filter(([key, value]) => Boolean(value) && damageKeyToNumber(key) === hpDamage)
.length;
return canUseArmor || canUseStress || hasReduceSeverity || hasThresholdImmunity;
}
async takeDamage(damages, isDirect = false) {

2
module/enrichers/TemplateEnricher.mjs
View file

@ -58,7 +58,7 @@ export const renderMeasuredTemplate = async event => {
if (!type || !range || !game.canvas.scene) return;
const shapeData = CONFIG.Canvas.layers.regions.layerClass.getTemplateShape({
shapetype: type,
shapeType: type,
angle,
range,
direction,

17
module/enrichers/_module.mjs
View file

@ -35,23 +35,24 @@ export const enricherConfig = [
];
export const enricherRenderSetup = element => {
const clickWrapper = func => event => {
event.stopPropagation();
func(event);
};
element
.querySelectorAll('.enriched-damage-button')
.forEach(element => element.addEventListener('click', renderDamageButton));
.forEach(element => element.addEventListener('click', clickWrapper(renderDamageButton)));
element
.querySelectorAll('.duality-roll-button')
.forEach(element => element.addEventListener('click', renderDualityButton));
.forEach(element => element.addEventListener('click', clickWrapper(renderDualityButton)));
element
.querySelectorAll('.fate-roll-button')
.forEach(element => element.addEventListener('click', renderFateButton));
.forEach(element => element.addEventListener('click', clickWrapper(renderFateButton)));
element
.querySelectorAll('.measured-template-button')
.forEach(element => element.addEventListener('click', renderMeasuredTemplate));
// element
// .querySelectorAll('.enriched-effect')
// .forEach(element => element.addEventListener('dragstart', dragEnrichedEffect));
.forEach(element => element.addEventListener('click', clickWrapper(renderMeasuredTemplate)));
};

38
module/systemRegistration/migration-handlers/2_5_2.mjs Normal file
View file

@ -0,0 +1,38 @@
import { MigrationHandlerBase } from './base.mjs';
export class Migration_2_5_2 extends MigrationHandlerBase {
version = '2.5.2';
/** @inheritdoc */
async updateActiveEffectSource(effectSource, item) {
let shouldUpdate = false;
const newChanges = [];
const srdItem = item?._stats.compendiumSource ?
await foundry.utils.fromUuid(item?._stats.compendiumSource) :
null;
for (let i = 0; i < effectSource.system.changes.length; i++) {
const change = effectSource.system.changes[i];
const srdEffect = srdItem?.effects.find(x => x.name === effectSource.name);
if (change.type === 'custom') {
const srdChange = srdEffect ? srdEffect.system.changes[i] : null;
if (
change.key === srdChange.key &&
change.value === srdChange.value &&
change.type !== srdChange.type
) {
shouldUpdate = true;
newChanges.push(srdChange);
}
} else {
newChanges.push(change);
}
}
if (shouldUpdate) {
return {
_id: effectSource._id,
system: { changes: newChanges }
}
}
}
}

77
module/systemRegistration/migration-handlers/base.mjs Normal file
View file

@ -0,0 +1,77 @@
/**
* @import DHItem from "../../documents/item.mjs";
*/
/**
* The base class of an async migration.
* These are generally run between versions for things that require compendiums or must be done in post.
* The migrate() functions calls the various updateXSource() functions.
* Generally a subclass will override the version and the updateXSource() functions.
*/
export class MigrationHandlerBase {
version = null;
/**
* Gets change data for an active effect's source, or null if no changes
* @param {object} effectSource
* @param {DHItem} item
* @returns {Promise<object>}
* @protected
*/
async updateActiveEffectSource(effectSource, item) {
return null;
}
async migrate() {
// todo: handle more than just migrating effects. Right now this can only migrate effects
// NOTE: the preload is hardcoded, we should not hardcode it
const numActors = game.actors.size;
const numItems = game.items.size;
const finalUpdateProgress = 5;
const DhProgress = game.system.api.applications.ui.DhProgress;
const preRunProgress = game.packs.size;
const progress = DhProgress.createMigrationProgress(
preRunProgress + numActors + numItems + finalUpdateProgress
);
// Preload. Avoid hardcoding in the future
for (const pack of game.packs) {
await pack.getDocuments();
progress.advance();
}
const batch = [];
const updateItem = async item => {
const itemUpdates = [];
for (const effect of item.effects) {
const changes = await this.updateActiveEffectSource(effect.toObject(), item);
if (changes) itemUpdates.push(changes);
}
if (itemUpdates.length) {
batch.push({
action: 'update',
documentName: 'ActiveEffect',
updates: itemUpdates,
parent: item
});
}
};
for (const actor of game.actors) {
for (const item of actor.items) {
await updateItem(item);
}
progress.advance();
}
for (const item of game.items) {
await updateItem(item);
progress.advance();
}
await foundry.documents.modifyBatch(batch);
progress.advance({ by: finalUpdateProgress });
}
}

15
module/systemRegistration/migrations.mjs
View file

@ -1,4 +1,5 @@
import { defaultRestOptions } from '../config/generalConfig.mjs';
import { Migration_2_5_2 } from './migration-handlers/2_5_2.mjs';
export async function runMigrations() {
let lastMigrationVersion = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.LastMigrationVersion);
@ -320,7 +321,19 @@ export async function runMigrations() {
lastMigrationVersion = '2.1.0';
}
//#endregion
await game.settings.set(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.LastMigrationVersion, lastMigrationVersion);
/* -------------------------------------------- */
/* New Style migrations below this point */
/* -------------------------------------------- */
const migrations = [
new Migration_2_5_2()
].filter(m => m.version && foundry.utils.isNewerVersion(m.version, lastMigrationVersion));
for (const handler of migrations) {
await handler.migrate();
await game.settings.set(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.LastMigrationVersion, handler.version);
}
}

4
module/systemRegistration/socket.mjs
View file

@ -1,5 +1,5 @@
import DamageReductionDialog from '../applications/dialogs/damageReductionDialog.mjs';
import Party from '../applications/sheets/actors/party.mjs';
import PartySheet from '../applications/sheets/actors/party.mjs';
export function handleSocketEvent({ action = null, data = {} } = {}) {
switch (action) {
@ -16,7 +16,7 @@ export function handleSocketEvent({ action = null, data = {} } = {}) {
Hooks.call(socketEvent.Refresh, data);
break;
case socketEvent.DowntimeTrigger:
Party.downtimeMoveQuery(data);
PartySheet.downtimeMoveQuery(data);
break;
case socketEvent.TagTeamStart:
Hooks.callAll(CONFIG.DH.HOOKS.hooksConfig.tagTeamStart, data);