Server

You don't need to change functions like AddItem, RemoveItem, GetItemByName or etc in your other scripts, you can use qb's and esx's functions

OpenCraft

exports["tgiann-inventory"]:OpenCraft(src, categoryName)

Parameters

src: number player source id
categoryName: string category name in configCraft.lua

OpenInventoryById

exports["tgiann-inventory"]:OpenInventoryById(playerSrc, targetSrc, showClothe)

Parameters

playerSrc: number player source id
targetSrc: number target player source id
showClothe: boolean show the target's clothing inventory

ForceOpenInventoryById

Ignores config.searchPlayer settings when opening another player's inventory.

exports["tgiann-inventory"]:ForceOpenInventoryById(playerSrc, targetSrc, showClothe)

Parameters

playerSrc: number player source id
targetSrc: number target player source id
showClothe: boolean show the target's clothing inventory

OpenShop

exports["tgiann-inventory"]:OpenShop(src, shopName)

Parameters

src: number player source id
shopName: string products key name in configShop.lua

OpenInventory / ForceOpenInventory

ForceOpenInventory was added for those converting from Ox Inventory. It works the same as OpenInventory, but opens the inventory without considering values such as passwords.

exports["tgiann-inventory"]:OpenInventory(src, invType, invId, invData, openType)
exports["tgiann-inventory"]:ForceOpenInventory(src, invType, invId, invData, openType)

Parameters

src: number
invType: "glovebox" | "trunk" | "stash" | "shop" | "drop" | "crafting" | "otherplayer"
invId: "playerid" | "name" | "plate"
invData: { maxWeight: number, slots: number, whitelist: string[], blacklist: string[], label: string, maxAmount: Record<string, number>, jobs: string | string[], coords: vec3 | vec3[] }
openType: { isPlayer: boolean, password: string }

Examples

exports["tgiann-inventory"]:OpenInventory(source, "stash", "gang12", {
    maxWeight = 10000,
    slots = 10,
    whitelist = { "bandage", "item2" },
    label = "Gang Stash",
    maxAmount = { bandage = 5 },
    jobs = "police",
    coords = vector3(0.0, 100.0, 20.0)
}, {
    isPlayer = false,
    password = "1234"
})

exports["tgiann-inventory"]:OpenInventory(source, "stash", "gang12", {
    maxWeight = 10000,
    slots = 10,
    label = "Gang Stash",
})

exports["tgiann-inventory"]:OpenInventory(source, "otherplayer", otherSource)
exports["tgiann-inventory"]:OpenInventory(source, "trunk", "PLATE123")

RegisterStash

Method 1

exports["tgiann-inventory"]:RegisterStash(invId, label, slots, maxweight, owner, groups, coords, blacklist, whitelist)

Parameters

invId: string playerid | name | plate
label: string inventory label
slots: number slot amount
maxweight: number max weight
owner: boolean if true, the inventory is saved to the first player to open it
groups: boolean back compatibility for Ox Inventory (currently not used)
coords: vector3 stash coords
blacklist: table blacklisted items, e.g. {"bandage", "item2"}
whitelist: table whitelisted items, e.g. {"bandage", "item2"}

Method 2

exports["tgiann-inventory"]:RegisterStash(data)

data: { stashName: string, maxWeight?: number, slots?: number, whitelist?: string[], blacklist?: string[], label?: string, maxAmount?: Record<string, number>, jobs?: string | string[], coords?: vec3 | vec3[], password?: string, isPlayer?: boolean }

LoadInventory

PlayerData.items = exports["tgiann-inventory"]:LoadInventory(source)

Parameters

src: number player source id

Returns

table items

SaveInventory

exports["tgiann-inventory"]:SaveInventory(src)

Parameters

src: number player source id

SetInventory

exports["tgiann-inventory"]:SetInventory(src, items)

Parameters

src: number player source id
items: table player's new items

GetItemList / Items

Optionally takes the name of an item, returning only data for that item.

local allItems = exports["tgiann-inventory"]:GetItemList()
local allItems = exports["tgiann-inventory"]:Items()

local bandage = exports["tgiann-inventory"]:GetItemList("bandage")
local bandage = exports["tgiann-inventory"]:Items("bandage")

Parameters

itemName?: string if provided, only that item's data is returned
src?: number if itemName is provided and its label/description have multi-language support, they're resolved to the given player's language. Without src, the default language is used

Returns

table the item list, or a single item's data if itemName was provided

ItemsRaw

Same as GetItemList / Items, except if the label and description are defined with multi-language support, they are returned directly as an object instead of being resolved to a single string.

local allItems = exports["tgiann-inventory"]:ItemsRaw()
local bandage = exports["tgiann-inventory"]:ItemsRaw("bandage")

Parameters

itemName?: string if provided, only that item's data is returned

Returns

table the item list, or a single item's data if itemName was provided

GetItemLabel

local label = exports["tgiann-inventory"]:GetItemLabel("bandage")

Parameters

item: string item spawn name
src?: number if the item's label has multi-language support, it's resolved to the given player's language. Without src, the default language is used

Returns

string the item's label

GetItem

Returns generic item data from the specified inventory, with the total count.

exports["tgiann-inventory"]:GetItem(src, item, metadata, returnsAmount)

Parameters

src: number player source
item: string or table item name or item table
metadata?: table only returns the count of items strictly matching this metadata
returnsAmount?: boolean if true, returns a number instead of a table

Returns

number or table amount, or item data

GetPlayerItems

local src = source
local playerItems = exports["tgiann-inventory"]:GetPlayerItems(src)

Parameters

src: number player source

Returns

table player items

GetPlayerClotheItems

local src = source
local playerClotheItems = exports["tgiann-inventory"]:GetPlayerClotheItems(src)

Parameters

src: number player source

Returns

table player clothe items

GetTotalWeight

local items = {
    ["1"] = { item = "bandage", amount = 5 },
    ["4"] = { item = "arrow", amount = 2 },
}
local weight = exports["tgiann-inventory"]:GetTotalWeight(items)
return weight < 10

Parameters

items: table item list with amount

Returns

number weight

GetFreeWeight

local freeWeight = exports["tgiann-inventory"]:GetFreeWeight(src)
return freeWeight > 0

Parameters

src: number player source id

Returns

number free weight

GetSlotsByItem

Returns a table containing the slots where the item was found.

exports["tgiann-inventory"]:GetSlotsByItem(items, itemName)

Parameters

items: table the table containing the items
itemName: string the name of the item to search for

Returns

table slots by item

GetFirstSlotByItem

exports["tgiann-inventory"]:GetFirstSlotByItem(items, itemName)

Parameters

items: table the table of items to search through
itemName: string the name of the item to search for

Returns

number or nil the slot number of the first matching item, or nil if no match is found

SetItem

local src = source
local success = exports["tgiann-inventory"]:SetItem(src, "bandage", 15)
if success then
    print("item set success")
end

Parameters

source: number player source
item: string item spawn name
amount: number the amount of item to set

Returns

boolean success

AddItem

local src = source
local metadata = {
    level = 2
}
local success = exports["tgiann-inventory"]:AddItem(src, "bandage", 2, nil, metadata, false)
if success then
    print("item added")
end

Parameters

source: number player source
item: string item spawn name
amount: number the amount of item to add
slot?: number slot number
metadata?: table metadata of the item to add
isClotheSlot?: boolean adds the item to the clothing slots

Returns

boolean success

RemoveItem

local src = source
local itemData = exports["tgiann-inventory"]:GetItemByName(src, "bandage")
if itemData.amount > 0 then
    local success = exports["tgiann-inventory"]:RemoveItem(src, "bandage", 1, itemData.key)
    if success then
        print("item removed")
    end
end

Parameters

source: number player source
item: string item spawn name
amount: number the amount of item to remove
slot?: number slot number
metadata?: table item metadata value

Returns

boolean success

CloseInventory

Closes the player's inventory.

exports["tgiann-inventory"]:CloseInventory(source)

Parameters

source: number player source

CanCarryWeight

Returns whether the inventory can carry the specified weight, and the free inventory weight.

exports["tgiann-inventory"]:CanCarryWeight(source, weight)

Parameters

source: number player source
weight: number weight to check

Returns

boolean success

CanCarryItem / CanAddItem

local src = source
local canCarry = exports["tgiann-inventory"]:CanCarryItem(src, "bandage", 100)
if canCarry then
    exports["tgiann-inventory"]:AddItem(src, "bandage", 100)
end

Parameters

source: number player source
item: string item spawn name
amount: number the amount of item to check

Returns

boolean success

CanCarryItems

local src = source
local items = {
    { name = "bandage", amount = "3" },
    { name = "gold", amount = "1" },
}
local canCarry = exports["tgiann-inventory"]:CanCarryItems(src, items)
if canCarry then
    for i = 1, #items do
        exports["tgiann-inventory"]:AddItem(src, items[i].name, items[i].amount)
    end
end

Parameters

source: number player source
items: table items table

Returns

boolean success

ClearInventory

exports["tgiann-inventory"]:ClearInventory(source, filterItems)

Parameters

source: number player source
filterItems: nil | string | string[] item name(s) to clear. Omit to clear everything

GetItemByName

local src = source
local itemData = exports["tgiann-inventory"]:GetItemByName(src, "bandage")
if itemData.amount > 0 then
    exports["tgiann-inventory"]:RemoveItem(src, "bandage", itemData.amount)
end

Parameters

source: number player source
item: string item spawn name
metadata?: table item metadata value

Returns

table player item

GetItemsByName

local src = source
local items = exports["tgiann-inventory"]:GetItemsByName(src, "bandage")
for i = 1, #items do
    local itemData = items[i]
    exports["tgiann-inventory"]:RemoveItem(src, itemData.name, itemData.amount)
end

Parameters

source: number player source
name: string item name
metadata?: table item metadata value

Returns

table player items

GetItemBySlot

local src = source
local slot = 1
local itemData = exports["tgiann-inventory"]:GetItemBySlot(src, slot)
if itemData.amount > 0 then
    exports["tgiann-inventory"]:RemoveItem(src, itemData.name, itemData.amount)
end

Parameters

source: number player source
slot: number slot number
metadata?: table item metadata value

Returns

table player item

GetItemCount

Returns the total count of the specified items.

exports["tgiann-inventory"]:GetItemCount(source, items)

Parameters

source: number player source
items: table or string the item(s) to count

Returns

number or nil total count

HasItem

local src = source
local has1 = exports["tgiann-inventory"]:HasItem(src, "bandage", 2)
local has2 = exports["tgiann-inventory"]:HasItem(src, { "bandage", "armor" }, 2)

Parameters

src: number player source
items: table or string the item(s) to check — a string, an array of strings, or a key-value table of item name to amount
amount?: number the amount to check for. Only has effect when items is a string or an array of strings

Returns

boolean whether the player has the item(s)

RepairWeapon

local src = source
local playerItems = exports["tgiann-inventory"]:GetPlayerItems(src)
for slot, itemData in pairs(playerItems) do
    if itemData.name == "weapon_pistol" then
        exports["tgiann-inventory"]:RepairWeapon(src, slot, 100)
    end
end

Parameters

src: number player source
slot: number slot number
value?: number repair value, min 0, max 100

Returns

boolean success

CreateCustomStashWithItem

Creates a custom stash inventory pre-filled with items.

-- Server
local items = {
    { name = "bandage", amount = 2 },
    {
        name = "weapon_pistol",
        amount = 2,
        info = { ammo = 500 }
    },
}
exports["tgiann-inventory"]:CreateCustomStashWithItem("airdrop_1", items)

-- Client
TriggerServerEvent("tgiann-inventory:server:OpenInventory", "stash", "airdrop_1")

Parameters

stashUniqId: string stash name
items: table item list

GetItemByNameFromSecondaryInventory

Returns the data of the item in the stash.

local itemData = exports["tgiann-inventory"]:GetItemByNameFromSecondaryInventory("stash", "airdrop_01", "bandage")
return itemData.amount > 0

Parameters

invType: string stash, trunk or glovebox
invName: string inventory name, id or plate
item: string item spawn name
metadata?: table

Returns

table item data

GetSecondaryInventoryItems

Returns the data of the items in the stash.

local itemsData = exports["tgiann-inventory"]:GetSecondaryInventoryItems("stash", "airdrop_01")

Parameters

invType: string stash, trunk or glovebox
invName: string inventory name, id or plate

Returns

table items

RemoveItemFromSecondaryInventory

Removes an item from a stash.

local src = source
local stashId = "airdrop_01"
local itemData = exports["tgiann-inventory"]:GetItemByNameFromSecondaryInventory("stash", stashId, "bandage")
if itemData.amount > 0 then
    local success = exports["tgiann-inventory"]:RemoveItemFromSecondaryInventory("stash", stashId, "bandage", 1, itemData.slot)
    if success then
        print("item removed")
    end
end

Parameters

invType: string stash, trunk or glovebox
invName: string inventory name, id or plate
item: string item spawn name
amount: number the amount of item to remove
slot?: number slot number
metadata?: table

Returns

boolean success

AddItemToSecondaryInventory

Adds an item to a stash.

local stashId = "airdrop_01"
local success = exports["tgiann-inventory"]:AddItemToSecondaryInventory("stash", stashId, "bandage", 1)
if success then
    print("item added")
end

Parameters

invType: string stash, trunk or glovebox
invName: string inventory name, id or plate
item: string item spawn name
amount: number the amount of item to add
slot?: number slot number
metadata?: table

Returns

boolean success

UpdateItemMetadata / SetItemData

Updates the item's metadata.

local src = source
local itemData = exports["tgiann-inventory"]:GetItemByName(src, "weapon_pistol")
local newMetadata = { ammo = 200 }
exports["tgiann-inventory"]:UpdateItemMetadata(src, "weapon_pistol", itemData.slot, newMetadata)

Parameters

src: number player source
item: string item spawn name
slot: number slot number
metadata: table the item's new metadata

DeleteInventory

Deletes all data of the inventory.

exports["tgiann-inventory"]:DeleteInventory("stash", "airdrop_01")
exports["tgiann-inventory"]:DeleteInventory("glovebox", "TL001TL")

Parameters

invType: string trunk, glovebox or stash
invId: string inventory unique name or plate

GiveClotheItem

exports["tgiann-inventory"]:GiveClotheItem(src, model, itemName, data, isClotheSlot)

Parameters

src: number player source
model: number player model (joaat("mp_f_freemode_01") or joaat("mp_m_freemode_01"))
itemName: string clothe item — see valid values below
data: table clothes data — see structure below
isClotheSlot?: boolean adds the item directly to the clothing slot and equips it

Valid itemName values

c_mask — Mask (component 1)
c_helmet — Helmet / Hat (prop 0)
c_glasses — Glasses (prop 1)
c_watch — Watch (prop 6)
c_bracelet — Bracelet (prop 7)
c_bproof — Body Armor (component 9)
c_necklace — Necklace (component 7)
c_ear — Earring (prop 2)
c_torso — Torso: top (component 11), arms (component 3), undershirt (component 8)
c_bag — Bag (component 5)
c_pants — Pants (component 4)
c_shoes — Shoes (component 6)
c_decal — Decal (component 10)

Each element of data follows this structure:

local exampleDataEntry = {
    category = "component", -- "component" or "prop"
    id = 6,                 -- GTA component/prop ID
    data = {
        collection = "",    -- Collection name (often empty string, can be a DLC name)
        index = 1,           -- Drawable index
        texture = 0,         -- Texture / color ID
    }
}

Examples

-- Give shoes to the player inventory
exports["tgiann-inventory"]:GiveClotheItem(
    source,
    GetEntityModel(GetPlayerPed(source)),
    "c_shoes",
    {
        {
            category = "component",
            id = 6,
            data = { collection = "", index = 1, texture = 0 }
        }
    },
    false -- isClotheSlot: false = add to player inventory
)

-- Give pants and equip immediately
exports["tgiann-inventory"]:GiveClotheItem(
    source,
    GetEntityModel(GetPlayerPed(source)),
    "c_pants",
    {
        {
            category = "component",
            id = 4,
            data = { collection = "", index = 7, texture = 0 }
        }
    },
    true -- isClotheSlot: true = add to clothing slot & equip
)

-- Give a torso (up to 3 components: torso, arms, undershirt)
exports["tgiann-inventory"]:GiveClotheItem(
    source,
    GetEntityModel(GetPlayerPed(source)),
    "c_torso",
    {
        { category = "component", id = 11, data = { collection = "Male_freemode_valentines", index = 2, texture = 1 } }, -- Torso
        { category = "component", id = 3,  data = { collection = "", index = 0, texture = 0 } },                        -- Arms
        { category = "component", id = 8,  data = { collection = "", index = 15, texture = 0 } },                       -- Undershirt
    },
    true
)

-- Give a helmet (prop item)
exports["tgiann-inventory"]:GiveClotheItem(
    source,
    GetEntityModel(GetPlayerPed(source)),
    "c_helmet",
    {
        { category = "prop", id = 0, data = { collection = "", index = 45, texture = 0 } }
    },
    false
)

-- Give glasses (prop item) and equip
exports["tgiann-inventory"]:GiveClotheItem(
    source,
    GetEntityModel(GetPlayerPed(source)),
    "c_glasses",
    {
        { category = "prop", id = 1, data = { collection = "", index = 12, texture = 3 } }
    },
    true
)

-- Give a mask
exports["tgiann-inventory"]:GiveClotheItem(
    source,
    GetEntityModel(GetPlayerPed(source)),
    "c_mask",
    {
        { category = "component", id = 1, data = { collection = "", index = 35, texture = 0 } }
    },
    false
)

RegisterShop

local items = {
    { name = "beer",    price = 7,  amount = 50, type = "item" },
    { name = "whiskey", price = 10, amount = 50, type = "item" },
    { name = "vodka",   price = 12, amount = 50, type = "item" },
}
exports["tgiann-inventory"]:RegisterShop("policeshop2", items)

Parameters

shopName: string unique shop name
items: table item list

RegisterCraft

local items = {
    { name = "beer",    price = 7,  amount = 50, type = "item" },
    { name = "whiskey", price = 10, amount = 50, type = "item" },
    { name = "vodka",   price = 12, amount = 50, type = "item" },
}
exports["tgiann-inventory"]:RegisterCraft("policecraft", "Fake Police Crafting", items)

Parameters

category: string unique crafting category
label: string crafting menu label
items: table item list

RegisterJobCraft

local items = {
    { name = "beer",    price = 7,  amount = 50, type = "item" },
    { name = "whiskey", price = 10, amount = 50, type = "item" },
    { name = "vodka",   price = 12, amount = 50, type = "item" },
}
exports["tgiann-inventory"]:RegisterJobCraft("police", "Fake Police Crafting", items)

Parameters

jobName: string job name
label: string crafting menu label
items: table item list

RegisterGangCraft

local items = {
    { name = "beer",    price = 7,  amount = 50, type = "item" },
    { name = "whiskey", price = 10, amount = 50, type = "item" },
    { name = "vodka",   price = 12, amount = 50, type = "item" },
}
exports["tgiann-inventory"]:RegisterGangCraft("ballas", "Ballas Crafting", items)

Parameters

gangName: string gang name
label: string crafting menu label
items: table item list

SetMaxWeight

exports["tgiann-inventory"]:SetMaxWeight(src, maxWeight)

Parameters

src: number player source id
maxWeight: number new max weight value

Search

Searches the inventory for an item, or a list of items. The result varies based on the first argument.

local count = exports["tgiann-inventory"]:Search(source, "count", "bandage")
print("bandage count: " .. count)

local items = exports["tgiann-inventory"]:Search(source, "count", { "bandage", "medikit" })
if items then
    for name, count in pairs(items) do
        print(name .. " count: " .. count)
    end
end

local waterSlots = exports["tgiann-inventory"]:Search(source, "slots", "water")
print(json.encode(waterSlots))

Parameters

src: number player source id
search: string slots or count
item: string item name
metadata?: table item metadata to search for

UpdateVehicle

Updates the internal reference to vehicle stashes, without triggering a save or updating the database.

exports["tgiann-inventory"]:UpdateVehicle(oldPlate, newPlate)

Parameters

oldPlate: string
newPlate: string

SaveAllInventory

Saves all currently unsaved inventories to the database.

exports["tgiann-inventory"]:SaveAllInventory()

CustomDrop

Drops can be created from other resources, containing a variety of items and using a custom label.

exports["tgiann-inventory"]:CustomDrop("copyOX", {
    { "meat", 5, { grade = 2, type = "deer" } },
    { "hide", 5, { grade = 2, type = "deer" } }
}, vector3(250.5, 350.5, 10.0))

Parameters

prefix: string drop name
items: table items table
coords: vector3 drop coords
slots?: number drop slot amount
maxWeight?: number drop max weight
instance?: number or string bucket number

CreateDropFromPlayer

Creates a new drop with the contents of a player's inventory.

exports["tgiann-inventory"]:CreateDropFromPlayer(source)

Parameters

source: number player id

CreateDropFromPlayerId

Used to create drops from the inventory of offline players.

exports["tgiann-inventory"]:CreateDropFromPlayerId(citizenid, coords, instance)

Parameters

citizenid: string QB: citizenid, ESX: identifier
coords: vector3 drop location
instance?: number or string bucket number

PreviousExports NextClient

Last updated 3 months ago