> For the complete documentation index, see [llms.txt](https://kazescripts.gitbook.io/kazescripts/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://kazescripts.gitbook.io/kazescripts/kaze_inventory/server-exports.md). # Server Exports Server exports for items, slots, inventories, stashes, drops, shops and hooks. The common inventory export names and arguments are supported, so scripts made for other inventories work after you point their exports at `kaze_inventory`. An inventory (`inv`) can be given as: * a player server id (`source`) * a stash name (`'police_locker'`) or stash id (`'stash:police_locker'`) * a per-player stash: `{ id = 'personal_locker', owner = 'citizenid' }` * a temporary stash id (`'temp:5'`) * an inventory id (`'trunk:ABC123'`, `'glovebox:ABC123'`, a drop id) Weights are in grams. ## Items ### Items ```lua exports.kaze_inventory:Items(name?) ``` Item data for one item, or every item keyed by name. ```lua local water = exports.kaze_inventory:Items('water') print(water.label, water.weight, water.stack) ``` ### ItemList ```lua exports.kaze_inventory:ItemList() ``` Every item keyed by name. ```lua for name, item in pairs(exports.kaze_inventory:ItemList()) do print(name, item.label) end ``` ### AddItem ```lua exports.kaze_inventory:AddItem(inv, item, count?, metadata?, slot?, cb?) ``` Returns `success, response`. `response` is the list of touched slots, or a reason: `invalid_item`, `invalid_inventory`, `inventory_full`. ```lua local ok, reason = exports.kaze_inventory:AddItem(source, 'water', 2) exports.kaze_inventory:AddItem(source, 'WEAPON_PISTOL', 1, { components = { 'at_flashlight' } }) ``` ### RemoveItem ```lua exports.kaze_inventory:RemoveItem(inv, item, count?, metadata?, slot?, ignoreTotal?, strict?) ``` Returns `true` or `false`. With `ignoreTotal`, removes as many as there are when there are fewer than `count`. ```lua if exports.kaze_inventory:RemoveItem(source, 'lockpick', 1) then print('Used') end ``` ### SetItem ```lua exports.kaze_inventory:SetItem(inv, item, count) ``` Sets the total amount of an item, adding or removing the difference. ```lua exports.kaze_inventory:SetItem(source, 'money', 500) ``` ### CanCarryItem ```lua exports.kaze_inventory:CanCarryItem(inv, item, count?, metadata?) ``` Returns `true` when the item fits by weight and slots. ```lua if exports.kaze_inventory:CanCarryItem(source, 'burger', 5) then exports.kaze_inventory:AddItem(source, 'burger', 5) end ``` ### CanCarryWeight ```lua exports.kaze_inventory:CanCarryWeight(inv, weight) ``` Returns `true` when the extra weight fits. ```lua local fits = exports.kaze_inventory:CanCarryWeight(source, 2500) ``` ### GetItemCount ```lua exports.kaze_inventory:GetItemCount(inv, item, metadata?) ``` Total count of an item. `0` when there is none. ```lua local cash = exports.kaze_inventory:GetItemCount(source, 'money') ``` ### GetItem ```lua exports.kaze_inventory:GetItem(inv, item, metadata?, returnsCount?) ``` Item data with a `count` field. With `returnsCount`, only the count. ```lua local item = exports.kaze_inventory:GetItem(source, 'water') print(item.label, item.count) ``` ### Search ```lua exports.kaze_inventory:Search(inv, search, item, metadata?) ``` `search` is `'count'` or `'slots'`. `item` is one name or a list of names. A list returns a table keyed by item name. ```lua local counts = exports.kaze_inventory:Search(source, 'count', { 'water', 'burger' }) local slots = exports.kaze_inventory:Search(source, 'slots', 'WEAPON_PISTOL') ``` ## Slots and metadata A slot is returned as `{ slot, name, count, metadata, label, weight, stack, close }`. ### GetSlot ```lua exports.kaze_inventory:GetSlot(inv, slot) ``` The item in one slot, or `nil`. ```lua local item = exports.kaze_inventory:GetSlot(source, 1) ``` ### GetSlotWithItem ```lua exports.kaze_inventory:GetSlotWithItem(inv, item, metadata?) ``` The first slot holding the item. ```lua local card = exports.kaze_inventory:GetSlotWithItem(source, 'id_card') ``` ### GetSlotIdWithItem ```lua exports.kaze_inventory:GetSlotIdWithItem(inv, item, metadata?) ``` The first slot number holding the item. ```lua local slot = exports.kaze_inventory:GetSlotIdWithItem(source, 'phone') ``` ### GetSlotsWithItem ```lua exports.kaze_inventory:GetSlotsWithItem(inv, item, metadata?) ``` Every slot holding the item. ```lua for _, s in ipairs(exports.kaze_inventory:GetSlotsWithItem(source, 'WEAPON_PISTOL')) do print(s.slot, s.metadata.serial) end ``` ### GetSlotIdsWithItem ```lua exports.kaze_inventory:GetSlotIdsWithItem(inv, item, metadata?) ``` Every slot number holding the item. ```lua local slots = exports.kaze_inventory:GetSlotIdsWithItem(source, 'water') ``` ### GetEmptySlot ```lua exports.kaze_inventory:GetEmptySlot(inv) ``` The first free slot number, or `nil` when full. ```lua local free = exports.kaze_inventory:GetEmptySlot(source) ``` ### SetMetadata ```lua exports.kaze_inventory:SetMetadata(inv, slot, metadata) ``` Replaces the metadata of the item in a slot. ```lua local slot = exports.kaze_inventory:GetSlotWithItem(source, 'id_card') slot.metadata.description = 'Expires 2027' exports.kaze_inventory:SetMetadata(source, slot.slot, slot.metadata) ``` ### SetDurability ```lua exports.kaze_inventory:SetDurability(inv, slot, durability) ``` Sets durability from `0` to `100`. ```lua exports.kaze_inventory:SetDurability(source, 3, 50) ``` ## Inventories ### GetInventory ```lua exports.kaze_inventory:GetInventory(inv) ``` Returns `{ id, label, type, slots, weight, maxWeight, owner, items }`. `Inventory(inv)` is the same. ```lua local inv = exports.kaze_inventory:GetInventory(source) print(inv.weight .. ' / ' .. inv.maxWeight) ``` ### GetInventoryItems ```lua exports.kaze_inventory:GetInventoryItems(inv) ``` Items keyed by slot. Gear comes after the pocket slots. ```lua for slot, item in pairs(exports.kaze_inventory:GetInventoryItems(source)) do print(slot, item.name, item.count) end ``` ### GetInventoryWeight ```lua exports.kaze_inventory:GetInventoryWeight(inv) ``` Current weight in grams. ```lua local weight = exports.kaze_inventory:GetInventoryWeight('trunk:ABC123') ``` ### SetMaxWeight ```lua exports.kaze_inventory:SetMaxWeight(inv, weight) ``` Changes the max weight. ```lua exports.kaze_inventory:SetMaxWeight(source, 50000) ``` ### SetSlotCount ```lua exports.kaze_inventory:SetSlotCount(inv, slots) ``` Changes the number of slots. ```lua exports.kaze_inventory:SetSlotCount(source, 50) ``` ### ClearInventory ```lua exports.kaze_inventory:ClearInventory(inv, keep?) ``` Removes every item. `keep` is an item name or a list of names to keep. ```lua exports.kaze_inventory:ClearInventory(source, { 'phone', 'id_card' }) ``` ### GetContainerFromSlot ```lua exports.kaze_inventory:GetContainerFromSlot(inv, slot) ``` The inventory id of a container item, such as a wallet or bag. ```lua local id = exports.kaze_inventory:GetContainerFromSlot(source, 4) exports.kaze_inventory:AddItem(id, 'money', 100) ``` ### GetCurrentWeapon ```lua exports.kaze_inventory:GetCurrentWeapon(source) ``` The weapon in the player's hand as `{ slot, name, metadata, count }`, or `nil`. ```lua local weapon = exports.kaze_inventory:GetCurrentWeapon(source) if weapon then print(weapon.name, weapon.metadata.serial) end ``` ### RegisterUsable ```lua exports.kaze_inventory:RegisterUsable(name, fn) ``` Runs `fn(source, item)` when a player uses the item. ```lua exports.kaze_inventory:RegisterUsable('repairkit', function(source, item) exports.kaze_inventory:RemoveItem(source, 'repairkit', 1, nil, item.slot) end) ``` ## Stashes ### RegisterStash ```lua exports.kaze_inventory:RegisterStash(name, label, slots, maxWeight, owner?, groups?, coords?) ``` `owner = true` gives every player their own copy, `owner = 'citizenid'` makes one private stash, `groups` limits it to jobs. ```lua exports.kaze_inventory:RegisterStash('police_locker', 'Police Locker', 50, 100000, false, { police = 0 }) ``` ### OpenStash ```lua exports.kaze_inventory:OpenStash(source, name, owner?) ``` Opens a stash for a player from anywhere. ```lua exports.kaze_inventory:OpenStash(source, 'police_locker') ``` ### PlaceStash ```lua exports.kaze_inventory:PlaceStash(name, { coords, prop?, blip? }) ``` Puts a registered stash in the world with a target, an optional prop and blip. ```lua exports.kaze_inventory:PlaceStash('police_locker', { coords = vec4(461.4, -998.3, 30.7, 90.0), prop = 'prop_ld_int_safe_01', blip = { id = 587, colour = 3 }, }) ``` ### GetStash ```lua exports.kaze_inventory:GetStash(name, owner?) ``` Returns `{ id, label, slots, maxWeight, weight, owner, items }`. ```lua local stash = exports.kaze_inventory:GetStash('police_locker') ``` ### GetStashes ```lua exports.kaze_inventory:GetStashes() ``` Every registered stash as `{ [name] = label }`. ```lua for name, label in pairs(exports.kaze_inventory:GetStashes()) do print(name, label) end ``` ### ClearStash ```lua exports.kaze_inventory:ClearStash(name, owner?) ``` Removes every item from a stash. ```lua exports.kaze_inventory:ClearStash('evidence', 'citizenid') ``` ### RemoveStash ```lua exports.kaze_inventory:RemoveStash(name) ``` Unregisters a stash and removes it from the world. ```lua exports.kaze_inventory:RemoveStash('police_locker') ``` ### CreateTemporaryStash ```lua exports.kaze_inventory:CreateTemporaryStash(props) ``` Kept in memory only, never saved. Returns its id. | Field | | | ----------------------------- | --------------------------------------------------- | | `label`, `slots`, `maxWeight` | Name and size | | `items` | `{ { 'name', count, metadata? } }` | | `id` | Fixed id (`temp:`) | | `owner` | Source, identifier or a list. Others cannot open it | | `groups` | Job lock | | `coords`, `reach` | Must be this close to open it | | `lifetime` | Seconds before it is removed | | `removeWhenEmpty` | Removed when the last item is taken | | `onRemove` | `function(id, items)` | ```lua local id = exports.kaze_inventory:CreateTemporaryStash({ label = 'Evidence bag', slots = 10, maxWeight = 10000, owner = source, lifetime = 600 }) exports.kaze_inventory:forceOpenInventory(source, 'stash', id) ``` ### RemoveTemporaryStash ```lua exports.kaze_inventory:RemoveTemporaryStash(id) ``` Removes a temporary stash and its items. ```lua exports.kaze_inventory:RemoveTemporaryStash(id) ``` ### GetTemporaryStashes ```lua exports.kaze_inventory:GetTemporaryStashes() ``` Every temporary stash as `{ [id] = { label, expires, items } }`. ```lua for id, stash in pairs(exports.kaze_inventory:GetTemporaryStashes()) do print(id, stash.label) end ``` ## Opening inventories ### forceOpenInventory ```lua exports.kaze_inventory:forceOpenInventory(source, type, data) ``` Opens `player`, `stash`, `drop` or any inventory id for a player, with no distance check. ```lua exports.kaze_inventory:forceOpenInventory(source, 'player', targetId) exports.kaze_inventory:forceOpenInventory(source, 'stash', { id = 'personal_locker', owner = 'citizenid' }) ``` ## Drops ### CustomDrop ```lua exports.kaze_inventory:CustomDrop(prefix, items, coords, slots?, maxWeight?, instance?, model?) ``` Creates a ground drop and returns its id. ```lua exports.kaze_inventory:CustomDrop('Loot', { { 'water', 2 }, { 'WEAPON_PISTOL', 1, { serial = 'LOOT01' } }, }, vec3(200.0, -900.0, 30.0)) ``` ### CreateDropFromPlayer ```lua exports.kaze_inventory:CreateDropFromPlayer(source) ``` Moves the player's pockets into a drop at their feet. Returns the drop id. ```lua local dropId = exports.kaze_inventory:CreateDropFromPlayer(source) ``` ## Police ### ConfiscateInventory ```lua exports.kaze_inventory:ConfiscateInventory(source) ``` Moves the player's pockets into a saved confiscation stash. ```lua exports.kaze_inventory:ConfiscateInventory(targetId) ``` ### ReturnInventory ```lua exports.kaze_inventory:ReturnInventory(source) ``` Gives confiscated items back. ```lua exports.kaze_inventory:ReturnInventory(targetId) ``` ## Vehicles ### UpdateVehicle ```lua exports.kaze_inventory:UpdateVehicle(oldPlate, newPlate) ``` Moves the trunk and glovebox to a new plate. ```lua exports.kaze_inventory:UpdateVehicle('ABC123', 'KAZE01') ``` ## Shops ### RegisterShop ```lua exports.kaze_inventory:RegisterShop(id, data) ``` `count` limits stock. `currency` is `'money'` (default), `'bank'` or an item name. `license` and `grade` limit who may buy. ```lua exports.kaze_inventory:RegisterShop('gunstore', { name = 'Gun Store', inventory = { { name = 'WEAPON_PISTOL', price = 2500, license = 'weapon' }, { name = 'ammo-9', price = 5, count = 500 }, { name = 'armour', price = 1500, currency = 'bank' }, }, locations = { vec4(22.0, -1105.6, 29.8, 160.0) }, blip = { id = 110, colour = 1, scale = 0.75 }, ped = { model = 's_m_y_ammucity_01', scenario = 'WORLD_HUMAN_CLIPBOARD' }, }) ``` ### OpenShop ```lua exports.kaze_inventory:OpenShop(source, id) ``` Opens a shop for a player wherever they are. ```lua exports.kaze_inventory:OpenShop(source, 'gunstore') ``` ### GetShop ```lua exports.kaze_inventory:GetShop(id) ``` Returns `{ id, label, items, locations, groups, blip, ped }`. ```lua local shop = exports.kaze_inventory:GetShop('gunstore') ``` ### GetShops ```lua exports.kaze_inventory:GetShops() ``` Every shop as `{ [id] = label }`. ```lua for id, label in pairs(exports.kaze_inventory:GetShops()) do print(id, label) end ``` ### SetShopItems ```lua exports.kaze_inventory:SetShopItems(id, inventory) ``` Replaces what a shop sells. ```lua exports.kaze_inventory:SetShopItems('gunstore', { { name = 'WEAPON_KNIFE', price = 300 }, }) ``` ### SetShopPrice ```lua exports.kaze_inventory:SetShopPrice(id, item, price) ``` Changes one item's price. ```lua exports.kaze_inventory:SetShopPrice('gunstore', 'WEAPON_PISTOL', 3000) ``` ### SetShopStock ```lua exports.kaze_inventory:SetShopStock(id, item, count) ``` Sets stock. `nil` removes the stock limit. ```lua exports.kaze_inventory:SetShopStock('gunstore', 'ammo-9', 1000) ``` ### AddShopStock ```lua exports.kaze_inventory:AddShopStock(id, item, count) ``` Adds to the stock and returns the new amount. ```lua local stock = exports.kaze_inventory:AddShopStock('gunstore', 'ammo-9', 250) ``` ### RemoveShop ```lua exports.kaze_inventory:RemoveShop(id) ``` Removes a shop for everyone. ```lua exports.kaze_inventory:RemoveShop('gunstore') ``` ## Hooks ### registerHook ```lua exports.kaze_inventory:registerHook(event, fn, options?) ``` Returns a hook id. Return `false` to cancel. Options: `inventoryFilter` (Lua patterns for inventory ids) and `itemFilter` (`{ name = true }`). | Event | Payload | Can cancel | | --------------- | --------------------------------------------------------------------------------------------- | -------------------------------------- | | `openInventory` | `source, inventoryId, inventoryType` | yes | | `swapItems` | `source, fromInventory, toInventory, fromType, toType, fromSlot, toSlot, count, item, action` | yes | | `createItem` | `inventoryId, item, count, metadata` | no, return a table to replace metadata | | `usingItem` | `source, inventoryId, item` | yes | | `usedItem` | `source, inventoryId, item` | no | | `buyItem` | `source, shopType, itemName, count, totalPrice, currency` | no | | `craftItem` | `source, benchId, recipe, itemName, toInventory, count` | yes | | `giveItem` | `source, target, item, count` | yes | ```lua exports.kaze_inventory:registerHook('swapItems', function(p) if p.toType == 'stash' then return false end end, { itemFilter = { WEAPON_RPG = true } }) ``` ### removeHooks ```lua exports.kaze_inventory:removeHooks(id?) ``` Removes one hook, or every hook of the calling resource. ```lua local hook = exports.kaze_inventory:registerHook('openInventory', function() end) exports.kaze_inventory:removeHooks(hook) ```