BaseInventoryComponentclass

public bool Add(Sandbox.BaseInventoryItem item, int slot = -1)PUBLIC

Adds an already-spawned item to the inventory. Slot -1 picks one: the item's `Sandbox.BaseInventoryItem.PreferredSlot` when free, otherwise the first empty slot (buckets always take the preference). Host only. The item is reparented under this inventory and disabled until switched to.

protected virtual bool CanPickupWorldItem(Sandbox.BaseInventoryItem item)PROTECTEDVIRTUAL

Is this an item lying in the world that we could take right now? It's valid, it isn't in an inventory, it doesn't refuse us (`Sandbox.BaseInventoryItem.OnCanPickup(Sandbox.BaseInventoryComponent)`), and it isn't something we dropped a moment ago. Runs on the host for routed pickup requests, making it the place to validate them - the base deliberately has no range check (like shot claims, what's plausible is game policy), so override to add range or line-of-sight rules.

public void Drop(Sandbox.BaseInventoryItem item)PUBLIC

Drops an item out of the inventory and into the world. Holsters it first if it's active, asks the item to place itself (see `Sandbox.BaseInventoryItem.Drop`), then switches to the best remaining item. Routed through the host.

public int FindEmptySlot()PUBLIC

Returns the first empty slot index, or -1 if the inventory is full.

public void ForceHolster()PUBLIC

Holsters the active item without giving it a say (`Sandbox.BaseInventoryItem.OnHolstering(Sandbox.BaseInventoryItem)` isn't consulted) - for host-decreed empty hands: arrests, vehicles, cutscenes. Host only.

public int GetAmmo(Sandbox.BaseAmmoResource type)PUBLIC

How much reserve ammo of the given type this inventory holds. Null is 0.

public virtual Sandbox.BaseInventoryItem GetBestItem()PUBLICVIRTUAL

Returns the highest `Sandbox.BaseInventoryItem.Value` item we're allowed to switch to, or null if there's nothing switchable. Items flagged `Sandbox.BaseInventoryItem.ShouldAvoid` (e.g. empty guns) are only picked when nothing better exists. Override for game-specific priority - runs on the host for engine-driven switches (remove, drop, pickup, loadout), so per-player preference data must be host-available.

public T GetItem()PUBLIC

Returns the first item of the given type in the inventory (lowest slot wins), or null.

public Sandbox.BaseInventoryItem GetSlot(int slot)PUBLIC

Returns the item in the given slot, or null if the slot is empty. When items share the slot (a buckets inventory), the lowest `Sandbox.BaseInventoryItem.SlotOrder` wins.

public System.Collections.Generic.IEnumerable`1<Sandbox.BaseInventoryItem> GetSlotItems(int slot)PUBLIC

Returns every item in the given slot, ordered by `Sandbox.BaseInventoryItem.SlotOrder`. One or none in a hotbar inventory; the bucket's contents in a buckets one.

public int GiveAmmo(Sandbox.BaseAmmoResource type, int amount)PUBLIC

Add reserve ammo of the given type, clamped to the type's `Sandbox.BaseAmmoResource.MaxReserve`. Returns how much was actually added. Call this from host game logic (pickups) - it's authoritative on the host.

public void GiveLoadout()PUBLIC

Grants the starting loadout - picks up every `Sandbox.BaseInventoryComponent.StartingItems` prefab, grants the `Sandbox.BaseInventoryComponent.StartingAmmo`, then switches to the best item if nothing is active. Host only. Grants unconditionally - it's the caller's job to only ask once per life.

public bool HasAmmo(Sandbox.BaseAmmoResource type, int amount = 1)PUBLIC

Does this inventory hold at least `amount` reserve ammo of the given type?

public bool HasItem()PUBLIC

Returns whether the inventory contains an item of the given type.

public void MoveSlot(int fromSlot, int toSlot)PUBLIC

Moves the item in `fromSlot` to `toSlot`, swapping if the destination is occupied. Routed through the host.

protected virtual bool OnAdding(Sandbox.BaseInventoryItem item, int slot)PROTECTEDVIRTUAL

An item is about to be added to `slot`. Return false to refuse.

protected virtual bool OnDropping(Sandbox.BaseInventoryItem item)PROTECTEDVIRTUAL

An item is about to be dropped into the world. Return false to refuse.

protected virtual void OnFixedUpdate()PROTECTEDVIRTUALFIXED TICK

protected virtual void OnItemAdded(Sandbox.BaseInventoryItem item)PROTECTEDVIRTUAL

An item was added to the inventory.

protected virtual bool OnMovingSlot(int fromSlot, int toSlot)PROTECTEDVIRTUAL

The items in these slots are about to move/swap. Return false to refuse.

protected virtual bool OnRemoving(Sandbox.BaseInventoryItem item)PROTECTEDVIRTUAL

An item is about to be removed and destroyed. Return false to refuse.

protected virtual void OnStart()PROTECTEDVIRTUALLIFECYCLE

protected virtual void OnUpdate()PROTECTEDVIRTUALPER-FRAME

public virtual void PickupWorldItem(Sandbox.BaseInventoryItem item)PUBLICVIRTUAL

Take an item lying in the world into this inventory - the path Touch and Use pickup share, and the one to call from game code in None mode. Routed through the host. Refuses anything `Sandbox.BaseInventoryComponent.CanPickupWorldItem(Sandbox.BaseInventoryItem)` does. The usual add hooks apply, and the item becomes active when nothing else is. Override to change what a pickup does (ammo from duplicates, notices).

public void Pump()PUBLICPER-FRAME

Drives the active item's per-frame control hook. The inventory calls this itself every frame unless `Sandbox.BaseInventoryComponent.ManualPumping` is set, in which case you call it yourself. Only does anything on the client that owns the inventory - control is input, which is owner only.

public void Remove(Sandbox.BaseInventoryItem item)PUBLIC

Removes an item from the inventory and destroys it, then switches to the best remaining item. Routed through the host.

public void SetAmmo(Sandbox.BaseAmmoResource type, int amount)PUBLIC

Set the reserve ammo of the given type to an exact value (clamped to zero). Ignores the type's max - the escape hatch for game logic that wants to exceed it.

protected virtual bool ShouldAutoSwitchTo(Sandbox.BaseInventoryItem item)PROTECTEDVIRTUAL

Should picking this item up make it active? Base: `Sandbox.BaseInventoryComponent.AutoSwitchOnPickup` is on, the item is better (higher Value) than the active one, and it isn't avoided (an empty gun). The active item can still refuse the holster. Override for game policy.

public void Switch(Sandbox.BaseInventoryItem item, bool allowHolster = False)PUBLIC

Makes the given item active, holstering whatever was active. Pass null with `allowHolster` to holster everything. Routed through the host.

public void SwitchToBest()PUBLIC

Switches to the best available item (see `Sandbox.BaseInventoryComponent.GetBestItem`).

public int TakeAmmo(Sandbox.BaseAmmoResource type, int amount)PUBLIC

Take up to `amount` reserve ammo of the given type, returning how much was actually removed. The owning client spends locally and the spend is mirrored to the host, whose pool is the truth.

public bool Transfer(Sandbox.BaseInventoryItem item, Sandbox.BaseInventoryComponent to, int slot = -1)PUBLIC

Moves an item from this inventory into another - no world drop, no destroy. The usual gates get a say (`Sandbox.BaseInventoryComponent.OnRemoving(Sandbox.BaseInventoryItem)` here, `Sandbox.BaseInventoryComponent.OnAdding(Sandbox.BaseInventoryItem,System.Int32)` and the item's own say there); any refusal leaves everything as it was. Reserve ammo stays behind - the pool lives on the inventory, not the item. The destination doesn't auto-deploy (it may be a chest). Host only - who may move items between which inventories is game policy, so games route their own requests here. Returns whether the item moved.

public Sandbox.BaseInventoryItem Sandbox.BaseInventoryComponent.ActiveItem { get; set; }PUBLICGETSET

The item that is currently active (deployed), or null when nothing is held. Setting this is host authoritative - use `Sandbox.BaseInventoryComponent.Switch(Sandbox.BaseInventoryItem,System.Boolean)`.

public bool Sandbox.BaseInventoryComponent.AutoSwitchOnEmpty { get; set; }PUBLICGETSET

Switch away from the active item when it's spent (`Sandbox.BaseInventoryItem.ShouldAvoid`) and something that isn't is available - the classic arena-shooter auto-switch. Voluntary, so the item can still refuse the holster.

public bool Sandbox.BaseInventoryComponent.AutoSwitchOnPickup { get; set; }PUBLICGETSET

Switch to a picked up item when it's better than the active one (see `Sandbox.BaseInventoryComponent.ShouldAutoSwitchTo(Sandbox.BaseInventoryItem)`). Empty hands always deploy the pickup.

public Sandbox.BaseInventoryComponent.InventoryBehaviour Sandbox.BaseInventoryComponent.Behaviour { get; set; }PUBLICGETSET

How this inventory assigns its slots - exclusive hotbar slots or shared buckets.

public bool Sandbox.BaseInventoryComponent.GiveOnStart { get; set; }PUBLICGETSET

Grant the loadout automatically when the inventory starts. Turn off to decide when yourself (respawn logic, saved loadouts) and call `Sandbox.BaseInventoryComponent.GiveLoadout`.

public System.Collections.Generic.IEnumerable`1<Sandbox.BaseInventoryItem> Sandbox.BaseInventoryComponent.Items { get; set; }PUBLICGETSET

All items currently in the inventory, ordered by slot then `Sandbox.BaseInventoryItem.SlotOrder`. Includes disabled (inactive) items but not ones waiting to be destroyed - a removed item is gone immediately, even though its GameObject lives until the end of the frame. Items inside a nested inventory (a held backpack) belong to that inventory, not this one.

public bool Sandbox.BaseInventoryComponent.ManualPumping { get; set; }PUBLICGETSET

By default the inventory pumps the active item's control every frame in its own update. Turn this on to take over that timing yourself - the inventory will stop pumping and you call `Sandbox.BaseInventoryComponent.Pump` from wherever you want (e.g. alongside your player's own input handling).

public int Sandbox.BaseInventoryComponent.MaxSlots { get; set; }PUBLICGETSET

How many slots this inventory has. Items occupy slots 0..MaxSlots-1.

public Sandbox.BaseInventoryComponent.PickupBehaviour Sandbox.BaseInventoryComponent.PickupMode { get; set; }PUBLICGETSET

How this inventory takes items lying in the world - dropped, or placed in the scene.

public float Sandbox.BaseInventoryComponent.PickupRadius { get; set; }PUBLICGETSET

How close a world item has to be for Touch pickup, from the inventory's origin.

public System.Collections.Generic.List`1<Sandbox.BaseInventoryComponent.AmmoGrant> Sandbox.BaseInventoryComponent.StartingAmmo { get; set; }PUBLICGETSET

Reserve ammo granted by the loadout.

public System.Collections.Generic.List`1<Sandbox.GameObject> Sandbox.BaseInventoryComponent.StartingItems { get; set; }PUBLICGETSET

Item prefabs granted by the loadout, in order. Each needs a `Sandbox.BaseInventoryItem`.

public bool Sandbox.BaseInventoryComponent.UsesLoadout { get; set; }PUBLICGETSET

Does this inventory start with a loadout?