Fix Various Weight Bugs

CHANGELOG.md

@@ -50,6 +50,8 @@ Athena.systems.inventory.convert.toBaseItem
 Athena.systems.inventory.convert.toItem
 Athena.systems.inventory.convert.toStoredItem
 
+Fix Various Weight Related Bugs
+
 --------------------------------------
 --- Everything Below is Before April 2
 --------------------------------------

src/core/plugins/core-inventory/server/src/view.ts

@@ -318,35 +318,16 @@ const Internal = {
 
  // Check Storage Capacity
  const config = Athena.systems.inventory.config.get();
- const maxWeight = openStoragesWeight[player.id];
- let itemsToCheck: Array<StoredItem>;
 
- if (info.startType === 'custom' && config.weight.enabled) {
- itemsToCheck = complexSwap.from;
-
- if ((Athena.systems.inventory.weight.isWeightExceeded([complexSwap.to]), config.weight.player)) {
- // console.log('weight exceeded at 1');
+ if (config.weight.enabled) {
+ const storageWeight = openStoragesWeight[player.id];
+ const maxWeight = info.endType === 'custom' ? storageWeight : config.weight.player;
+ if (Athena.systems.inventory.weight.isWeightExceeded([complexSwap.to], maxWeight)) {
  InventoryView.storage.resync(player);
  return;
  }
  }
 
- if (info.endType === 'custom' && config.weight.enabled) {
- itemsToCheck = complexSwap.to;
- if ((Athena.systems.inventory.weight.isWeightExceeded([complexSwap.from]), maxWeight)) {
- // console.log('weight exceeded at 2');
- InventoryView.storage.resync(player);
- return;
- }
- }
-
- const isWeightExceeded = Athena.systems.inventory.weight.isWeightExceeded([itemsToCheck], maxWeight);
- if (isWeightExceeded) {
- // console.log('weight exceeded at 3');
- InventoryView.storage.resync(player);
- return;
- }
-
  // Assign Data
  if (info.startType === 'custom') {
  openStorages[player.id] = complexSwap.from;

src/core/plugins/core-inventory/webview/components/Grid.vue

@@ -103,8 +103,8 @@
  </div>
  <Context :contextTitle="context.title" :x="context.x" :y="context.y" v-if="context">
  <div v-if="context.hasUseEffect" @click="contextAction('use')">Use</div>
- <template v-for="(customAction) in context.customEvents">
- <div @click="contextAction('use',customAction.eventToCall)">{{customAction.name}}</div>
+ <template v-for="customAction in context.customEvents">
+ <div @click="contextAction('use', customAction.eventToCall)">{{ customAction.name }}</div>
  </template>
  <div @click="contextAction('split')">Split</div>
  <div @click="contextAction('drop')">Drop</div>
@@ -152,7 +152,16 @@ export default defineComponent({
  toolbar: 5,
  custom: 35,
  },
- context: undefined as { x: number; y: number; title: string; slot: number; hasUseEffect: boolean, customEvents: Array<CustomContextAction>} | undefined,
+ context: undefined as
+ | {
+ x: number;
+ y: number;
+ title: string;
+ slot: number;
+ hasUseEffect: boolean;
+ customEvents: Array<CustomContextAction>;
+ }
+ | undefined,
  itemSingleClick: undefined as { type: InventoryType; index: number },
  itemName: '',
  itemDescription: '',
@@ -256,7 +265,7 @@ export default defineComponent({
  hasItem: false,
  name: undefined,
  quantity: 0,
- weight: 0,
+ totalWeight: 0,
  highlight: false,
  slot,
  };
@@ -281,7 +290,7 @@ export default defineComponent({
  defaultTemplate.highlight = item.isEquipped;
  defaultTemplate.name = item.name;
  defaultTemplate.quantity = item.quantity;
- defaultTemplate.weight = typeof item.weight === 'number' ? item.weight : 0;
+ defaultTemplate.totalWeight = typeof item.totalWeight === 'number' ? item.totalWeight : 0;
  return defaultTemplate;
  },
  /**
@@ -347,10 +356,11 @@ export default defineComponent({
  }
 
  const item = this.getItem('inventory', slot);
- 
+
  // Let's check, if this item can be used. This information is used to show/hide the "Use" context menu action.
- const hasUseEffect: boolean = (typeof item.consumableEventToCall !== 'undefined' || 
- (item.behavior && (item.behavior.isEquippable || item.behavior.isWeapon || item.behavior.isClothing)));
+ const hasUseEffect: boolean =
+ typeof item.consumableEventToCall !== 'undefined' ||
+ (item.behavior && (item.behavior.isEquippable || item.behavior.isWeapon || item.behavior.isClothing));
 
  this.context = {
  title: item.name,

src/core/plugins/core-inventory/webview/components/Slot.vue

@@ -13,7 +13,7 @@
  <slot name="index"></slot>
  </div>
  <div class="quantity" v-if="info.quantity !== 0">{{ info.quantity }}x</div>
- <div class="weight" v-if="info.weight !== 0">{{ info.weight.toFixed(2) }}{{ units }}</div>
+ <div class="weight" v-if="info.totalWeight !== 0">{{ info.totalWeight.toFixed(2) }}{{ units }}</div>
  <div class="name" v-if="info.name !== '' && showName">
  {{ info.name }}
  </div>

src/core/plugins/core-inventory/webview/utility/slotInfo.ts

@@ -4,6 +4,6 @@ export interface SlotInfo {
  hasItem: boolean;
  quantity: number;
  name: string;
- weight: number;
+ totalWeight: number;
  highlight?: boolean;
 }

src/core/server/systems/inventory/factory.ts

@@ -338,8 +338,8 @@ export function fromStoredItem<CustomData = {}, CustomBehavior = DefaultItemBeha
 
  const combinedItem = Object.assign(baseItem, item) as Item<CustomBehavior & DefaultItemBehavior, CustomData>;
 
- if (typeof combinedItem.weight === 'number') {
- combinedItem.totalWeight = combinedItem.weight * combinedItem.quantity;
+ if (typeof baseItem.weight === 'number') {
+ combinedItem.totalWeight = baseItem.weight * combinedItem.quantity;
  }
 
  return combinedItem;

src/core/server/systems/inventory/manager.ts

@@ -329,7 +329,7 @@ export function add<CustomData = {}>(
  }
 
  if (item.quantity === 0) {
- return data;
+ return Athena.systems.inventory.weight.update<CustomData>(data);
  }
 
  // Lookup the base item based on the dbName of the item.
@@ -377,12 +377,10 @@ export function add<CustomData = {}>(
  item.quantity -= 1;
  }
 
- // Re-calculate item weight
- itemClone = calculateItemWeight(baseItem, itemClone);
  copyOfData.push(itemClone);
 
  if (item.quantity === 0) {
- return copyOfData;
+ return Athena.systems.inventory.weight.update<CustomData>(copyOfData);
  }
 
  return add(item, copyOfData, size);
@@ -463,9 +461,7 @@ export function sub<CustomData = {}>(
 
  // If the quantity of the found item is greater than; subtract necessary amount.
  copyOfData[existingItemIndex].quantity -= item.quantity;
- copyOfData[existingItemIndex] = calculateItemWeight(baseItem, copyOfData[existingItemIndex]);
-
- return copyOfData;
+ return Athena.systems.inventory.weight.update(copyOfData);
 }
 
 /**
@@ -528,10 +524,9 @@ export function splitAt<CustomData = {}>(
 
  // Remove quantity from existing item based on split count.
  copyOfData[index].quantity -= splitCount;
- copyOfData[index] = calculateItemWeight<CustomData>(baseItem, copyOfData[index]);
  copyOfData.push(itemClone);
 
- return copyOfData;
+ return Athena.systems.inventory.weight.update<CustomData>(copyOfData);
 }
 
 /**
@@ -584,19 +579,15 @@ export function combineAt<CustomData = {}>(
 
  if (copyOfData[fromIndex].quantity + copyOfData[toIndex].quantity <= baseItem.maxStack) {
  copyOfData[toIndex].quantity += copyOfData[fromIndex].quantity;
- copyOfData[toIndex] = calculateItemWeight(baseItem, copyOfData[toIndex]);
  copyOfData.splice(fromIndex, 1);
- return copyOfData;
+ return Athena.systems.inventory.weight.update<CustomData>(copyOfData);
  }
 
  const spaceAvailable = baseItem.maxStack - copyOfData[toIndex].quantity;
  copyOfData[fromIndex].quantity -= spaceAvailable;
  copyOfData[toIndex].quantity += spaceAvailable;
 
- copyOfData[fromIndex] = calculateItemWeight(baseItem, copyOfData[fromIndex]);
- copyOfData[toIndex] = calculateItemWeight(baseItem, copyOfData[toIndex]);
-
- return copyOfData;
+ return Athena.systems.inventory.weight.update<CustomData>(copyOfData);
 }
 
 export function combineAtComplex(from: ComplexSwap, to: ComplexSwap): ComplexSwapReturn | undefined {
@@ -645,18 +636,19 @@ export function combineAtComplex(from: ComplexSwap, to: ComplexSwap): ComplexSwa
  // Simply move quantities; and return results.
  if (spaceAvailable > fromData[fromIndex].quantity) {
  toData[toIndex].quantity += fromData[fromIndex].quantity;
- toData[toIndex] = calculateItemWeight(baseItem, toData[toIndex]);
  fromData.splice(fromIndex, 1);
- return { from: fromData, to: toData };
+ return {
+ from: Athena.systems.inventory.weight.update(fromData),
+ to: Athena.systems.inventory.weight.update(toData),
+ };
  }
 
  fromData[fromIndex].quantity -= spaceAvailable;
  toData[toIndex].quantity += spaceAvailable;
-
- fromData[fromIndex] = calculateItemWeight(baseItem, fromData[fromIndex]);
- toData[toIndex] = calculateItemWeight(baseItem, toData[toIndex]);
-
- return { from: fromData, to: toData };
+ return {
+ from: Athena.systems.inventory.weight.update(fromData),
+ to: Athena.systems.inventory.weight.update(toData),
+ };
 }
 
 /**
@@ -706,7 +698,7 @@ export function swap(
  copyOfData[endIndex].slot = fromSlot;
  }
 
- return copyOfData;
+ return Athena.systems.inventory.weight.update(copyOfData);
 }
 
 /**
@@ -778,7 +770,10 @@ export function swapBetween(from: ComplexSwap, to: ComplexSwap): ComplexSwapRetu
 
  // Move the 'from' item to the other data set.
  toData.push(fromItem);
- return { from: fromData, to: toData };
+ return {
+ from: Athena.systems.inventory.weight.update(fromData),
+ to: Athena.systems.inventory.weight.update(toData),
+ };
 }
 
 /**

src/core/server/systems/inventory/weight.ts

@@ -1,4 +1,5 @@
 import { Item, StoredItem } from '@AthenaShared/interfaces/item';
+import * as Athena from '@AthenaServer/api';
 import * as config from './config';
 
 /**
@@ -60,6 +61,27 @@ export function isWeightExceeded(dataSets: Array<Array<StoredItem | Item>>, amou
  return false;
 }
 
+/**
+ * Update weight for a given data set, and all items.
+ *
+ * @export
+ * @template T
+ * @param {(Array<StoredItem<T> | Item>)} dataSet
+ * @return {(Array<StoredItem<T> | Item>)}
+ */
+export function update<T = {}>(dataSet: Array<StoredItem<T>>): Array<StoredItem<T>> {
+ for (let i = 0; i < dataSet.length; i++) {
+ const baseItem = Athena.systems.inventory.factory.getBaseItem(dataSet[i].dbName);
+ if (typeof baseItem === 'undefined') {
+ continue;
+ }
+
+ dataSet[i].totalWeight = baseItem.weight * dataSet[i].quantity;
+ }
+
+ return dataSet;
+}
+
 interface WeightFuncs {
  getDataWeight: typeof getDataWeight;
  getTotalWeight: typeof getTotalWeight;