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

Fix conflicts

Browse source
This commit is contained in:
Dapoolp 2025-08-08 20:06:59 +02:00
commit 3ff6ec4f5e
164 changed files with 2542 additions and 749 deletions
Download patch file Download diff file Expand all files Collapse all files

38
module/data/action/baseAction.mjs
View file

@ -115,7 +115,6 @@ export default class DHBaseAction extends ActionMixin(foundry.abstract.DataModel
if (!this.actor) throw new Error("An Action can't be used outside of an Actor context.");
if (this.chatDisplay) await this.toChat();
let { byPassRoll } = options,
config = this.prepareConfig(event, byPassRoll);
for (let i = 0; i < this.constructor.extraSchemas.length; i++) {
@ -221,16 +220,13 @@ export default class DHBaseAction extends ActionMixin(foundry.abstract.DataModel
};
}
}
const resources = config.costs
.filter(c =>
c.enabled !== false
&&
(
(!successCost && (!c.consumeOnSuccess || config.roll?.success))
||
(successCost && c.consumeOnSuccess)
)
.filter(
c =>
c.enabled !== false &&
((!successCost && (!c.consumeOnSuccess || config.roll?.success)) ||
(successCost && c.consumeOnSuccess))
)
.map(c => {
const resource = usefulResources[c.key];
@ -243,14 +239,12 @@ export default class DHBaseAction extends ActionMixin(foundry.abstract.DataModel
});
await this.actor.modifyResource(resources);
if (config.uses?.enabled
&&
(
(!successCost && (!config.uses?.consumeOnSuccess || config.roll?.success))
||
(successCost && config.uses?.consumeOnSuccess)
)
) this.update({ 'uses.value': this.uses.value + 1 });
if (
config.uses?.enabled &&
((!successCost && (!config.uses?.consumeOnSuccess || config.roll?.success)) ||
(successCost && config.uses?.consumeOnSuccess))
)
this.update({ 'uses.value': this.uses.value + 1 });
if(config.roll?.success || successCost) {
setTimeout(() => {
@ -309,11 +303,9 @@ export default class DHBaseAction extends ActionMixin(foundry.abstract.DataModel
}
async applyEffect(effect, actor) {
const origin = effect.parent?.parent ? effect.parent.parent.uuid : effect.parent.uuid;
// Enable an existing effect on the target if it originated from this effect
const existingEffect = actor.effects.find(e => e.origin === origin);
const existingEffect = actor.effects.find(e => e.origin === effect.uuid);
if (existingEffect) {
return existingEffect.update(
return effect.update(
foundry.utils.mergeObject({
...effect.constructor.getInitialDuration(),
disabled: false
@ -326,7 +318,7 @@ export default class DHBaseAction extends ActionMixin(foundry.abstract.DataModel
...effect.toObject(),
disabled: false,
transfer: false,
origin: origin
origin: effect.uuid
});
await ActiveEffect.implementation.create(effectData, { parent: actor });
}

2
module/data/action/damageAction.mjs
View file

@ -51,7 +51,7 @@ export default class DHDamageAction extends DHBaseAction {
dialog: {},
data: this.getRollData(),
targetSelection: systemData.targets.length > 0
}
};
if (this.hasSave) config.onSave = this.save.damageMod;
if (data.system) {
config.source.message = data._id;

27
module/data/actor/character.mjs
View file

@ -68,12 +68,13 @@ export default class DhCharacter extends BaseDataActor {
new fields.SchemaField({
name: new fields.StringField(),
value: new fields.NumberField({ integer: true, initial: 0 }),
description: new fields.StringField()
description: new fields.StringField(),
core: new fields.BooleanField({ initial: false })
})
),
gold: new fields.SchemaField({
coins: new fields.NumberField({ initial: 0, integer: true }),
handfulls: new fields.NumberField({ initial: 0, integer: true }),
handfuls: new fields.NumberField({ initial: 1, integer: true }),
bags: new fields.NumberField({ initial: 0, integer: true }),
chests: new fields.NumberField({ initial: 0, integer: true })
}),
@ -573,7 +574,10 @@ export default class DhCharacter extends BaseDataActor {
case 'experience':
selection.data.forEach(id => {
const experience = this.experiences[id];
if (experience) experience.value += selection.value;
if (experience) {
experience.value += selection.value;
experience.leveledUp = true;
}
});
break;
}
@ -620,6 +624,23 @@ export default class DhCharacter extends BaseDataActor {
};
}
async _preUpdate(changes, options, userId) {
const allowed = await super._preUpdate(changes, options, userId);
if (allowed === false) return;
/* The first two experiences are always marked as core */
if (changes.system?.experiences && Object.keys(this.experiences).length < 2) {
const experiences = new Set(Object.keys(this.experiences));
const changeExperiences = new Set(Object.keys(changes.system.experiences));
const newExperiences = Array.from(changeExperiences.difference(experiences));
for (var i = 0; i < Math.min(newExperiences.length, 2 - experiences.size); i++) {
const experience = newExperiences[i];
changes.system.experiences[experience].core = true;
}
}
}
async _preDelete() {
if (this.companion) {
this.companion.updateLevel(1);

59
module/data/chat-message/adversaryRoll.mjs
View file

@ -1,20 +1,21 @@
const fields = foundry.data.fields;
const targetsField = () => new fields.ArrayField(
new fields.SchemaField({
id: new fields.StringField({}),
actorId: new fields.StringField({}),
name: new fields.StringField({}),
img: new fields.StringField({}),
difficulty: new fields.NumberField({ integer: true, nullable: true }),
evasion: new fields.NumberField({ integer: true }),
hit: new fields.BooleanField({ initial: false }),
saved: new fields.SchemaField({
result: new fields.NumberField(),
success: new fields.BooleanField({ nullable: true, initial: null })
const targetsField = () =>
new fields.ArrayField(
new fields.SchemaField({
id: new fields.StringField({}),
actorId: new fields.StringField({}),
name: new fields.StringField({}),
img: new fields.StringField({}),
difficulty: new fields.NumberField({ integer: true, nullable: true }),
evasion: new fields.NumberField({ integer: true }),
hit: new fields.BooleanField({ initial: false }),
saved: new fields.SchemaField({
result: new fields.NumberField(),
success: new fields.BooleanField({ nullable: true, initial: null })
})
})
})
)
);
export default class DHActorRoll extends foundry.abstract.TypeDataModel {
targetHook = null;
@ -39,27 +40,25 @@ export default class DHActorRoll extends foundry.abstract.TypeDataModel {
action: new fields.StringField()
}),
damage: new fields.ObjectField(),
costs: new fields.ArrayField(
new fields.ObjectField()
),
costs: new fields.ArrayField(new fields.ObjectField()),
successConsumed: new fields.BooleanField({ initial: false })
};
}
get actionActor() {
if(!this.source.actor) return null;
if (!this.source.actor) return null;
return fromUuidSync(this.source.actor);
}
get actionItem() {
const actionActor = this.actionActor;
if(!actionActor || !this.source.item) return null;
if (!actionActor || !this.source.item) return null;
return actionActor.items.get(this.source.item);
}
get action() {
const actionItem = this.actionItem;
if(!actionItem || !this.source.action) return null;
if (!actionItem || !this.source.action) return null;
return actionItem.system.actionsList?.find(a => a.id === this.source.action);
}
@ -74,7 +73,7 @@ export default class DHActorRoll extends foundry.abstract.TypeDataModel {
}
get hitTargets() {
return this.currentTargets.filter(t => (t.hit || !this.hasRoll || !this.targetSelection));
return this.currentTargets.filter(t => t.hit || !this.hasRoll || !this.targetSelection);
}
async updateTargets() {
@ -98,13 +97,13 @@ export default class DHActorRoll extends foundry.abstract.TypeDataModel {
if(this.targetSelection && this.targetHook !== null) {
Hooks.off("targetToken", this.targetHook);
this.targetHook = null;
} else if(!this.targetSelection && this.targetHook === null) {
this.targetHook = Hooks.on("targetToken", foundry.utils.debounce(this.updateTargets.bind(this), 50));
} else if (!this.targetSelection && this.targetHook === null) {
this.targetHook = Hooks.on('targetToken', foundry.utils.debounce(this.updateTargets.bind(this), 50));
}
}
prepareDerivedData() {
if(this.hasTarget) {
if (this.hasTarget) {
this.hasHitTarget = this.targets.filter(t => t.hit === true).length > 0;
this.currentTargets = this.getTargetList();
this. registerTargetHook();
@ -116,9 +115,9 @@ export default class DHActorRoll extends foundry.abstract.TypeDataModel {
return a;
}, {hit: 0, miss: 0})
}
if(this.hasSave) this.setPendingSaves();
if (this.hasSave) this.setPendingSaves();
}
this.canViewSecret = this.parent.speakerActor?.testUserPermission(game.user, 'OBSERVER');
this.canButtonApply = game.user.isGM;
}
@ -139,11 +138,7 @@ export default class DHActorRoll extends foundry.abstract.TypeDataModel {
setPendingSaves() {
this.pendingSaves = this.targetSelection
? this.targets.filter(
target => target.hit && target.saved.success === null
).length > 0
: this.currentTargets.filter(
target => target.saved.success === null
).length > 0;
? this.targets.filter(target => target.hit && target.saved.success === null).length > 0
: this.currentTargets.filter(target => target.saved.success === null).length > 0;
}
}

20
module/data/fields/action/beastformField.mjs
View file

@ -4,7 +4,25 @@ export default class BeastformField extends fields.SchemaField {
constructor(options = {}, context = {}) {
const beastformFields = {
tierAccess: new fields.SchemaField({
exact: new fields.NumberField({ integer: true, nullable: true, initial: null })
exact: new fields.NumberField({
integer: true,
nullable: true,
initial: null,
choices: () => {
const settingsTiers = game.settings.get(
CONFIG.DH.id,
CONFIG.DH.SETTINGS.gameSettings.LevelTiers
).tiers;
return Object.values(settingsTiers).reduce(
(acc, tier) => {
acc[tier.tier] = game.i18n.localize(tier.name);
return acc;
},
{ 1: game.i18n.localize('DAGGERHEART.GENERAL.Tiers.1') }
);
},
hint: 'DAGGERHEART.ACTIONS.Config.beastform.exactHint'
})
})
};
super(beastformFields, options, context);

3
module/data/fields/action/rangeField.mjs
View file

@ -5,7 +5,8 @@ export default class RangeField extends fields.StringField {
const options = {
choices: CONFIG.DH.GENERAL.range,
required: false,
blank: true
blank: true,
label: "DAGGERHEART.GENERAL.range"
};
super(options, context);
}

2
module/data/fields/action/rollField.mjs
View file

@ -5,7 +5,7 @@ export class DHActionRollData extends foundry.abstract.DataModel {
static defineSchema() {
return {
type: new fields.StringField({ nullable: true, initial: null, choices: CONFIG.DH.GENERAL.rollTypes }),
trait: new fields.StringField({ nullable: true, initial: null, choices: CONFIG.DH.ACTOR.abilities }),
trait: new fields.StringField({ nullable: true, initial: null, choices: CONFIG.DH.ACTOR.abilities, label: "DAGGERHEART.GENERAL.Trait.single" }),
difficulty: new fields.NumberField({ nullable: true, initial: null, integer: true, min: 0 }),
bonus: new fields.NumberField({ nullable: true, initial: null, integer: true }),
advState: new fields.StringField({

6
module/data/fields/action/usesField.mjs
View file

@ -12,7 +12,10 @@ export default class UsesField extends fields.SchemaField {
initial: null,
nullable: true
}),
consumeOnSuccess: new fields.BooleanField({ initial: false, label: "DAGGERHEART.ACTIONS.Settings.consumeOnSuccess.label" })
consumeOnSuccess: new fields.BooleanField({
initial: false,
label: 'DAGGERHEART.ACTIONS.Settings.consumeOnSuccess.label'
})
};
super(usesFields, options, context);
}
@ -30,6 +33,7 @@ export default class UsesField extends fields.SchemaField {
if (!uses) return null;
return {
...uses,
remaining: this.remainingUses,
enabled: uses.hasOwnProperty('enabled') ? uses.enabled : true
};
}

10
module/data/fields/actionField.mjs
View file

@ -1,4 +1,5 @@
import DHActionConfig from '../../applications/sheets-configs/action-config.mjs';
import { itemAbleRollParse } from '../../helpers/utils.mjs';
import MappingField from './mappingField.mjs';
/**
@ -164,6 +165,15 @@ export function ActionMixin(Base) {
return foundry.utils.getProperty(this.parent, this.systemPath) instanceof Collection;
}
get remainingUses() {
if (!this.uses) return null;
return Math.max(
(this.uses.max ? itemAbleRollParse(this.uses.max, this.actor) : 0) - (this.uses.value ?? 0),
0
);
}
static async create(data, operation = {}) {
const { parent, renderSheet } = operation;
let { type } = data;

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

@ -147,4 +147,8 @@ export default class DHArmor extends AttachableItem {
const labels = [`${game.i18n.localize('DAGGERHEART.ITEMS.Armor.baseScore')}: ${this.baseScore}`];
return labels;
}
get itemFeatures() {
return this.armorFeatures;
}
}

4
module/data/item/base.mjs
View file

@ -106,6 +106,10 @@ export default class BaseDataItem extends foundry.abstract.TypeDataModel {
return this.actions;
}
get itemFeatures() {
return [];
}
/**
* Obtain a data object used to evaluate any dice rolls associated with this Item Type
* @param {object} [options] - Options which modify the getRollData method.

20
module/data/item/beastform.mjs
View file

@ -88,6 +88,26 @@ export default class DHBeastform extends BaseDataItem {
/* -------------------------------------------- */
get beastformAttackData() {
const effect = this.parent.effects.find(x => x.type === 'beastform');
if (!effect) return null;
const traitBonus = effect.changes.find(x => x.key === `system.traits.${this.mainTrait}.value`)?.value ?? 0;
const evasionBonus = effect.changes.find(x => x.key === 'system.evasion')?.value ?? 0;
const damageDiceIndex = effect.changes.find(x => x.key === 'system.rules.attack.damage.diceIndex');
const damageDice = damageDiceIndex ? Object.keys(CONFIG.DH.GENERAL.diceTypes)[damageDiceIndex.value] : null;
const damageBonus = effect.changes.find(x => x.key === 'system.rules.attack.damage.bonus')?.value ?? 0;
return {
trait: game.i18n.localize(CONFIG.DH.ACTOR.abilities[this.mainTrait].label),
traitBonus: traitBonus ? Number(traitBonus).signedString() : '',
evasionBonus: evasionBonus ? Number(evasionBonus).signedString() : '',
damageDice: damageDice,
damageBonus: damageBonus ? `${Number(damageBonus).signedString()}` : ''
};
}
async _preCreate() {
if (!this.actor) return;

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

@ -20,7 +20,8 @@ export default class DHSubclass extends BaseDataItem {
choices: CONFIG.DH.ACTOR.abilities,
integer: false,
nullable: true,
initial: null
initial: null,
label: "DAGGERHEART.ITEMS.Subclass.spellcastingTrait"
}),
features: new ItemLinkFields(),
featureState: new fields.NumberField({ required: true, initial: 1, min: 1 }),

10
module/data/item/weapon.mjs
View file

@ -18,12 +18,12 @@ export default class DHWeapon extends AttachableItem {
const fields = foundry.data.fields;
return {
...super.defineSchema(),
tier: new fields.NumberField({ required: true, integer: true, initial: 1, min: 1 }),
tier: new fields.NumberField({ required: true, integer: true, initial: 1, min: 1, label: "DAGGERHEART.GENERAL.Tiers.singular" }),
equipped: new fields.BooleanField({ initial: false }),
//SETTINGS
secondary: new fields.BooleanField({ initial: false }),
burden: new fields.StringField({ required: true, choices: CONFIG.DH.GENERAL.burden, initial: 'oneHanded' }),
secondary: new fields.BooleanField({ initial: false, label: "DAGGERHEART.ITEMS.Weapon.secondaryWeapon" }),
burden: new fields.StringField({ required: true, choices: CONFIG.DH.GENERAL.burden, initial: 'oneHanded', label: "DAGGERHEART.GENERAL.burden" }),
weaponFeatures: new fields.ArrayField(
new fields.SchemaField({
value: new fields.StringField({
@ -234,4 +234,8 @@ export default class DHWeapon extends AttachableItem {
return labels;
}
get itemFeatures() {
return this.weaponFeatures;
}
}

5
module/data/settings/Automation.mjs
View file

@ -45,6 +45,11 @@ export default class DhAutomation extends foundry.abstract.DataModel {
required: true,
initial: true,
label: 'DAGGERHEART.SETTINGS.Automation.FIELDS.resourceScrollTexts.label'
}),
playerCanEditSheet: new fields.BooleanField({
required: true,
initial: false,
label: 'DAGGERHEART.SETTINGS.Automation.FIELDS.playerCanEditSheet.label'
})
};
}

6
module/data/settings/Homebrew.mjs
View file

@ -45,10 +45,10 @@ export default class DhHomebrew extends foundry.abstract.DataModel {
initial: 'Coins',
label: 'DAGGERHEART.SETTINGS.Homebrew.currency.coinName'
}),
handfulls: new fields.StringField({
handfuls: new fields.StringField({
required: true,
initial: 'Handfulls',
label: 'DAGGERHEART.SETTINGS.Homebrew.currency.handfullName'
initial: 'Handfuls',
label: 'DAGGERHEART.SETTINGS.Homebrew.currency.handfulName'
}),
bags: new fields.StringField({
required: true,

25
module/data/settings/RangeMeasurement.mjs
View file

@ -1,25 +0,0 @@
export default class DhRangeMeasurement extends foundry.abstract.DataModel {
static defineSchema() {
const fields = foundry.data.fields;
return {
enabled: new fields.BooleanField({ required: true, initial: true, label: 'DAGGERHEART.GENERAL.enabled' }),
melee: new fields.NumberField({ required: true, initial: 5, label: 'DAGGERHEART.CONFIG.Range.melee.name' }),
veryClose: new fields.NumberField({
required: true,
initial: 15,
label: 'DAGGERHEART.CONFIG.Range.veryClose.name'
}),
close: new fields.NumberField({
required: true,
initial: 30,
label: 'DAGGERHEART.CONFIG.Range.close.name'
}),
far: new fields.NumberField({ required: true, initial: 60, label: 'DAGGERHEART.CONFIG.Range.far.name' }),
veryFar: new fields.NumberField({
required: true,
initial: 120,
label: 'DAGGERHEART.CONFIG.Range.veryFar.name'
})
};
}
}

25
module/data/settings/VariantRules.mjs
View file

@ -17,9 +17,28 @@ export default class DhVariantRules extends foundry.abstract.DataModel {
label: 'DAGGERHEART.SETTINGS.VariantRules.FIELDS.actionTokens.tokens.label'
})
}),
useCoins: new fields.BooleanField({
initial: false,
label: 'DAGGERHEART.SETTINGS.VariantRules.FIELDS.useCoins.label'
rangeMeasurement: new fields.SchemaField({
enabled: new fields.BooleanField({
required: true,
initial: true,
label: 'DAGGERHEART.GENERAL.enabled'
}),
melee: new fields.NumberField({
required: true,
initial: 5,
label: 'DAGGERHEART.CONFIG.Range.melee.name'
}),
veryClose: new fields.NumberField({
required: true,
initial: 15,
label: 'DAGGERHEART.CONFIG.Range.veryClose.name'
}),
close: new fields.NumberField({
required: true,
initial: 30,
label: 'DAGGERHEART.CONFIG.Range.close.name'
}),
far: new fields.NumberField({ required: true, initial: 60, label: 'DAGGERHEART.CONFIG.Range.far.name' })
})
};
}

1
module/data/settings/_module.mjs
View file

@ -1,5 +1,4 @@
export { default as DhAppearance } from './Appearance.mjs';
export { default as DhAutomation } from './Automation.mjs';
export { default as DhHomebrew } from './Homebrew.mjs';
export { default as DhRangeMeasurement } from './RangeMeasurement.mjs';
export { default as DhVariantRules } from './VariantRules.mjs';