diff --git a/.gitattributes b/.gitattributes
deleted file mode 100644
index 56ce8818..00000000
--- a/.gitattributes
+++ /dev/null
@@ -1,2 +0,0 @@
-* text=auto eol=lf
-*.json text eol=lf
diff --git a/module/data/actor/adversary.mjs b/module/data/actor/adversary.mjs
index d6d0dcdf..d69e17ad 100644
--- a/module/data/actor/adversary.mjs
+++ b/module/data/actor/adversary.mjs
@@ -3,7 +3,8 @@ import { ActionField } from '../fields/actionField.mjs';
import { commonActorRules } from './base.mjs';
import DhCreature from './creature.mjs';
import { bonusField } from '../fields/actorField.mjs';
-import { getTierAdjustedAdversary } from './tierAdjustment.mjs';
+import { calculateExpectedValue, parseTermsFromSimpleFormula } from '../../helpers/utils.mjs';
+import { adversaryExpectedDamage, adversaryScalingData } from '../../config/actorConfig.mjs';
export default class DhpAdversary extends DhCreature {
static LOCALIZATION_PREFIXES = ['DAGGERHEART.ACTORS.Adversary'];
@@ -205,6 +206,205 @@ export default class DhpAdversary extends DhCreature {
/** Returns source data for this actor adjusted to a new tier, which can be used to create a new actor. */
adjustForTier(tier) {
const source = this.parent.toObject(true);
- return getTierAdjustedAdversary(source, tier);
+
+ /** @type {(2 | 3 | 4)[]} */
+ const tiers = new Array(Math.abs(tier - this.tier))
+ .fill(0)
+ .map((_, idx) => idx + Math.min(tier, this.tier) + 1);
+ if (tier < this.tier) tiers.reverse();
+ const typeData = adversaryScalingData[source.system.type] ?? adversaryScalingData[source.system.standard];
+ const tierEntries = tiers.map(t => ({ tier: t, ...typeData[t] }));
+
+ // Apply simple tier changes
+ const scale = tier > this.tier ? 1 : -1;
+ for (const entry of tierEntries) {
+ source.system.difficulty += scale * entry.difficulty;
+ source.system.damageThresholds.major += scale * entry.majorThreshold;
+ source.system.damageThresholds.severe += scale * entry.severeThreshold;
+ source.system.resources.hitPoints.max += scale * entry.hp;
+ source.system.resources.stress.max += scale * entry.stress;
+ source.system.attack.roll.bonus += scale * entry.attack;
+ }
+
+ // Get the mean and standard deviation of expected damage in the previous and new tier
+ // The data we have is for attack scaling, but we reuse this for action scaling later
+ const expectedDamageData = adversaryExpectedDamage[source.system.type] ?? adversaryExpectedDamage.basic;
+ const damageMeta = {
+ currentDamageRange: { tier: source.system.tier, ...expectedDamageData[source.system.tier] },
+ newDamageRange: { tier, ...expectedDamageData[tier] },
+ type: 'attack'
+ };
+
+ // Update damage of base attack
+ try {
+ this.#adjustActionDamage(source.system.attack, damageMeta);
+ } catch (err) {
+ ui.notifications.warn('Failed to convert attack damage of adversary');
+ console.error(err);
+ }
+
+ // Update damage of each item action, making sure to also update the description if possible
+ const damageRegex = /@Damage\[([^\[\]]*)\]({[^}]*})?/g;
+ for (const item of source.items) {
+ // Replace damage inlines with new formulas
+ for (const withDescription of [item.system, ...Object.values(item.system.actions)]) {
+ withDescription.description = withDescription.description.replace(damageRegex, (match, inner) => {
+ const { value: formula } = parseInlineParams(inner);
+ if (!formula || !type) return match;
+
+ try {
+ const adjusted = this.#calculateAdjustedDamage(formula, { ...damageMeta, type: 'action' });
+ const newFormula = [
+ adjusted.diceQuantity ? `${adjusted.diceQuantity}d${adjusted.faces}` : null,
+ adjusted.bonus
+ ]
+ .filter(p => !!p)
+ .join('+');
+ return match.replace(formula, newFormula);
+ } catch {
+ return match;
+ }
+ });
+ }
+
+ // Update damage in item actions
+ // Parse damage, and convert all formula matches in the descriptions to the new damage
+ for (const action of Object.values(item.system.actions)) {
+ try {
+ const result = this.#adjustActionDamage(action, { ...damageMeta, type: 'action' });
+ if (!result) continue;
+
+ for (const { previousFormula, formula } of Object.values(result)) {
+ const oldFormulaRegexp = new RegExp(
+ previousFormula.replace(' ', '').replace('+', '(?:\\s)?\\+(?:\\s)?')
+ );
+ item.system.description = item.system.description.replace(oldFormulaRegexp, formula);
+ action.description = action.description.replace(oldFormulaRegexp, formula);
+ }
+ } catch (err) {
+ ui.notifications.warn(`Failed to convert action damage for item ${item.name}`);
+ console.error(err);
+ }
+ }
+ }
+
+ // Finally set the tier of the source data, now that everything is complete
+ source.system.tier = tier;
+ return source;
+ }
+
+ /**
+ * Converts a damage object to a new damage range
+ * @returns {{ diceQuantity: number; faces: number; bonus: number }} the adjusted result as a combined term
+ * @throws error if the formula is the wrong type
+ */
+ #calculateAdjustedDamage(formula, { currentDamageRange, newDamageRange, type }) {
+ const terms = parseTermsFromSimpleFormula(formula);
+ const flatTerms = terms.filter(t => t.diceQuantity === 0);
+ const diceTerms = terms.filter(t => t.diceQuantity > 0);
+ if (flatTerms.length > 1 || diceTerms.length > 1) {
+ throw new Error('invalid formula for conversion');
+ }
+ const value = {
+ ...(diceTerms[0] ?? { diceQuantity: 0, faces: 1 }),
+ bonus: flatTerms[0]?.bonus ?? 0
+ };
+ const previousExpected = calculateExpectedValue(value);
+ if (previousExpected === 0) return value; // nothing to do
+
+ const dieSizes = [4, 6, 8, 10, 12, 20];
+ const steps = newDamageRange.tier - currentDamageRange.tier;
+ const increasing = steps > 0;
+ const deviation = (previousExpected - currentDamageRange.mean) / currentDamageRange.deviation;
+ const expected = Math.max(1, newDamageRange.mean + newDamageRange.deviation * deviation);
+
+ // If this was just a flat number, convert to the expected damage and exit
+ if (value.diceQuantity === 0) {
+ value.bonus = Math.round(expected);
+ return value;
+ }
+
+ const getExpectedDie = () => calculateExpectedValue({ diceQuantity: 1, faces: value.faces }) || 1;
+ const getBaseAverage = () => calculateExpectedValue({ ...value, bonus: 0 });
+
+ // Check the number of base overages over the expected die. In the end, if the bonus inflates too much, we add a die
+ const baseOverages = Math.floor(value.bonus / getExpectedDie());
+
+ // Prestep. Change number of dice for attacks, bump up/down for actions
+ // We never bump up to d20, though we might bump down from it
+ if (type === 'attack') {
+ const minimum = increasing ? value.diceQuantity : 0;
+ value.diceQuantity = Math.max(minimum, newDamageRange.tier);
+ } else {
+ const currentIdx = dieSizes.indexOf(value.faces);
+ value.faces = dieSizes[Math.clamp(currentIdx + steps, 0, 4)];
+ }
+
+ value.bonus = Math.round(expected - getBaseAverage());
+
+ // Attempt to handle negative values.
+ // If we can do it with only step downs, do so. Otherwise remove tier dice, and try again
+ if (value.bonus < 0) {
+ let stepsRequired = Math.ceil(Math.abs(value.bonus) / value.diceQuantity);
+ const currentIdx = dieSizes.indexOf(value.faces);
+
+ // If step downs alone don't suffice, change the flat modifier, then calculate steps required again
+ // If this isn't sufficient, the result will be slightly off. This is unlikely to happen
+ if (type !== 'attack' && stepsRequired > currentIdx && value.diceQuantity > 0) {
+ value.diceQuantity -= increasing ? 1 : Math.abs(steps);
+ value.bonus = Math.round(expected - getBaseAverage());
+ if (value.bonus >= 0) return value; // complete
+ }
+
+ stepsRequired = Math.ceil(Math.abs(value.bonus) / value.diceQuantity);
+ value.faces = dieSizes[Math.max(0, currentIdx - stepsRequired)];
+ value.bonus = Math.max(0, Math.round(expected - getBaseAverage()));
+ }
+
+ // If value is really high, we add a number of dice based on the number of overages
+ // This attempts to preserve a similar amount of variance when increasing an action
+ const overagesToRemove = Math.floor(value.bonus / getExpectedDie()) - baseOverages;
+ if (type !== 'attack' && increasing && overagesToRemove > 0) {
+ value.diceQuantity += overagesToRemove;
+ value.bonus = Math.round(expected - getBaseAverage());
+ }
+
+ return value;
+ }
+
+ /**
+ * Updates damage to reflect a specific value.
+ * @throws if damage structure is invalid for conversion
+ * @returns the converted formula and value as a simplified term, or null if it doesn't deal HP damage
+ */
+ #adjustActionDamage(action, damageMeta) {
+ if (!action.damage?.parts.hitPoints) return null;
+
+ const result = {};
+ for (const property of ['value', 'valueAlt']) {
+ const data = action.damage.parts.hitPoints[property];
+ const previousFormula = data.custom.enabled
+ ? data.custom.formula
+ : [data.flatMultiplier ? `${data.flatMultiplier}${data.dice}` : 0, data.bonus ?? 0]
+ .filter(p => !!p)
+ .join('+');
+ const value = this.#calculateAdjustedDamage(previousFormula, damageMeta);
+ const formula = [value.diceQuantity ? `${value.diceQuantity}d${value.faces}` : null, value.bonus]
+ .filter(p => !!p)
+ .join('+');
+ if (value.diceQuantity) {
+ data.custom.enabled = false;
+ data.bonus = value.bonus;
+ data.dice = `d${value.faces}`;
+ data.flatMultiplier = value.diceQuantity;
+ } else if (!value.diceQuantity) {
+ data.custom.enabled = true;
+ data.custom.formula = formula;
+ }
+
+ result[property] = { previousFormula, formula, value };
+ }
+
+ return result;
}
}
diff --git a/module/data/actor/tierAdjustment.mjs b/module/data/actor/tierAdjustment.mjs
deleted file mode 100644
index 785eec2b..00000000
--- a/module/data/actor/tierAdjustment.mjs
+++ /dev/null
@@ -1,218 +0,0 @@
-import { calculateExpectedValue, parseTermsFromSimpleFormula } from '../../helpers/utils.mjs';
-import { adversaryExpectedDamage, adversaryScalingData } from '../../config/actorConfig.mjs';
-
-export function getTierAdjustedAdversary(source, tier) {
- const currentTier = source.tier ?? 1;
-
- /** @type {(2 | 3 | 4)[]} */
- const tiers = new Array(Math.abs(tier - currentTier))
- .fill(0)
- .map((_, idx) => idx + Math.min(tier, currentTier) + 1);
- if (tier < currentTier) tiers.reverse();
- const typeData = adversaryScalingData[source.system.type] ?? adversaryScalingData[source.system.standard];
- const tierEntries = tiers.map(t => ({ tier: t, ...typeData[t] }));
-
- // Apply simple tier changes
- const scale = tier > currentTier ? 1 : -1;
- for (const entry of tierEntries) {
- source.system.difficulty += scale * entry.difficulty;
- source.system.damageThresholds.major += scale * entry.majorThreshold;
- source.system.damageThresholds.severe += scale * entry.severeThreshold;
- source.system.resources.hitPoints.max += scale * entry.hp;
- source.system.resources.stress.max += scale * entry.stress;
- source.system.attack.roll.bonus += scale * entry.attack;
- }
-
- // Get the mean and standard deviation of expected damage in the previous and new tier
- // The data we have is for attack scaling, but we reuse this for action scaling later
- const expectedDamageData = adversaryExpectedDamage[source.system.type] ?? adversaryExpectedDamage.basic;
- const damageMeta = {
- currentDamageRange: { tier: source.system.tier, ...expectedDamageData[source.system.tier] },
- newDamageRange: { tier, ...expectedDamageData[tier] }
- };
-
- // Store initial attack damage for abilities that have you deal a "standard attack"
- const initialAttack = {
- type: source.system.attack.damage?.parts.hitPoints?.type?.toSorted(),
- value: getDamagePartsFormula(source.system.attack.damage?.parts.hitPoints?.value)
- };
-
- // Update damage of base attack.
- try {
- const damage = source.system.attack.damage;
- if (!damage?.parts.hitPoints) throw new Error('Unexpected missing attack in adversary');
-
- for (const property of ['value', 'valueAlt']) {
- const data = damage.parts.hitPoints[property];
- const previousFormula = getDamagePartsFormula(data);
- const { value, formula } = calculateAdjustedDamage(previousFormula, 'attack', damageMeta);
- applyAdjustedDamage(data, value, formula);
- }
- } catch (err) {
- ui.notifications.warn('Failed to convert attack damage of adversary');
- console.error(err);
- }
-
- // Update damage of each item action, making sure to also update the description if possible
- const damageRegex = /@Damage\[([^\[\]]*)\]({[^}]*})?/g;
- for (const item of source.items) {
- // Replace damage inlines with new formulas. Keep a record for a specific check later
- const descriptionFormulas = [];
- for (const withDescription of [item.system, ...Object.values(item.system.actions)]) {
- withDescription.description = withDescription.description.replace(damageRegex, (match, inner) => {
- const { value: formula } = parseInlineParams(inner);
- if (!formula || !type) return match;
-
- try {
- const newFormula = calculateAdjustedDamage(formula, 'action', damageMeta)?.formula;
- descriptionFormulas.push(formula);
- return match.replace(formula, newFormula);
- } catch {
- return match;
- }
- });
- }
-
- // Update damage in item actions and convert all formula matches in the descriptions to the new damage
- for (const action of Object.values(item.system.actions)) {
- if (!action.damage?.parts.hitPoints) continue;
- try {
- // Apply conversions and save a record. If it matches attack damage *and* Its not in the description, use attack conversion instead
- const result = [];
- for (const property of ['value', 'valueAlt']) {
- const { [property]: data, type: damageType } = action.damage.parts.hitPoints;
- const previousFormula = getDamagePartsFormula(data);
- const isActuallyAttack =
- previousFormula === initialAttack.value &&
- foundry.utils.equals(damageType.toSorted(), initialAttack.type) &&
- !descriptionFormulas.includes(previousFormula);
- const type = isActuallyAttack ? 'attack' : 'action';
- const { value, formula } = calculateAdjustedDamage(previousFormula, type, damageMeta);
- applyAdjustedDamage(data, value, formula);
- result.push({ previousFormula, formula });
- }
-
- // Override text in the description with those values
- for (const { previousFormula, formula } of Object.values(result)) {
- const oldFormulaRegexp = new RegExp(
- previousFormula.replace(' ', '').replace('+', '(?:\\s)?\\+(?:\\s)?')
- );
- item.system.description = item.system.description.replace(oldFormulaRegexp, formula);
- action.description = action.description.replace(oldFormulaRegexp, formula);
- }
- } catch (err) {
- ui.notifications.warn(`Failed to convert action damage for item ${item.name}`);
- console.error(err);
- }
- }
- }
-
- // Finally set the tier of the source data, now that everything is complete
- source.system.tier = tier;
- return source;
-}
-
-/**
- * Converts a damage object to a new damage range
- * @returns {{ diceQuantity: number; faces: number; bonus: number }} the adjusted result as a combined term
- * @throws error if the formula is the wrong type
- */
-function calculateAdjustedDamage(formula, type, { currentDamageRange, newDamageRange }) {
- const terms = parseTermsFromSimpleFormula(formula);
- const flatTerms = terms.filter(t => t.diceQuantity === 0);
- const diceTerms = terms.filter(t => t.diceQuantity > 0);
- if (flatTerms.length > 1 || diceTerms.length > 1) {
- throw new Error('invalid formula for conversion');
- }
- const value = {
- ...(diceTerms[0] ?? { diceQuantity: 0, faces: 1 }),
- bonus: flatTerms[0]?.bonus ?? 0
- };
- const previousExpected = calculateExpectedValue(value);
- if (previousExpected === 0) return value; // nothing to do
-
- const dieSizes = [4, 6, 8, 10, 12, 20];
- const steps = newDamageRange.tier - currentDamageRange.tier;
- const increasing = steps > 0;
- const deviation = (previousExpected - currentDamageRange.mean) / currentDamageRange.deviation;
- const expected = Math.max(1, newDamageRange.mean + newDamageRange.deviation * deviation);
-
- // If this was just a flat number, convert to the expected damage and exit
- if (value.diceQuantity === 0) {
- value.bonus = Math.round(expected);
- return value;
- }
-
- const getExpectedDie = () => calculateExpectedValue({ diceQuantity: 1, faces: value.faces }) || 1;
- const getBaseAverage = () => calculateExpectedValue({ ...value, bonus: 0 });
-
- // Check the number of base overages over the expected die. In the end, if the bonus inflates too much, we add a die
- const baseOverages = Math.floor(value.bonus / getExpectedDie());
-
- // Prestep. Change number of dice for attacks, bump up/down for actions
- // We never bump up to d20, though we might bump down from it
- if (type === 'attack') {
- const minimum = increasing ? value.diceQuantity : 0;
- value.diceQuantity = Math.max(minimum, newDamageRange.tier);
- } else {
- const currentIdx = dieSizes.indexOf(value.faces);
- value.faces = dieSizes[Math.clamp(currentIdx + steps, 0, 4)];
- }
-
- value.bonus = Math.round(expected - getBaseAverage());
-
- // Attempt to handle negative values.
- // If we can do it with only step downs, do so. Otherwise remove tier dice, and try again
- if (value.bonus < 0) {
- let stepsRequired = Math.ceil(Math.abs(value.bonus) / value.diceQuantity);
- const currentIdx = dieSizes.indexOf(value.faces);
-
- // If step downs alone don't suffice, change the flat modifier, then calculate steps required again
- // If this isn't sufficient, the result will be slightly off. This is unlikely to happen
- if (type !== 'attack' && stepsRequired > currentIdx && value.diceQuantity > 0) {
- value.diceQuantity -= increasing ? 1 : Math.abs(steps);
- value.bonus = Math.round(expected - getBaseAverage());
- if (value.bonus >= 0) return value; // complete
- }
-
- stepsRequired = Math.ceil(Math.abs(value.bonus) / value.diceQuantity);
- value.faces = dieSizes[Math.max(0, currentIdx - stepsRequired)];
- value.bonus = Math.max(0, Math.round(expected - getBaseAverage()));
- }
-
- // If value is really high, we add a number of dice based on the number of overages
- // This attempts to preserve a similar amount of variance when increasing an action
- const overagesToRemove = Math.floor(value.bonus / getExpectedDie()) - baseOverages;
- if (type !== 'attack' && increasing && overagesToRemove > 0) {
- value.diceQuantity += overagesToRemove;
- value.bonus = Math.round(expected - getBaseAverage());
- }
-
- const newFormula = [value.diceQuantity ? `${value.diceQuantity}d${value.faces}` : null, value.bonus]
- .filter(p => !!p)
- .join('+');
- return { value, formula: newFormula };
-}
-
-function getDamagePartsFormula(data) {
- return data.custom.enabled
- ? data.custom.formula
- : [data.flatMultiplier ? `${data.flatMultiplier}${data.dice}` : 0, data.bonus ?? 0].filter(p => !!p).join('+');
-}
-
-/**
- * Updates damage to reflect a specific value.
- * @throws if damage structure is invalid for conversion
- * @returns the converted formula and value as a simplified term, or null if it doesn't deal HP damage
- */
-function applyAdjustedDamage(diceData, value, formula) {
- if (value.diceQuantity) {
- diceData.custom.enabled = false;
- diceData.bonus = value.bonus;
- diceData.dice = `d${value.faces}`;
- diceData.flatMultiplier = value.diceQuantity;
- } else if (!value.diceQuantity) {
- diceData.custom.enabled = true;
- diceData.custom.formula = formula;
- }
-}
diff --git a/module/data/item/class.mjs b/module/data/item/class.mjs
index 470a1e3c..7014e011 100644
--- a/module/data/item/class.mjs
+++ b/module/data/item/class.mjs
@@ -2,7 +2,7 @@ import BaseDataItem from './base.mjs';
import ForeignDocumentUUIDField from '../fields/foreignDocumentUUIDField.mjs';
import ForeignDocumentUUIDArrayField from '../fields/foreignDocumentUUIDArrayField.mjs';
import ItemLinkFields from '../fields/itemLinkFields.mjs';
-import { addLinkedItemsDiff, fromUuids, getFeaturesHTMLData, updateLinkedItemApps } from '../../helpers/utils.mjs';
+import { addLinkedItemsDiff, getFeaturesHTMLData, updateLinkedItemApps } from '../../helpers/utils.mjs';
export default class DHClass extends BaseDataItem {
/** @inheritDoc */
@@ -73,16 +73,15 @@ export default class DHClass extends BaseDataItem {
const uuids = [this.parent.uuid, this.parent._stats?.compendiumSource].filter(u => !!u);
const subclasses = game.items.filter(x => x.type === 'subclass' && uuids.includes(x.system.linkedClass));
for (const pack of game.packs) {
- const packIds = [];
const indexes = await pack.getIndex({ fields: ['system.linkedClass'] });
for (const index of indexes) {
if (index.type !== 'subclass') continue;
if (!uuids.includes(index.system?.linkedClass)) continue;
if (subclasses.find(x => x.uuid === index.uuid)) continue;
- packIds.push(index._id);
- }
- if (packIds.length > 0) subclasses.push(...(await pack.getDocuments({ _id__in: packIds })));
+ const subclass = await foundry.utils.fromUuid(index.uuid);
+ subclasses.push(subclass);
+ }
}
return subclasses;
@@ -217,10 +216,6 @@ export default class DHClass extends BaseDataItem {
classItems.push(contentLink.outerHTML);
}
- // Preload all class features for acquisition from the cache
- // todo: make feature acquisition async and replace feature helpers for methods
- await fromUuids(this._source.features.map(f => f.item));
-
const hopeFeatures = await getFeaturesHTMLData(this.hopeFeatures);
const classFeatures = await getFeaturesHTMLData(this.classFeatures);
diff --git a/module/data/item/subclass.mjs b/module/data/item/subclass.mjs
index 55b078c2..ecf72de3 100644
--- a/module/data/item/subclass.mjs
+++ b/module/data/item/subclass.mjs
@@ -1,4 +1,5 @@
-import { fromUuids, getFeaturesHTMLData } from '../../helpers/utils.mjs';
+import { getFeaturesHTMLData } from '../../helpers/utils.mjs';
+import ForeignDocumentUUIDField from '../fields/foreignDocumentUUIDField.mjs';
import ItemLinkFields from '../fields/itemLinkFields.mjs';
import BaseDataItem from './base.mjs';
@@ -90,11 +91,6 @@ export default class DHSubclass extends BaseDataItem {
const spellcastTrait = this.spellcastingTrait
? game.i18n.localize(CONFIG.DH.ACTOR.abilities[this.spellcastingTrait].label)
: null;
-
- // Preload all class features for acquisition from the cache
- // todo: make feature acquisition async and replace feature helpers for methods
- await fromUuids(this._source.features.map(f => f.item));
-
const foundationFeatures = await getFeaturesHTMLData(this.foundationFeatures);
const specializationFeatures = await getFeaturesHTMLData(this.specializationFeatures);
const masteryFeatures = await getFeaturesHTMLData(this.masteryFeatures);
diff --git a/module/dice/dualityRoll.mjs b/module/dice/dualityRoll.mjs
index 1d2d556a..f40e9781 100644
--- a/module/dice/dualityRoll.mjs
+++ b/module/dice/dualityRoll.mjs
@@ -135,11 +135,11 @@ export default class DualityRoll extends D20Roll {
this.terms = [this.terms[0], this.terms[1], this.terms[2]];
this.terms[0] = new game.system.api.dice.diceTypes.HopeDie({
- faces: this.terms[0]?.faces ?? this.data.rules.dualityRoll?.defaultHopeDice ?? 12
+ faces: this.data.rules.dualityRoll?.defaultHopeDice ?? 12
});
this.terms[1] = new foundry.dice.terms.OperatorTerm({ operator: '+' });
this.terms[2] = new game.system.api.dice.diceTypes.FearDie({
- faces: this.terms[2]?.faces ?? this.data.rules.dualityRoll?.defaultFearDice ?? 12
+ faces: this.data.rules.dualityRoll?.defaultFearDice ?? 12
});
}
diff --git a/module/helpers/utils.mjs b/module/helpers/utils.mjs
index 2f20175b..8bc95aa0 100644
--- a/module/helpers/utils.mjs
+++ b/module/helpers/utils.mjs
@@ -865,45 +865,6 @@ export function camelize(str) {
.replace(/\s+/g, '');
}
-/** Bulk load a list of documents using uuids. Returns the documents in the same order */
-export async function fromUuids(uuids) {
- // Set up base entries. Each step works on a sublist of these objects
- const entries = uuids.map(uuid => ({
- uuid,
- parsed: foundry.utils.parseUuid(uuid),
- value: foundry.utils.fromUuidSync(uuid)
- }));
-
- // Handle missing uuids for embedded documents first
- // A value may be index data, so we check if its a document
- const packEmbeddedEntries = entries.filter(
- e =>
- !(e.value instanceof Document) &&
- e.parsed.collection instanceof foundry.documents.collections.CompendiumCollection &&
- e.parsed.embedded.length > 0
- );
- await Promise.all(
- packEmbeddedEntries.map(async e => {
- e.value = await fromUuid(e.uuid);
- return true;
- })
- );
-
- // Handle missing top level pack stuff, by batching per pack
- const missingTopLevel = entries.filter(e => !(e.value instanceof Document) && e.value?.pack);
- for (const packGroup of Object.values(Object.groupBy(missingTopLevel, e => e.value.pack))) {
- const pack = game.packs.get(packGroup[0].value.pack);
- if (!pack) continue;
-
- const ids = packGroup.map(p => p.parsed.id);
- const documents = await pack.getDocuments({ _id__in: ids });
- for (const p of packGroup) {
- p.value = documents.find(d => d.id === p.parsed.id) ?? p.value;
- }
- }
-
- return entries.map(e => e.value);
-}
/**
* Triggers DiceSoNice rolls or dice roll audio for rolls. Not used for duality rolls.
* @param { Roll[] } rolls
diff --git a/styles/less/global/prose-mirror.less b/styles/less/global/prose-mirror.less
index e4b1249f..8412235d 100644
--- a/styles/less/global/prose-mirror.less
+++ b/styles/less/global/prose-mirror.less
@@ -40,11 +40,6 @@
ul {
list-style: disc;
}
- }
- // Fixes centering and makes it not render over scrollbar
- &:hover button.toggle:enabled {
- display: flex;
- right: 12px;
}
}
}
diff --git a/styles/less/sheets-settings/adversary-settings/sheet.less b/styles/less/sheets-settings/adversary-settings/sheet.less
index e6eb8d0b..b4b0683b 100644
--- a/styles/less/sheets-settings/adversary-settings/sheet.less
+++ b/styles/less/sheets-settings/adversary-settings/sheet.less
@@ -7,7 +7,7 @@
&.attack.active {
display: flex;
flex-direction: column;
- gap: 12px;
+ gap: 16px;
}
.fieldsets-section {
diff --git a/templates/sheets-settings/adversary-settings/details.hbs b/templates/sheets-settings/adversary-settings/details.hbs
index 3160fbb9..dc2fd386 100644
--- a/templates/sheets-settings/adversary-settings/details.hbs
+++ b/templates/sheets-settings/adversary-settings/details.hbs
@@ -18,12 +18,6 @@
{{formField systemFields.motivesAndTactics value=document._source.system.motivesAndTactics label=(localize "DAGGERHEART.ACTORS.Adversary.FIELDS.motivesAndTactics.label")}}
-
-
+
+