fix: make the movement calculate correctly

Author: anthonyronda

src/lang/en.json

@@ -215,7 +215,9 @@
   "OSE.items.Containers": "Containers",
   "OSE.items.Armors": "Armors",
   "OSE.items.Weight": "Wgt.",
-  "OSE.items.ItemSlots": "Item Slots",
+  "OSE.items.WeightLong": "Weight",
+  "OSE.items.ItemBasedEncumberance": "Enc.",
+  "OSE.items.ItemBasedEncumberanceLong": "Item-Based Encumbrance",
   "OSE.items.Qualities": "Qualities",
   "OSE.items.Notes": "Notes",
   "OSE.items.Cost": "Cost",

src/module/actor/data-model-classes/data-model-character-encumbrance-item-based.ts

@@ -15,6 +15,24 @@ export default class OseDataModelCharacterEncumbranceItemBased
   extends OseDataModelCharacterEncumbrance
   implements CharacterEncumbrance
 {
+  static packedEncumbranceSteps = {
+    fiveEighths: 62.5,
+    threeQuarters: 75,
+    sevenEighths: 87.5,
+  };
+
+  static equippedEncumbranceSteps = {
+    oneThird: 33.33,
+    fiveNinths: 55.55,
+    sevenNinths: 77.77,
+  };
+
+  #equippedMax;
+
+  #packedMax;
+
+  #max;
+
   static templateEncumbranceBar = "";
 
   static templateInventoryRow = "";
@@ -31,28 +49,82 @@ export default class OseDataModelCharacterEncumbranceItemBased
 
   #weight;
 
-  constructor(
-    max = OseDataModelCharacterEncumbrance.baseEncumbranceCap,
-    items: Item[] = []
-  ) {
+  #equippedWeight;
+
+  #packedWeight;
+
+  constructor(max = 16, items: Item[] = []) {
     super(OseDataModelCharacterEncumbranceItemBased.type, max);
-    this.#weight = items.reduce(
-      (acc, { type, system: { quantity, itemslots } }: Item) => {
-        if (type === "item") return acc + quantity.value * itemslots;
-        if (["weapon", "armor", "container"].includes(type))
-          return acc + itemslots;
-        return acc;
-      },
-      0
+
+    this.#packedMax = 16;
+    this.#equippedMax = 9;
+    this.#packedWeight = Math.ceil(
+      items.reduce(
+        (acc, { type, system: { quantity, itemslots, equipped } }: Item) => {
+          if (type === "item" && !equipped)
+            return acc + quantity.value * itemslots;
+          if (["weapon", "armor", "container"].includes(type) && !equipped)
+            return acc + itemslots;
+          return acc;
+        },
+        0
+      )
+    );
+    this.#equippedWeight = Math.ceil(
+      items.reduce(
+        (acc, { type, system: { quantity, itemslots, equipped } }: Item) => {
+          if (type === "item" && equipped)
+            return acc + quantity.value * itemslots;
+          if (["weapon", "armor", "container"].includes(type) && equipped)
+            return acc + itemslots;
+          return acc;
+        },
+        0
+      )
     );
+    this.#weight = this.usingEquippedEncumbrance
+      ? this.#equippedWeight
+      : this.#packedWeight;
+
+    this.#max = this.usingEquippedEncumbrance
+      ? this.#equippedMax
+      : this.#packedMax;
   }
 
   // eslint-disable-next-line class-methods-use-this
   get steps() {
-    return Object.values(OseDataModelCharacterEncumbrance.encumbranceSteps);
+    return this.usingEquippedEncumbrance
+      ? Object.values(
+          OseDataModelCharacterEncumbranceItemBased.equippedEncumbranceSteps
+        )
+      : Object.values(
+          OseDataModelCharacterEncumbranceItemBased.packedEncumbranceSteps
+        );
+  }
+
+  get usingEquippedEncumbrance() {
+    const equippedValues = Object.values(
+      OseDataModelCharacterEncumbranceItemBased.equippedEncumbranceSteps
+    );
+    const packedValues = Object.values(
+      OseDataModelCharacterEncumbranceItemBased.packedEncumbranceSteps
+    );
+    let equippedIndex = equippedValues.findIndex(
+      (step) => step > (this.#equippedWeight / this.#equippedMax) * 100
+    );
+    equippedIndex = equippedIndex === -1 ? 4 : equippedIndex;
+    let packedIndex = packedValues.findIndex(
+      (step) => step > (this.#packedWeight / this.#packedMax) * 100
+    );
+    packedIndex = packedIndex === -1 ? 4 : packedIndex;
+    return !!(equippedIndex >= packedIndex);
   }
 
   get value(): number {
     return this.#weight;
   }
+
+  get max(): number {
+    return this.#max;
+  }
 }

src/module/actor/data-model-classes/data-model-character-encumbrance.ts

@@ -26,6 +26,12 @@ export default class OseDataModelCharacterEncumbrance
     quarter: 25,
     threeEighths: 37.5,
     half: 50,
+    fiveEighths: 62.5,
+    threeQuarters: 75,
+    sevenEighths: 87.5,
+    oneThird: 33.34,
+    fiveNinths: 55.56,
+    sevenNinths: 77.78,
   };
 
   #encumbranceVariant;
@@ -113,4 +119,65 @@ export default class OseDataModelCharacterEncumbrance
         (this.#delta || 0)
     );
   }
+
+  // Item-based encumbrance variant props - packed
+  get atFiveEighthsEncumbered() {
+    return (
+      this.value >
+      this.max *
+        (OseDataModelCharacterEncumbrance.encumbranceSteps.fiveEighths / 100)
+    );
+  }
+
+  get atThreeQuartersEncumbered() {
+    return (
+      this.value >
+      this.max *
+        (OseDataModelCharacterEncumbrance.encumbranceSteps.threeQuarters / 100)
+    );
+  }
+
+  get atSevenEighthsEncumbered() {
+    return (
+      this.value >
+      this.max *
+        (OseDataModelCharacterEncumbrance.encumbranceSteps.sevenEighths / 100)
+    );
+  }
+
+  // Item-based encumbrance variant props - equipped
+  // eslint-disable-next-line class-methods-use-this
+  get usingEquippedEncumbrance() {
+    return false;
+  }
+
+  get atOneThirdEncumbered() {
+    return (
+      this.value >
+      Math.round(
+        this.max *
+          (OseDataModelCharacterEncumbrance.encumbranceSteps.oneThird / 100)
+      )
+    );
+  }
+
+  get atFiveNinthsEncumbered() {
+    return (
+      this.value >
+      Math.round(
+        this.max *
+          (OseDataModelCharacterEncumbrance.encumbranceSteps.fiveNinths / 100)
+      )
+    );
+  }
+
+  get atSevenNinthsEncumbered() {
+    return (
+      this.value >
+      Math.round(
+        this.max *
+          (OseDataModelCharacterEncumbrance.encumbranceSteps.sevenNinths / 100)
+      )
+    );
+  }
 }

src/module/actor/data-model-classes/data-model-character-move.ts

@@ -26,20 +26,38 @@ export default class OseDataModelCharacterMove implements CharacterMove {
   #overEncumbranceLimit;
 
   #halfEncumbered;
+
   #threeEighthsEncumbered;
+
   #quarterEncumbered;
-  
+
+  #fiveEighthsEncumbered;
+
+  #threeQuartersEncumbered;
+
+  #sevenEighthsEncumbered;
+
+  #usingEquippedEncumbrance;
+
+  #oneThirdEncumbered;
+
+  #fiveNinthsEncumbered;
+
+  #sevenNinthsEncumbered;
+
   /**
    * The constructor
    *
    * @param {OseDataModelCharacterEncumbrance} encumbrance - An object representing the character's encumbrance values
    * @param {boolean} shouldCalculateMovement - Should the class autocalculate movement?
    * @param {number} base - The base move rate for the actor
+   * @param {boolean} usingEquippedEncumbrance - Is the character using equipped encumbrance
    */
   constructor(
     encumbrance: OseDataModelCharacterEncumbrance = new OseDataModelCharacterEncumbrance(),
     shouldCalculateMovement = true,
-    base = OseDataModelCharacterMove.baseMoveRate
+    base = OseDataModelCharacterMove.baseMoveRate,
+    usingEquippedEncumbrance = encumbrance.usingEquippedEncumbrance
   ) {
     // Props necessary for any encumbrance variant
     this.#moveBase = base;
@@ -48,17 +66,38 @@ export default class OseDataModelCharacterMove implements CharacterMove {
     this.#overEncumbranceLimit = encumbrance.encumbered;
 
     // Non-basic encumbrance variant props
-    this.#halfEncumbered    = encumbrance.atHalfEncumbered;
+    this.#halfEncumbered = encumbrance.atHalfEncumbered;
     this.#threeEighthsEncumbered = encumbrance.atThreeEighthsEncumbered;
-    this.#quarterEncumbered  = encumbrance.atQuarterEncumbered;
+    this.#quarterEncumbered = encumbrance.atQuarterEncumbered;
+
+    // Item-based encumbrance variant props - packed steps
+    this.#fiveEighthsEncumbered = encumbrance.atFiveEighthsEncumbered;
+    this.#threeQuartersEncumbered = encumbrance.atThreeQuartersEncumbered;
+    this.#sevenEighthsEncumbered = encumbrance.atSevenEighthsEncumbered;
+    // Item-based encumbrance variant props - equipped steps
+    this.#usingEquippedEncumbrance = usingEquippedEncumbrance;
+    this.#oneThirdEncumbered = encumbrance.atOneThirdEncumbered;
+    this.#fiveNinthsEncumbered = encumbrance.atFiveNinthsEncumbered;
+    this.#sevenNinthsEncumbered = encumbrance.atSevenNinthsEncumbered;
   }
 
   #derivedSpeed() {
-    if (this.#overEncumbranceLimit)    return 0;
-    else if (this.#halfEncumbered)     return this.#moveBase * .25;
-    else if (this.#threeEighthsEncumbered)  return this.#moveBase * .50;
-    else if (this.#quarterEncumbered)   return this.#moveBase * .75;
-    else                               return this.#moveBase;
+    if (this.#overEncumbranceLimit) return 0;
+    if (this.#usingEquippedEncumbrance) {
+      if (this.#sevenNinthsEncumbered) return this.#moveBase * 0.25;
+      if (this.#fiveNinthsEncumbered) return this.#moveBase * 0.5;
+      return this.#oneThirdEncumbered ? this.#moveBase * 0.75 : this.#moveBase;
+    }
+    if (this.#encumbranceVariant === "itembased") {
+      if (this.#sevenEighthsEncumbered) return this.#moveBase * 0.25;
+      if (this.#threeQuartersEncumbered) return this.#moveBase * 0.5;
+      return this.#fiveEighthsEncumbered
+        ? this.#moveBase * 0.75
+        : this.#moveBase;
+    }
+    if (this.#halfEncumbered) return this.#moveBase * 0.25;
+    if (this.#threeEighthsEncumbered) return this.#moveBase * 0.5;
+    return this.#quarterEncumbered ? this.#moveBase * 0.75 : this.#moveBase;
   }
 
   get base() {

src/module/helpers-handlebars.ts

@@ -71,6 +71,8 @@ const registerHelpers = async () => {
     "asset",
     (relativePath) => `${OSE.assetsPath}${relativePath}`
   );
+
+  Handlebars.registerHelper("ceil", (val) => Math.ceil(val));
 };
 
 export default registerHelpers;

src/module/item/data-model-spell.js

@@ -1,7 +1,7 @@
 /**
- * @file The data model for Items of type Ability
+ * @file The data model for Items of type Spell
  */
-export default class OseDataModelItem extends foundry.abstract.DataModel {
+export default class OseDataModelSpell extends foundry.abstract.DataModel {
   static defineSchema() {
     const { StringField, NumberField, ArrayField, ObjectField } =
       foundry.data.fields;