137 lines
3.1 KiB
TypeScript
137 lines
3.1 KiB
TypeScript
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,
|
|
};
|