Added item containers.

Author: SobranDM

CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## New in 1.5.0-beta4
+
+- Further sorted Assets compendium into required rating folders.
+- Fixed up the chat display of initiative rolls for both individual and group initiative.
+- Fixed issue where combat would hang if multiple combatants were deleted from the canvas mid-combat, if initiative type was set to group.
+- Added container items.
+  - If a container is equipped or stowed, all items inside are considered stowed.
+  - If a container is neither equipped or stowed, all items inside are neither equipped nor stowed.
+  - This should easily allow for things like dropping backpacks to move more quickly, track things stowed at a home base, and so on.
+  - Only ordinary items may be containers, but they may be of treasure or personal type if desired.
+    - There is no logic checking to see if a treasure bag contains only treasure items, so if you throw an item in a treasure bag and your treasure value doesn't go up... that's probably why.
+  - Ordinary items, weapons, and armor may all be placed in bags. Things like foci and spells shouldn't allow that, though I'm not sure how you would even make that happen.
+  - Drag an item to somewhere else on the sheet (even another non-bag item) to remove it from the container.
+
 ## New in 1.5.0-beta3
 
 - Fixed some more compendium errors.

module/actor/actor-sheet.js

@@ -41,7 +41,7 @@ export class WwnActorSheet extends ActorSheet {
       let div = $(
         `<div class="item-summary"><ol class="tag-list">${item.getTags()}</ol><div>${description}</div></div>`
       );
-      li.parents(".item-entry").append(div.hide());
+      li.parent(".item-entry").append(div.hide());
       div.slideDown(200);
     }
     li.toggleClass("expanded");

module/actor/character-sheet.js

@@ -57,6 +57,26 @@ export class WwnActorSheetCharacter extends WwnActorSheet {
         [[], [], [], [], [], [], [], []]
       );
 
+    // Validate and clean up container relationships
+    const containers = items.filter(item => item.system.container.isContainer);
+    const containerIds = new Set(containers.map(item => item.id));
+
+    // Check all items for invalid containerIds
+    const itemsToUpdate = [];
+    for (const item of this.actor.items) {
+      if (item.system.containerId && !containerIds.has(item.system.containerId)) {
+        itemsToUpdate.push({
+          _id: item.id,
+          "system.containerId": ""
+        });
+      }
+    }
+
+    // Update items with invalid containerIds
+    if (itemsToUpdate.length > 0) {
+      this.actor.updateEmbeddedDocuments("Item", itemsToUpdate);
+    }
+
     // Sort spells by level
     var sortedSpells = {};
     var slots = {};
@@ -216,6 +236,95 @@ export class WwnActorSheetCharacter extends WwnActorSheet {
     });
   }
 
+  _onDropItem(event, dragData) {
+
+    // If the drag originated from outside our sheet, let Foundry handle it
+    if (!event.target.closest('.wwn.sheet.actor')) {
+      super._onDropItem(event, dragData);
+      return;
+    }
+
+    // Get the dragged item from the UUID
+    const draggedItem = fromUuidSync(dragData.uuid);
+    if (!draggedItem) return;
+
+    // Find the target item under the drop point
+    const targetElement = event.target.closest('.item');
+    if (!targetElement) {
+      // If dropped on empty space, remove from container if it was in one
+      if (draggedItem.system?.containerId) {
+        draggedItem.update({
+          "system.containerId": "",
+          "system.equipped": false,
+          "system.stowed": true,
+        });
+      }
+      super._onDropItem(event, dragData);
+      return;
+    }
+
+    const targetItemId = targetElement.dataset.itemId;
+    if (!targetItemId) {
+      // If dropped on something that isn't an item, remove from container if it was in one
+      if (draggedItem.system?.containerId) {
+        draggedItem.update({
+          "system.containerId": "",
+          "system.equipped": false,
+          "system.stowed": true,
+        });
+      }
+      super._onDropItem(event, dragData);
+      return;
+    }
+
+    // Get the target item
+    const targetItem = this.actor.items.get(targetItemId);
+    if (!targetItem || !targetItem.system.container.isContainer) {
+      // If dropped on a non-container item, remove from container if it was in one
+      if (draggedItem.system?.containerId) {
+        draggedItem.update({
+          "system.containerId": "",
+          "system.equipped": false,
+          "system.stowed": true
+        });
+      }
+      super._onDropItem(event, dragData);
+      return;
+    }
+
+    // Only allow certain item types to be added to containers
+    const allowedTypes = ['item', 'weapon', 'armor'];
+    if (!allowedTypes.includes(draggedItem.type)) {
+      super._onDropItem(event, dragData);
+      return;
+    }
+
+    // Update the dragged item's containerId
+    draggedItem.system && draggedItem.update({
+      "system.containerId": targetItemId,
+      "system.equipped": false,
+      "system.stowed": targetItem.system.equipped || targetItem.system.stowed,
+    });
+
+    super._onDropItem(event, dragData);
+  }
+
+  async _onContainerItemAdd(item, target) {
+    const alreadyExistsInActor = target.parent.items.find((i) => i.id === item.id);
+    let latestItem = item;
+    if (!alreadyExistsInActor) {
+      const newItem = await this._onDropItemCreate([item.toObject()]);
+      latestItem = newItem.pop();
+    }
+
+    const alreadyExistsInContainer = target.system.itemIds.find((i) => i.id === latestItem.id);
+    if (!alreadyExistsInContainer) {
+      const newList = [...target.system.itemIds, latestItem.id];
+      await target.update({ system: { itemIds: newList } });
+      await latestItem.update({ system: { containerId: target.id } });
+    }
+  }
+
   _pushLang(table) {
     const data = this.actor.system;
     let update = duplicate(data[table]);
@@ -309,6 +418,31 @@ export class WwnActorSheetCharacter extends WwnActorSheet {
       }
     });
 
+    // Container toggle listener
+    html.find(".inventory .container-arrow").click(async (ev) => {
+      const container = $(ev.currentTarget).closest('.item-entry');
+      const itemId = container.find('.item').data('itemId');
+      const item = this.actor.items.get(itemId);
+      const items = container.find('.container-items');
+
+      if (item && item.system.container.isContainer) {
+        const isCurrentlyOpen = item.system.container.isOpen;
+        const icon = $(ev.currentTarget).find('i');
+
+        // Animate the container
+        if (!isCurrentlyOpen) {
+          items.slideDown(200);
+        } else {
+          items.slideUp(200);
+        }
+
+        // Update the item state
+        await item.update({
+          "system.container.isOpen": !isCurrentlyOpen
+        });
+      }
+    });
+
     html.find("a[data-action='modifiers']").click((ev) => {
       this._onShowModifiers(ev);
     });
@@ -351,26 +485,48 @@ export class WwnActorSheetCharacter extends WwnActorSheet {
       await item.update({
         system: {
           equipped: !item.system.equipped,
+          stowed: item.system.equipped ? item.system.stowed : false,
         },
       });
+
+      // Update contained items
+      if (item.system.container.isContainer) {
+        const containedItems = item.actor.items.filter((i) => i.system.containerId === item.id);
+        item.actor.updateEmbeddedDocuments("Item", containedItems.map((i) => ({
+          _id: i.id,
+          "system.equipped": false,
+          "system.stowed": item.system.equipped || item.system.stowed,
+        })));
+      }
     });
 
-    html.find(".item-prep").click(async (ev) => {
+    html.find(".stow-toggle").click(async (ev) => {
       const li = $(ev.currentTarget).parents(".item");
       const item = this.actor.items.get(li.data("itemId"));
       await item.update({
         system: {
-          prepared: !item.system.prepared,
+          equipped: item.system.stowed ? item.system.equipped : false,
+          stowed: !item.system.stowed,
         },
       });
+
+      // Update contained items
+      if (item.system.container.isContainer) {
+        const containedItems = item.actor.items.filter((i) => i.system.containerId === item.id);
+        item.actor.updateEmbeddedDocuments("Item", containedItems.map((i) => ({
+          _id: i.id,
+          "system.equipped": false,
+          "system.stowed": item.system.equipped || item.system.stowed,
+        })));
+      }
     });
 
-    html.find(".stow-toggle").click(async (ev) => {
+    html.find(".item-prep").click(async (ev) => {
       const li = $(ev.currentTarget).parents(".item");
       const item = this.actor.items.get(li.data("itemId"));
       await item.update({
         system: {
-          stowed: !item.system.stowed,
+          prepared: !item.system.prepared,
         },
       });
     });

module/actor/entity.js

@@ -1268,7 +1268,7 @@ export class WwnActor extends Actor {
     const data = this.system;
     const saves = data.saves;
     const baseSave = this.type === "monster" ? 15 : 16;
-    console.log(baseSave);
+
     Object.keys(saves).forEach((s) => {
       if (!saves[s].mod) {
         saves[s].mod = 0;

module/combat/combat-group.js

@@ -42,27 +42,22 @@ export class WWNGroupCombat extends WWNCombat {
     }), {});
     const results = await this.#prepareGroupInitiativeDice(rollPerGroup);
 
-    // Rewrite to make new roll for each black group combatant, using similar logic to what
-    // is done in rollPerGroup / #prepareGroupInitiativeDice
-
     const alertCombatants = this.combatants.filter(c => c.group === "black");
-    const alertResults = {};
+    this.alertResults = {};
     for (const combatant of alertCombatants) {
       const combatantData = combatant.token.delta.syntheticActor.system;
       const roll = new Roll(`${combatantData.initiative.roll}+${combatantData.initiative.value}`);
       const evaluatedRoll = await roll.evaluate();
-      alertResults[combatant.id] = {
+      this.alertResults[combatant.id] = {
         initiative: evaluatedRoll.total,
         roll: evaluatedRoll
       };
     }
 
     const updates = this.combatants.map(
-      (c) => ({ _id: c.id, initiative: c.group === "black" ? alertResults[c.id].initiative : results[c.group].initiative })
+      (c) => ({ _id: c.id, initiative: c.group === "black" ? this.alertResults[c.id].initiative : results[c.group].initiative })
     )
 
-
-
     await this.updateEmbeddedDocuments("Combatant", updates);
     await this.#rollInitiativeUIFeedback(results);
     await this.activateCombatant(0);
@@ -73,15 +68,18 @@ export class WWNGroupCombat extends WWNCombat {
     const pool = foundry.dice.terms.PoolTerm.fromRolls(Object.values(rollPerGroup));
     const evaluatedRolls = await Roll.fromTerms([pool]).roll();
     const rollValues = evaluatedRolls.dice.map(d => d.total);
+    const diceArray = [...evaluatedRolls.dice];
+
     if (this.availableGroups.includes("black")) {
-      rollValues.splice(this.availableGroups.indexOf('black'), 0, 0)
+      rollValues.splice(this.availableGroups.indexOf('black'), 0, 0);
+      diceArray.splice(this.availableGroups.indexOf('black'), 0, null);
     }
 
     return this.availableGroups.reduce((prev, curr, i) => ({
       ...prev,
-      [[curr]]: {
+      [curr]: {
         initiative: rollValues[i],
-        roll: evaluatedRolls.dice[i]
+        roll: diceArray[i]
       }
     }), {});
   }
@@ -104,9 +102,33 @@ export class WWNGroupCombat extends WWNCombat {
 
   #constructInitiativeOutputForGroup(group, roll) {
     if (group === "black") {
-      // TODO: Display individual initiative rolls for black group combatants
+      const alertCombatants = this.combatants.filter(c => c.group === "black");
+      return alertCombatants.map(combatant => {
+        const alertResult = this.alertResults[combatant.id];
+        if (!alertResult) return '';
+
+        return `
+        <p>${game.i18n.format("WWN.roll.initiative", { group: combatant.name })}
+        <div class="dice-roll">   
+          <div class="dice-result">
+            <div class="dice-formula">${alertResult.roll.formula}</div>
+              <div class="dice-tooltip">
+                    <section class="tooltip-part">
+                      <div class="dice">
+                          <header class="part-header flexrow">
+                              <span class="part-formula">${alertResult.roll.formula}</span>
+                              <span class="part-total">${alertResult.roll.total}</span>
+                          </header>
+                      </div>
+                    </section>
+              </div>
+            <h4 class="dice-total">${alertResult.roll.total}</h4>
+          </div>
+        </div>
+      `;
+      }).join("\n");
     } else {
-      return `    
+      return `
       <p>${game.i18n.format("WWN.roll.initiative", { group })}
       <div class="dice-roll">   
         <div class="dice-result">

module/combat/combat.js

@@ -77,10 +77,52 @@ export class WWNCombat extends Combat {
 
     const updates = this.combatants.map((c) => ({ _id: c.id, initiative: results[c.id].initiative }));
     await this.updateEmbeddedDocuments("Combatant", updates);
+    await this.#rollInitiativeUIFeedback(results);
     await this.activateCombatant(0);
     return this;
   }
 
+  async #rollInitiativeUIFeedback(results = {}) {
+    const content = [
+      Object.entries(results).map(
+        ([id, result]) => this.#constructInitiativeOutputForIndividual(id, result.roll)
+      ).join("\n")
+    ];
+    const chatData = content.map(c => {
+      return {
+        speaker: { alias: game.i18n.localize("WWN.Initiative") },
+        sound: CONFIG.sounds.dice,
+        content: c
+      };
+    });
+    ChatMessage.implementation.createDocuments(chatData);
+  }
+
+  #constructInitiativeOutputForIndividual(id, roll) {
+    const combatant = this.combatants.get(id);
+    if (!combatant) return '';
+
+    return `
+    <p>${game.i18n.format("WWN.roll.initiative", { group: combatant.name })}
+    <div class="dice-roll">   
+      <div class="dice-result">
+        <div class="dice-formula">${roll.formula}</div>
+          <div class="dice-tooltip">
+                <section class="tooltip-part">
+                  <div class="dice">
+                      <header class="part-header flexrow">
+                          <span class="part-formula">${roll.formula}</span>
+                          <span class="part-total">${roll.total}</span>
+                      </header>
+                  </div>
+                </section>
+          </div>
+        <h4 class="dice-total">${roll.total}</h4>
+      </div>
+    </div>
+  `;
+  }
+
   // ===========================================================================
   // Randomize NPC HP
   // ===========================================================================

module/combat/combatant-group.js

@@ -10,8 +10,10 @@ export class WWNGroupCombatant extends WWNCombatant {
     if (assignedGroup)
       return assignedGroup;
 
-    if (canvas.tokens) {
+    if (canvas.tokens && this.token) {
       const token = canvas.tokens.get(this.token.id);
+      if (!token) return 'white';
+
       const disposition = token.document.disposition;
       const alertTwo = token.document.delta.syntheticActor.system.initiative.alertTwo;
       if (alertTwo) return "black";