# com.litterbox.inventory

> Inventory system. Part of BCS framework

Latest version **1.0.1** (published 2023-03-13) · 0 weekly downloads

## Install

```sh
npm install com.litterbox.inventory
pnpm add com.litterbox.inventory
yarn add com.litterbox.inventory
bun add com.litterbox.inventory
```

## Health

**Score 15/100 (F)** — status: abandoned.

Positive: no vulnerabilities.

Warnings: low downloads; no types; no esm support.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 1.0.1 |
| Published | 2023-03-13 |
| First published | 2023-02-18 |
| Weekly downloads | 0 |
| TypeScript types | none |
| Module format | CommonJS |
| Dependencies | 1 |
| Unpacked size | 94.8 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| Author | Black Cat Studios |
| Maintainers | blackcatadmin |

## Links

- npm: https://www.npmjs.com/package/com.litterbox.inventory
- npm.io page: https://npm.io/package/com.litterbox.inventory

## Dependencies (1)

- [com.litterbox.itemdatabase](https://npm.io/package/com.litterbox.itemdatabase.md) 1.0.2

## Recent versions

- 1.0.1 (latest) — 2023-03-13
- 1.0.0 — 2023-02-18

## README

# Quick Start

* Add BCS Inventory package to your package manifest. (com.bcs.inventory)
* Go to your game's initialization code and add:
  * `InventoryModule.Initialize(new InventoryPlayerPrefsJsonProvider())`
  * Initialize method accepts `IInventoryDataProvider` interface, which the 
    `InventoryPlayerPrefsJsonProvider` class implements. You can write custom
    providers by implementing the same interface.
* Inventory module creates a game wide inventory by default. You can access it
  with the constant key: `InventoryModule.AccountInventory`.
* To create a custom inventory, use below to methods:
  * `InventoryModule.IsInventoryValid(string)` : Makes sure the inventory exists and usable
  * `InventoryModule.CreateInventory(string)` : Creates the inventory.
  * So, to create a new inventory and make sure it is not creates previously:
    ```c#
    if (InventoryModule.IsInventoryValid(myInventoryId))
    {
        InventoryModule.CreateInventory(myInventoryId);
    }
    ```
* To add items, use `InventoryModule.AddToInventory(string, string, int)` or one of its overloads:
  * `InventoryModule.AddToInventory(string, string, int)`
  * `InventoryModule.AddToInventory(string, ItemDefinition, int)`
* To remove items from inventory:
  * `InventoryModule.RemoveFromInventory(string, string, int)`
  * `InventoryModule.RemoveFromInventory(string, ItemDefinition, int)`
* To get the owned quantity of a said item:
  * `InventoryModule.GetOwnedQuantity(string, string)`
  * `InventoryModule.GetOwnedQuantity(string, ItemDefinition)`
* To get a value indicating whether the given item is in inventory:
  * `InventoryModule.IsInInventory(string, string)`
  * `InventoryModule.IsInInventory(string, ItemDefinition)`

## Inventory Class

To decrease the amount of code written, inventory module comes with a wrapper class named `Inventory`. This class stores the id of the inventory it represents
and provides the following methods to modify the invenory with provided id:

```c#
void Add(string, int)
void Add(ItemDefition, int)
void Remove(string, int)
void Remove(ItemDefition, int)
int GetOwned(string)
int GetOwned(ItemDefition)
bool HasItem(string)
bool HasItem(ItemDefinition)
```

### A sample usage

```c#
public class InventoryClassExample
{
    private Inventory myInventory;
    private Inventory accountInventory;

    public void Initialize()
    {
        myInventory = new Inventory("myInventory");
        accountInventory = new Inventory();
    }

    public void AddMoneyToAccount(int money)
    {
        var moneyItem = ItemDatabaseModule.GetItem("it-money");
        accountInventory.Add(moneyItem, money);
    }

    public void MoveFundsToMyInventory(int money)
    {
        var accountFunds = accountInventory.GetOwned("it-money");
        
        if (accountsFunds < money)
        {
            money = accountFunds;
        }

        accountInventory.Remove("it-money", money);
        myInventory.Add("it-money", money);
    }
}
```

## Scriptable Inventories

Inventory module also provides you with a way to serialize inventory objects as scriptable objects, so that you can reference them from scripts and reuse them. for this, go to any folder you wish (`Assets > Game > Data > Inventories` is recommended), right click and then `Create > BCS > Inventory`. This will create a scriptable object. 

![Add Inventory](~DOCS/createinventoryobject.png)

Now, select the inventory scriptable object and set its id.

![Set Id of Inventory Object](~DOCS/inventoryobjectsetid.png)

To use it, create a script and add the following line to it.

```C#
[SerializeField] private InventoryObject inventory;
```

This will create a field in the inspector. Now, click the small circle next to it and select your inventory.

![Select inventory](~DOCS/selectinventory.png)

Back to your script, you can now use this like the following:

```c#
public void AddMoneyToInventory(int money)
{
    inventory.Inventory.Add(currency, money);
}
```

Full class for clarity:

```C#
public class ScriptableInventoryExample : MonoBehaviour
{
    [SerializeField] private InventoryObject inventory;
    [SerializeField] private ItemDefinition currency;

    public void AddMoneyToInventory(int money)
    {
        inventory.Inventory.Add(currency, money);
    }
}
```

## Dependencies

* BCS Item Database: `com.bcs.itemdatabase`

---
_Source: https://npm.io/package/com.litterbox.inventory · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._