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

refactor code for review comments

Browse source
This commit is contained in:
psitacus 2025-07-12 02:33:13 -06:00
parent 001abcadf4
commit 5065a609ac
6 changed files with 128 additions and 438 deletions
Download patch file Download diff file Expand all files Collapse all files

196
module/helpers/attachmentHelper.mjs
View file

@ -1,196 +0,0 @@
/**
* Utility functions for handling item attachments and their effects
*/
/**
* Copy all effects from an attached item to the actor when the parent item is equipped
* @param {Object} options - Configuration options
* @param {Item} options.parentItem - The item (armor/weapon) that the item is being attached to
* @param {Item} options.attachedItem - The item being attached
* @param {string} options.attachedUuid - UUID of the attached item
* @param {string} options.parentType - Type of parent item ("armor" or "weapon")
* @returns {Promise<ActiveEffect[]>} Created effects
*/
export async function copyAttachmentEffectsToActor({ parentItem, attachedItem, attachedUuid, parentType }) {
const actor = parentItem.parent;
if (!actor || !attachedItem.effects.size > 0 || !parentItem.system.equipped) {
return [];
}
const effectsToCreate = [];
for (const effect of attachedItem.effects) {
// Copy ALL effects when item is attached - attachment-only flag only matters for non-attached items
const effectData = effect.toObject();
effectData.origin = `${parentItem.uuid}:${attachedUuid}`;
// Set up attachment source metadata with the appropriate property name
const attachmentSource = {
itemUuid: attachedUuid,
originalEffectId: effect.id
};
attachmentSource[`${parentType}Uuid`] = parentItem.uuid;
effectData.flags = {
...effectData.flags,
[CONFIG.DH.id]: {
...effectData.flags?.[CONFIG.DH.id],
[CONFIG.DH.FLAGS.itemAttachmentSource]: attachmentSource
}
};
effectsToCreate.push(effectData);
}
if (effectsToCreate.length > 0) {
return await actor.createEmbeddedDocuments('ActiveEffect', effectsToCreate);
}
return [];
}
/**
* Remove effects from the actor that came from a specific attached item
* @param {Object} options - Configuration options
* @param {Item} options.parentItem - The item (armor/weapon) that the item was attached to
* @param {string} options.attachedUuid - UUID of the attached item being removed
* @param {string} options.parentType - Type of parent item ("armor" or "weapon")
* @returns {Promise<void>}
*/
export async function removeAttachmentEffectsFromActor({ parentItem, attachedUuid, parentType }) {
const actor = parentItem.parent;
if (!actor) return;
const parentUuidProperty = `${parentType}Uuid`;
const effectsToRemove = actor.effects.filter(effect => {
const attachmentSource = effect.getFlag(CONFIG.DH.id, CONFIG.DH.FLAGS.itemAttachmentSource);
return attachmentSource &&
attachmentSource[parentUuidProperty] === parentItem.uuid &&
attachmentSource.itemUuid === attachedUuid;
});
if (effectsToRemove.length > 0) {
await actor.deleteEmbeddedDocuments('ActiveEffect', effectsToRemove.map(e => e.id));
}
}
/**
* Remove an attachment from an item and clean up its effects
* @param {Object} options - Configuration options
* @param {Item} options.parentItem - The item (armor/weapon) that the item is attached to
* @param {string} options.attachedUuid - UUID of the attached item being removed
* @param {string} options.parentType - Type of parent item ("armor" or "weapon")
* @returns {Promise<void>}
*/
export async function removeAttachmentFromItem({ parentItem, attachedUuid, parentType }) {
const currentAttached = parentItem.system.attached;
// Remove the attachment from the parent item's attached array
await parentItem.update({
'system.attached': currentAttached.filter(uuid => uuid !== attachedUuid)
});
// Remove any effects that came from this attachment
await removeAttachmentEffectsFromActor({
parentItem,
attachedUuid,
parentType
});
}
/**
* Handle adding/removing attachment effects when a parent item is equipped/unequipped
* @param {Object} options - Configuration options
* @param {Item} options.parentItem - The item (armor/weapon) being equipped/unequipped
* @param {boolean} options.newEquippedStatus - The new equipped status
* @param {string} options.parentType - Type of parent item ("armor" or "weapon")
* @returns {Promise<void>}
*/
export async function handleAttachmentEffectsOnEquipChange({ parentItem, newEquippedStatus, parentType }) {
// Try to get the actor - it might be parentItem.parent instead of parentItem.parent.parent
const actor = parentItem.parent?.type === 'character' ? parentItem.parent : parentItem.parent?.parent;
if (!actor || !parentItem.system.attached?.length) {
return;
}
if (newEquippedStatus) {
// Item is being equipped - add attachment effects
for (const attachedUuid of parentItem.system.attached) {
const attachedItem = await fromUuid(attachedUuid);
if (attachedItem && attachedItem.effects.size > 0) {
await copyAttachmentEffectsToActor({
parentItem,
attachedItem,
attachedUuid,
parentType
});
}
}
} else {
// Item is being unequipped - remove attachment effects
const parentUuidProperty = `${parentType}Uuid`;
const effectsToRemove = actor.effects.filter(effect => {
const attachmentSource = effect.getFlag(CONFIG.DH.id, CONFIG.DH.FLAGS.itemAttachmentSource);
return attachmentSource && attachmentSource[parentUuidProperty] === parentItem.uuid;
});
if (effectsToRemove.length > 0) {
await actor.deleteEmbeddedDocuments('ActiveEffect', effectsToRemove.map(e => e.id));
}
}
}
/**
* Prepare attachment context data for rendering
* @param {Item} parentItem - The item (armor/weapon) that has attachments
* @returns {Promise<Object[]>} Array of attachment data objects
*/
export async function prepareAttachmentContext(parentItem) {
const attachedUUIDs = parentItem.system.attached;
return await Promise.all(
attachedUUIDs.map(async uuid => {
const item = await fromUuid(uuid);
return {
uuid: uuid,
name: item?.name || 'Unknown Item',
img: item?.img || 'icons/svg/item-bag.svg'
};
})
);
}
/**
* Add an attachment to an item via drag and drop
* @param {Object} options - Configuration options
* @param {Item} options.parentItem - The item (armor/weapon) that the item is being attached to
* @param {Item} options.droppedItem - The item being attached
* @param {string} options.parentType - Type of parent item ("armor" or "weapon")
* @returns {Promise<void>}
*/
export async function addAttachmentToItem({ parentItem, droppedItem, parentType }) {
const currentAttached = parentItem.system.attached;
const newUUID = droppedItem.uuid;
if (currentAttached.includes(newUUID)) {
ui.notifications.warn(`${droppedItem.name} is already attached to this ${parentType}.`);
return;
}
const updatedAttached = [...currentAttached, newUUID];
await parentItem.update({
'system.attached': updatedAttached
});
// Copy effects from attached item to actor (only if parent item is equipped)
const actor = parentItem.parent;
if (actor && droppedItem.effects.size > 0 && parentItem.system.equipped) {
await copyAttachmentEffectsToActor({
parentItem,
attachedItem: droppedItem,
attachedUuid: newUUID,
parentType
});
}
}