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

Creating a new method to update range dependent effects that uses the players targets

Browse source
This commit is contained in:
nsalyzyn 2025-12-17 11:31:15 -07:00
parent e11b9bbeaa
commit d86c7b96ce
1 changed files with 50 additions and 34 deletions
Download patch file Download diff file Expand all files Collapse all files

84
daggerheart.mjs
View file

@ -248,54 +248,70 @@ Hooks.on('chatMessage', (_, message) => {
} }
}); });
Hooks.on('moveToken', async (movedToken, data) => { const updateActorsRangeDependentEffects = async (token) => {
const effectsAutomation = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation).effects; const rangeMeasurement = game.settings.get(
if (!effectsAutomation.rangeDependent) return; CONFIG.DH.id,
CONFIG.DH.SETTINGS.gameSettings.variantRules
).rangeMeasurement;
const allEffects = [...movedToken.actor.allApplicableEffects()]; for (let effect of token.actor.allApplicableEffects()) {
const rangeDependantEffects = allEffects.filter(effect => effect.system.rangeDependence?.enabled); if (!effect.system.rangeDependence?.enabled) continue;
const { target, range, type } = effect.system.rangeDependence;
const updateEffects = async (disposition, token, effects, effectUpdates) => { // If there are no targets, assume false. Otherwise, start with the effect enabled.
const rangeMeasurement = game.settings.get( let enabledEffect = game.user.targets.size !== 0;
CONFIG.DH.id, // Expect all targets to meet the rangeDependence requirements
CONFIG.DH.SETTINGS.gameSettings.variantRules for (let userTarget of game.user.targets) {
).rangeMeasurement; const disposition = userTarget.document.disposition;
if ((target === 'friendly' && disposition !== 1) || (target === 'hostile' && disposition !== -1)) {
for (let effect of effects.filter(x => x.system.rangeDependence?.enabled)) { enabledEffect = false;
const { target, range, type } = effect.system.rangeDependence; break;
if ((target === 'friendly' && disposition !== 1) || (target === 'hostile' && disposition !== -1)) }
return false;
const distanceBetween = canvas.grid.measurePath([ const distanceBetween = canvas.grid.measurePath([
{ ...movedToken.toObject(), x: data.destination.x, y: data.destination.y }, // TODO: missing { ...movedToken.toObject(), x: data.destination.x, y: data.destination.y }
userTarget.document,
token token
]).distance; ]).distance;
const distance = rangeMeasurement[range]; const distance = rangeMeasurement[range];
const reverse = type === CONFIG.DH.GENERAL.rangeInclusion.outsideRange.id; const reverse = type === CONFIG.DH.GENERAL.rangeInclusion.outsideRange.id;
const newDisabled = reverse ? distanceBetween <= distance : distanceBetween > distance; if (reverse ? distanceBetween <= distance : distanceBetween > distance) {
const oldDisabled = effectUpdates[effect.uuid] ? effectUpdates[effect.uuid].disabled : newDisabled; enabledEffect = false;
effectUpdates[effect.uuid] = { break;
disabled: oldDisabled || newDisabled, }
value: effect
};
}
};
const effectUpdates = {};
for (let token of game.scenes.find(x => x.active).tokens) {
if (token.id !== movedToken.id) {
await updateEffects(token.disposition, token, rangeDependantEffects, effectUpdates);
} }
if (token.actor) await effect.update({ disabled: !enabledEffect });
await updateEffects(movedToken.disposition, token, [...token.actor.allApplicableEffects()], effectUpdates);
} }
}
for (let key in effectUpdates) { const updateAllRangeDependentEffects = async () => {
const effect = effectUpdates[key]; const effectsAutomation = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation).effects;
await effect.value.update({ disabled: effect.disabled }); if (!effectsAutomation.rangeDependent) return;
// Only consider tokens on the active scene
const tokens = game.scenes.find(x => x.active).tokens;
if (game.user.character) {
// The character updates their character's token. There can be only one token.
const characterToken = tokens.find(x => x.actor === game.user.character);
updateActorsRangeDependentEffects(characterToken);
} else if (game.user.isGM) {
// The GM is responsible for all other tokens.
const playerCharacters = game.users.players.filter(x => x.active).map(x => x.character);
for (let token of tokens.filter(x => !playerCharacters.includes(x.actor))) {
updateActorsRangeDependentEffects(token);
}
} }
};
Hooks.on('targetToken', async (user, token, targeted) => {
// TODO: There is a bug when you untarget one token and retarget a new one
await updateAllRangeDependentEffects();
});
Hooks.on('moveToken', async (movedToken, data) => {
await updateAllRangeDependentEffects();
}); });
Hooks.on('renderCompendiumDirectory', (app, html) => applications.ui.ItemBrowser.injectSidebarButton(html)); Hooks.on('renderCompendiumDirectory', (app, html) => applications.ui.ItemBrowser.injectSidebarButton(html));