Initial codebase

src/helpers.ts

@@ -0,0 +1,137 @@
+import { WORKBENCH_SIZE } from "./consts.js";
+import { ItemType, type IItem, type IScrewdriver } from "./state/item.js";
+import type { IInventory, IState, IWorkbench } from "./state/types.js";
+
+type AllInventories = "player" | "car" | "home" | "workbench";
+
+interface ItemContainer<T> {
+    index: number;
+    item: T;
+}
+
+const GetItemsAsInventory = (items: IItem[]): IInventory => {
+    return {
+        size: -1,
+        items: items,
+    };
+};
+
+const GetWorkbenchAsInventory = (workbench: IWorkbench): IInventory => {
+    return {
+        size: WORKBENCH_SIZE,
+        items: workbench.devices,
+    };
+};
+
+const GetInventory = (name: AllInventories, state: IState): IInventory => {
+    let inventory: IInventory;
+
+    switch (name) {
+        case "player":
+            inventory = state.player.inventory;
+            break;
+        case "car":
+            inventory = state.car.inventory;
+            break;
+        case "home":
+            inventory = state.home.inventory;
+            break;
+        case "workbench":
+            inventory = GetWorkbenchAsInventory(state.home.workbench);
+            break;
+    }
+
+    return inventory;
+};
+
+const GetItemsOfType = <T>(
+    itemType: ItemType,
+    inventories: IInventory[],
+): T[] => {
+    const items: T[] = [];
+
+    inventories.forEach((inventory) => {
+        items.push(
+            ...(inventory.items.filter(
+                (item) => item.type === itemType,
+            ) as T[]),
+        );
+    });
+
+    return items;
+};
+
+const GetItemOfType = <T>(
+    itemType: ItemType,
+    inventories: IInventory[],
+): T | undefined => {
+    let item: T | undefined;
+
+    inventories.forEach((inventory) => {
+        const found = inventory.items.find(
+            (_item) => _item.type === itemType,
+        ) as T;
+        if (found) {
+            item = found;
+            return;
+        }
+    });
+
+    return item;
+};
+
+const GetItemContainerOfType = <T>(
+    itemType: ItemType,
+    inventories: IInventory[],
+): ItemContainer<T> | undefined => {
+    let container: ItemContainer<T> | undefined;
+
+    inventories.forEach((inventory) => {
+        const found = inventory.items.find(
+            (_item) => _item.type === itemType,
+        ) as T;
+        const foundIndex = inventory.items.findIndex(
+            (_item) => _item.type === itemType,
+        );
+        if (found && foundIndex) {
+            container = {
+                index: foundIndex,
+                item: found,
+            };
+            return;
+        }
+    });
+
+    return container;
+};
+
+const GetBestScrewdriver = (
+    inventories: IInventory[],
+): IScrewdriver | undefined => {
+    const screwdrivers = GetItemsOfType(
+        ItemType.SCREWDRIVER,
+        inventories,
+    ) as IScrewdriver[];
+
+    let bestScrewdriver: IScrewdriver | undefined;
+    let bestQuality = -1;
+
+    screwdrivers.forEach((screwdriver) => {
+        if (screwdriver.quality > bestQuality) {
+            bestScrewdriver = screwdriver;
+        }
+    });
+
+    return bestScrewdriver;
+};
+
+export { type AllInventories, type ItemContainer };
+export {
+    GetItemsAsInventory,
+    GetWorkbenchAsInventory,
+    GetInventory,
+    GetItemsOfType,
+    GetItemOfType,
+    GetItemContainerOfType,
+    GetBestScrewdriver,
+};