RSG Framework

https://rsg.mintlify.app/
Admin
Official documentation for RSG Framework, a comprehensive Lua framework for RedM server development...
Tokens:172,275
Snippets:1,484
Trust Score:6.9
Update:4 months ago
Show doc for...
Tokens:
Raw
### Money System Configuration Example

Source: https://rsg.mintlify.app/essentials/money-system

Illustrates the configuration settings for the money system, including starting amounts, enabled money types, and limits. This snippet shows how to define initial player money and restrictions.

```lua
RSGConfig.Money = {
    -- Starting amounts for new players
    MoneyTypes = {
        cash = 50,
        bank = 0,            -- DEPRECATED
        valbank = 0,
        rhobank = 0,
        blkbank = 0,
        armbank = 0,
        bloodmoney = 0
    },

    -- Enable physical money items
    EnableMoneyItems = true,

    -- Money types that cannot go below 0
    DontAllowMinus = { 'cash', 'valbank', 'rhobank', 'blkbank', 'armbank', 'bloodmoney' },

    -- Minimum balance allowed (for types not in DontAllowMinus)
    MinusLimit = -5000,

    -- Paycheck settings
    PayCheckTimeOut = 30,        -- Minutes between paychecks
    PayCheckSociety = false      -- Deduct paychecks from society accounts
}
```

--------------------------------

### Starting a FiveM Resource

Source: https://rsg.mintlify.app/lua-reference/luabegining

Shows how to start a resource in FiveM, either by adding an 'ensure' line to server.cfg or by using an in-game console command.

```cfg
ensure my-first-script
```

```text
restart my-first-script
```

--------------------------------

### Example: Get and Check Player Reputation

Source: https://rsg.mintlify.app/essentials/reputation

Demonstrates fetching reputation for 'hunting' and 'fishing', printing the values, and checking if a player meets a required reputation threshold.

```lua
-- SERVER SIDE
local Player = RSGCore.Functions.GetPlayer(source)

-- Get hunting reputation
local huntingRep = Player.Functions.GetRep('hunting')
print('Player has '.. huntingRep ..' hunting reputation')

-- Check if player meets requirement
local requiredRep = 100
if Player.Functions.GetRep('fishing') >= requiredRep then
    print('Player is a master fisherman!')
end

-- Get non-existent reputation type
local unknownRep = Player.Functions.GetRep('nonexistent')
-- Returns: 0 (safe to use without checks)
```

--------------------------------

### Complete RSGCore:Client:OnPlayerLoaded Example

Source: https://rsg.mintlify.app/api-reference/endpoint/clienteventreference

A comprehensive example demonstrating the initialization of HUD, status update threads, welcome messages, and job-specific UI upon player load.

```lua
-- CLIENT SIDE
RegisterNetEvent('RSGCore:Client:OnPlayerLoaded', function()
    local PlayerData = RSGCore.Functions.GetPlayerData()

    -- Start HUD
    TriggerEvent('hud:client:LoadHud', PlayerData)

    -- Start status update thread
    CreateThread(function()
        while true do
            -- Update hunger/thirst display
            Wait(30000) -- Every 30 seconds
        end
    end)

    -- Show welcome message
    lib.notify({
        title = 'Welcome Back!',
        description = 'Hello, ' .. PlayerData.charinfo.firstname,
        type = 'success',
        duration = 5000
    })

    -- Job-specific initialization
    if PlayerData.job.name == 'police' then
        TriggerEvent('police:client:initPoliceJob')
    end
end)
```

--------------------------------

### Ace Permissions Example

Source: https://rsg.mintlify.app/essentials/configuration

An example of how to configure ace permissions in `server.cfg` to assign roles and grant access to commands.

```lua
# Example in server.cfg
add_ace rsgcore.god command allow
add_principal rsgcore.god group.admin
add_principal rsgcore.god rsgcore.admin
add_principal rsgcore.admin rsgcore.mod
```

--------------------------------

### Simple Client Prompt Example

Source: https://rsg.mintlify.app/essentials/prompts

Demonstrates how to create a client-side prompt that triggers a client event when interacted with. This example sets up a prompt for the Valentine General Store.

```lua
-- CLIENT SIDE
local RSGCore = exports['rsg-core']:GetCoreObject()

-- Create a prompt at Valentine General Store
exports['rsg-core']:createPrompt(
    'valentine_general_store',                    -- Unique location ID
    vector3(-322.5, 773.2, 116.2),               -- Store coordinates
    RSGCore.Shared.Keybinds['E'],                -- Press E to interact
    'Open General Store',                         -- Display text
    {
        type = 'client',                          -- Trigger client event
        event = 'store:client:openMenu',          -- Event name
        args = { storeId = 'valentine_general' }  -- Event arguments
    }
)
```

--------------------------------

### Shop System Example

Source: https://rsg.mintlify.app/inventory/functions

Example of a shop system server event that handles item purchases, including checking player money, inventory capacity, and processing the transaction.

```lua
RegisterNetEvent('shop:server:purchase', function(itemName, amount, price)
    local src = source
    local Player = RSGCore.Functions.GetPlayer(src)
    if not Player then return end

    local totalPrice = price * amount

    -- Check money
    if Player.Functions.GetMoney('cash') < totalPrice then
        lib.notify({ description = 'Not enough money!', type = 'error' })
        return
    end

    -- Check can add item
    local canAdd = exports['rsg-inventory']:CanAddItem(src, itemName, amount)
    if not canAdd then
        lib.notify({ description = 'Cannot carry that much!', type = 'error' })
        return
    end

    -- Process purchase
    if Player.Functions.RemoveMoney('cash', totalPrice, 'shop-purchase') then
        exports['rsg-inventory']:AddItem(src, itemName, amount, nil, nil, 'shop-purchase')
        lib.notify({ description = 'Purchased '.. amount ..'x '.. itemName, type = 'success' })
    end
end)
```

--------------------------------

### Lua Complete Payment Example (Server-Side)

Source: https://rsg.mintlify.app/lua-reference/patterns

A server-side example showing how to pay a player upon task completion. It adds cash and notifies the player of their earnings.

```lua
-- SERVER SIDE
RegisterNetEvent('job:server:completeTask', function()
    local src = source
    local Player = RSGCore.Functions.GetPlayer(src)
    if not Player then return end

    local payment = 150

    -- Pay player
    Player.Functions.AddMoney('cash', payment, 'task-completed')

    lib.notify(src, {
        description = 'Task completed! Earned $' .. payment,
        type = 'success'
    })
end)
```

--------------------------------

### Identity Card Example (Server-Side)

Source: https://rsg.mintlify.app/api-reference/endpoint/playerinformationreference

A complete server-side example demonstrating how to gather and send player identity card data to a specific client.

```lua
-- SERVER SIDE
RegisterNetEvent('identity:server:showCard', function(targetId)
    local src = source
    local Player = RSGCore.Functions.GetPlayer(src)
    local Target = RSGCore.Functions.GetPlayer(targetId)

    if not Player or not Target then return end

    local cardData = {
        name = Player.PlayerData.charinfo.firstname .. ' ' .. Player.PlayerData.charinfo.lastname,
        dob = Player.PlayerData.charinfo.birthdate,
        gender = Player.PlayerData.charinfo.gender == 0 and 'Male' or 'Female',
        nationality = Player.PlayerData.charinfo.nationality,
        citizenid = Player.PlayerData.citizenid
    }

    TriggerClientEvent('identity:client:showCard', targetId, cardData)
end)
```

--------------------------------

### Complete RSGCore:Client:OnPlayerUnload Example

Source: https://rsg.mintlify.app/api-reference/endpoint/clienteventreference

A comprehensive example demonstrating the cleanup of active threads, removal of player blips, hiding UI elements, and logging player unload.

```lua
-- CLIENT SIDE
local activeThreads = {}
local playerBlips = {}

RegisterNetEvent('RSGCore:Client:OnPlayerUnload', function()
    -- Stop all active threads
    for _, thread in pairs(activeThreads) do
        thread.active = false
    end
    activeThreads = {}

    -- Remove all player blips
    for _, blip in pairs(playerBlips) do
        if DoesBlipExist(blip) then
            RemoveBlip(blip)
        end
    end
    playerBlips = {}

    -- Clear UI
    SendNUIMessage({
        action = 'hideAll'
    })

    print('Player unloaded and cleaned up')
end)
```

--------------------------------

### Server Event Prompt Example

Source: https://rsg.mintlify.app/essentials/prompts

Illustrates creating a prompt that triggers a server event upon interaction. This example is for talking to a bank teller in Valentine.

```lua
-- CLIENT SIDE
exports['rsg-core']:createPrompt(
    'bank_valentine_teller',
    vector3(-312.8, 770.5, 117.1),
    RSGCore.Shared.Keybinds['E'],
    'Talk to Bank Teller',
    {
        type = 'server',
        event = 'bank:server:openAccount',
        args = { bankId = 'valentine' }
    }
)
```

--------------------------------

### Crafting System Example

Source: https://rsg.mintlify.app/inventory/functions

Example of a crafting system server event that checks for required items, verifies inventory space, and then removes ingredients and adds the crafted item.

```lua
RegisterNetEvent('crafting:server:craftItem', function(recipe)
    local src = source
    local Player = RSGCore.Functions.GetPlayer(src)
    if not Player then return end

    -- Check player has required items
    for _, ingredient in pairs(recipe.required) do
        if not exports['rsg-inventory']:HasItem(src, ingredient.item, ingredient.amount) then
            lib.notify({ description = 'Missing '.. ingredient.item, type = 'error' })
            return
        end
    end

    -- Check if player can add result
    local canAdd = exports['rsg-inventory']:CanAddItem(src, recipe.result, recipe.amount)
    if not canAdd then
        lib.notify({ description = 'Inventory full!', type = 'error' })
        return
    end

    -- Remove ingredients
    for _, ingredient in pairs(recipe.required) do
        exports['rsg-inventory']:RemoveItem(src, ingredient.item, ingredient.amount, nil, 'crafting')
    end

    -- Add result
    exports['rsg-inventory']:AddItem(src, recipe.result, recipe.amount, nil, nil, 'crafted')

    lib.notify({ description = 'Crafted '.. recipe.result, type = 'success' })
end)
```

--------------------------------

### Install MariaDB Server

Source: https://rsg.mintlify.app/essentials/linuxinstall

Installs the MariaDB database server package on your Linux system. Follow the on-screen prompts during installation.

```bash
sudo apt-get install mariadb-server
```

--------------------------------

### Update Player Inventory Space Example

Source: https://rsg.mintlify.app/essentials/configuration

An example demonstrating how to increase a player's inventory weight and slot capacity using `SetPlayerData`. This respects the system-wide maximums.

```lua
-- Example: Give player more inventory space
local Player = RSGCore.Functions.GetPlayer(source)
Player.Functions.SetPlayerData('weight', 50000)  -- Up to 50kg (still under 120kg max)
Player.Functions.SetPlayerData('slots', 35)       -- Up to 35 slots (still under 40 max)
```

--------------------------------

### Notification Examples by Type

Source: https://rsg.mintlify.app/api-reference/endpoint/oxlibreference

Demonstrates how to display different types of notifications (success, error, warning, info) using the `lib.notify` function. Each example shows a different `type` parameter.

```lua
-- Success
lib.notify({
    title = 'Item Purchased',
    description = 'You bought a canteen for $15',
    type = 'success'
})

-- Error
lib.notify({
    title = 'Purchase Failed',
    description = 'Not enough money',
    type = 'error'
})

-- Warning
lib.notify({
    title = 'Low Hunger',
    description = 'Your hunger is getting low',
    type = 'warning'
})

-- Info
lib.notify({
    title = 'Server Restart',
    description = 'Server will restart in 10 minutes',
    type = 'info'
})
```

--------------------------------

### Real Example: Client to Server Transaction

Source: https://rsg.mintlify.app/lua-reference/events

A practical example of a client triggering a server event for a banking transaction, including server-side logic for withdrawals and deposits.

```lua
-- CLIENT SIDE (rsg-banking)
TriggerServerEvent('rsg-banking:server:transact', type, amount)
```

```lua
-- SERVER SIDE (rsg-banking)
RegisterNetEvent('rsg-banking:server:transact', function(type, amount)
    local src = source
    local Player = RSGCore.Functions.GetPlayer(src)
    if not Player then return end

    if type == 1 then -- Withdraw
        local currentBank = Player.Functions.GetMoney('bank')
        if currentBank >= amount then
            Player.Functions.RemoveMoney('bank', amount, 'bank-withdraw')
            Player.Functions.AddMoney('cash', amount, 'bank-withdraw')
        end
    elseif type == 2 then -- Deposit
        local currentCash = Player.Functions.GetMoney('cash')
        if currentCash >= amount then
            Player.Functions.RemoveMoney('cash', amount, 'bank-deposit')
            Player.Functions.AddMoney('bank', amount, 'bank-deposit')
        end
    end
end)
```

--------------------------------

### Customize RSG Server Configuration

Source: https://rsg.mintlify.app/essentials/configuration

Provides a comprehensive example of customizing various RSG server settings. This includes adjusting player capacity, default spawn points, starting money, enabling/disabling features like whitelisting and PVP, and modifying player inventory limits.

```lua
-- Increase player capacity
RSGConfig.MaxPlayers = GetConvarInt('sv_maxclients', 64)

-- Change default spawn to Valentine
RSGConfig.DefaultSpawn = vector4(-175.89, 627.01, 114.09, 180.0)

-- Give players more starting money
RSGConfig.Money.MoneyTypes = {
    cash = 250,
    bank = 0,
    valbank = 500,
    rhobank = 0,
    blkbank = 0,
    armbank = 0,
    bloodmoney = 0
}

-- Enable whitelist
RSGConfig.Server.Whitelist = true
RSGConfig.Server.WhitelistPermission = 'whitelist'

-- Disable PVP for RP server
RSGConfig.Server.PVP = false
RSGConfig.EnablePVP = false

-- Faster paychecks
RSGConfig.Money.PayCheckTimeOut = 5

-- More inventory space
RSGConfig.Player.PlayerDefaults.weight = 50000
RSGConfig.Player.PlayerDefaults.slots = 30
```

--------------------------------

### Check iptables Installation

Source: https://rsg.mintlify.app/essentials/linuxinstall

Confirm if iptables, a firewall utility, is installed on your system. This is a prerequisite for opening network ports.

```bash
sudo iptables --version
```

--------------------------------

### Define Command Arguments with Help Text

Source: https://rsg.mintlify.app/essentials/commands

Sets up arguments for a command, providing names and helpful descriptions for each argument to guide users.

```lua
local arguments = {
    { name = 'id', help = 'Target player server ID (1-255)' },
    { name = 'amount', help = 'Dollar amount (max: 100000)' }
}
```

--------------------------------

### CheckItemDecay Example Usage (Lua)

Source: https://rsg.mintlify.app/inventory/item-decay

Provides a server-side example of using `CheckItemDecay` to update bread quality. It checks if the item was updated, logs the new quality, and handles item removal if it spoils completely.

```lua
-- SERVER SIDE
local Player = RSGCore.Functions.GetPlayer(source)
local breadItem = exports['rsg-inventory']:GetItemByName(source, 'bread')

if breadItem then
    local updated, quality, shouldDelete = Inventory.CheckItemDecay(breadItem)

    if updated then
        print('Bread quality updated to: '.. math.floor(quality) ..'%')

        if shouldDelete and quality <= 0 then
            print('Bread has spoiled and will be removed')
            exports['rsg-inventory']:RemoveItem(source, 'bread', 1, breadItem.slot, 'spoiled')
        end
    end
end
```

--------------------------------

### Tools & Equipment Item Example

Source: https://rsg.mintlify.app/essentials/shared

Example of defining tools and equipment, including properties like name, label, weight, image, and decay. Note that 'delete' is set to false for the pickaxe to keep broken tools.

```lua
['pickaxe'] = {
    name = 'pickaxe',
    label = 'Pickaxe',
    weight = 2000,
    type = 'item',
    image = 'tool_pickaxe.png',
    unique = false,
    useable = true,
    shouldClose = true,
    description = 'Mining pickaxe for extracting ore',
    decay = 10080,      -- 7 days
    delete = false      -- Keep broken tool
},

['lasso'] = {
    name = 'lasso',
    label = 'Lasso',
    weight = 500,
    type = 'item',
    image = 'tool_lasso.png',
    unique = false,
    useable = true,
    shouldClose = true,
    description = 'Rope lasso for catching animals or people'
},
```

--------------------------------

### Start and Stop a Monitoring Thread

Source: https://rsg.mintlify.app/lua-reference/threads

Provides a pattern for starting and stopping a background thread that monitors a condition. Uses a boolean flag to control the loop.

```lua
-- CLIENT SIDE
local activeThread = false

local function startMonitoring()
    if activeThread then return end
    activeThread = true

    CreateThread(function()
        while activeThread do
            -- Monitor something
            print('Monitoring...')
            Wait(1000)
        end
        print('Monitoring stopped')
    end)
end

local function stopMonitoring()
    activeThread = false
end

-- Usage
startMonitoring()
Wait(5000)
stopMonitoring()
```

--------------------------------

### Install OxLib in fxmanifest.lua

Source: https://rsg.mintlify.app/api-reference/endpoint/oxlibreference

Add this shared_script to your fxmanifest.lua to include the ox_lib library in your resource. Ensure it starts before dependent resources.

```lua
fx_version 'cerulean'
game 'rdr3'

shared_scripts {
    '@ox_lib/init.lua',
}

```

--------------------------------

### Client-Side Player Loaded Event

Source: https://rsg.mintlify.app/lua-reference/patterns

Example of getting the core RSG object on the client and waiting for the player to load before accessing player data.

```lua
-- CLIENT SIDE
local RSGCore = exports['rsg-core']:GetCoreObject()

-- Wait for player to load
RegisterNetEvent('RSGCore:Client:OnPlayerLoaded', function()
    local PlayerData = RSGCore.Functions.GetPlayerData()
    print('Player loaded:', PlayerData.charinfo.firstname)
end)
```

--------------------------------

### Get Item Metadata by Slot

Source: https://rsg.mintlify.app/inventory/metaitems

Server-side Lua example demonstrating how to retrieve an item from a specific inventory slot and access its name, amount, and metadata.

```lua
local item = exports['rsg-inventory']:GetItemBySlot(source, slotNumber)

if item then
    print('Item name:', item.name)
    print('Item amount:', item.amount)
    print('Item metadata:', json.encode(item.info))

    -- Access specific metadata
    local quality = item.info.quality
    local craftedBy = item.info.craftedBy
end
```

--------------------------------

### Define Starter Items for New Players

Source: https://rsg.mintlify.app/essentials/shared

Configure the initial items and their amounts given to new players. This can include currency if using money items.

```lua
RSGShared.StarterItems = {
    bread = { amount = 5, item = 'bread' },
    water = { amount = 5, item = 'water' },
}
```

```lua
-- Give different starter items
RSGShared.StarterItems = {
    bread = { amount = 10, item = 'bread' },
    water = { amount = 10, item = 'water' },
    bandage = { amount = 3, item = 'bandage' },
    dollar = { amount = 50, item = 'dollar' }  -- Starting cash if using money items
}
```

--------------------------------

### Get Item Metadata by Name

Source: https://rsg.mintlify.app/inventory/metaitems

Server-side Lua example showing how to find an item by its name in the inventory and access its specific metadata, such as 'money' for a 'money_clip' item.

```lua
local item = exports['rsg-inventory']:GetItemByName(source, 'money_clip')

if item then
    local moneyAmount = item.info.money or 0
    print('Money clip contains: $' .. moneyAmount)
end
```

--------------------------------

### Update System Packages

Source: https://rsg.mintlify.app/essentials/linuxinstall

Before installing new packages, it's recommended to update your system's package list. This ensures you get the latest available versions and security patches.

```bash
sudo apt-get update
```

--------------------------------

### Lua Client Script for Resource Initialization

Source: https://rsg.mintlify.app/lua-reference/luabegining

Example of a client-side Lua script that loads, prints a message, and listens for the player loaded event to display a welcome notification.

```lua
local RSGCore = exports['rsg-core']:GetCoreObject()

-- Code runs when resource starts
CreateThread(function()
    print('Client script loaded!')
end)

-- Listen for player spawn
AddEventHandler('RSGCore:Client:OnPlayerLoaded', function()
    print('Player loaded!')
    lib.notify({
        description = Config.WelcomeMessage,
        type = 'info'
    })
end)
```

--------------------------------

### Lua Thread Identifier Example

Source: https://rsg.mintlify.app/lua-reference/threads

Assigns a unique, random identifier to a thread for easier debugging. This helps in tracking the start and end of specific asynchronous operations within the game logs.

```lua
CreateThread(function()
    local threadId = 'MyThread-' .. math.random(1000, 9999)
    print('^2[THREAD START]^7', threadId)

    while true do
        -- Your code
        Wait(1000)
    end

    print('^1[THREAD END]^7', threadId)
end)
```

--------------------------------

### Get Duty Count for a Job

Source: https://rsg.mintlify.app/api-reference/endpoint/serverfunctionreference

Provides the number of players currently on duty for a specific job. This is a simpler alternative to GetPlayersOnDuty when only the count is needed. The example checks if the cop count is below a certain threshold.

```lua
function RSGCore.Functions.GetDutyCount(job)
    local count = 0
    for _, Player in pairs(RSGCore.Players) do
        if Player.PlayerData.job.name == job then
            if Player.PlayerData.job.onduty then
                count += 1
            end
        end
    end
    return count
end

-- Example

local copCount = RSGCore.Functions.GetDutyCount('vallaw')
if copCount < 2 then
    print('Not enough cops online!')
end
```

--------------------------------

### Get Player by License

Source: https://rsg.mintlify.app/api-reference/endpoint/serverfunctionreference

Fetches player data by their license identifier. This function prioritizes checking online players before querying the database. The example demonstrates printing the player's name if found.

```lua
function RSGCore.Functions.GetPlayerByLicense(license)
    return RSGCore.Player.GetPlayerByLicense(license)
end

-- Example

local license = 'license:1234567890abcdef'
local Player = RSGCore.Functions.GetPlayerByLicense(license)
if Player then
    print(Player.PlayerData.name)
end
```

--------------------------------

### Get All Player Items and Access Metadata

Source: https://rsg.mintlify.app/inventory/metaitems

Server-side Lua example iterating through all items in a player's inventory to find specific items (e.g., 'signed_document') and access their metadata like 'signedBy' and 'signedDate'.

```lua
local Player = RSGCore.Functions.GetPlayer(source)
if not Player then return end

for slot, item in pairs(Player.PlayerData.items) do
    if item and item.name == 'signed_document' then
        print('Document signed by:', item.info.signedBy)
        print('Document date:', item.info.signedDate)
    end
end
```

--------------------------------

### Get Player by Account Number

Source: https://rsg.mintlify.app/api-reference/endpoint/serverfunctionreference

Retrieves a player object based on their account number. This function iterates through all currently connected players. The example shows how to print the player's citizen ID if found.

```lua
function RSGCore.Functions.GetPlayerByAccount(account)
    for src in pairs(RSGCore.Players) do
        if RSGCore.Players[src].PlayerData.charinfo.account == account then
            return RSGCore.Players[src]
        end
    end
    return nil
end

-- Example

local Player = RSGCore.Functions.GetPlayerByAccount('US04RSG1234567890')
if Player then
    print(Player.PlayerData.citizenid)
end
```

--------------------------------

### Get Closest Player

Source: https://rsg.mintlify.app/api-reference/endpoint/serverfunctionreference

Finds the player closest to a given source player or specific coordinates. It returns the server ID of the closest player and the distance to them. The example checks if a player is found and within a certain distance.

```lua
function RSGCore.Functions.GetClosestPlayer(source, coords)
    -- Returns closestPlayer (server id), closestDistance
end

-- Example

local closestPlayer, distance = RSGCore.Functions.GetClosestPlayer(source)
if closestPlayer ~= -1 and distance < 3.0 then
    print('Player '.. closestPlayer ..' is '.. distance ..' units away')
end
```

--------------------------------

### Registering a Test Command

Source: https://rsg.mintlify.app/essentials/commands

Demonstrates how to register a basic command with arguments and a callback function. This command is accessible to all users.

```lua
local arguments = {
    { name = 'arg 1', help = 'This will give helpful hints on what arg is for' },
    { name = 'arg 2', help = 'This will give helpful hints on what arg is for' }
}

local argsRequired = true -- if this is true the command won't work without args entered

RSGCore.Commands.Add('test', 'Trigger a test command', arguments, argsRequired, function(source)
    print('Congrats, you made a test command that anyone can trigger!')
end, 'user')
```

--------------------------------

### Get Offline Player Data by Citizen ID

Source: https://rsg.mintlify.app/api-reference/endpoint/serverfunctionreference

Retrieves offline player data directly from the database using their citizen ID. This is useful for accessing historical player information. The example shows how to print the player's first name if found.

```lua
function RSGCore.Functions.GetOfflinePlayerByCitizenId(citizenid)
    return RSGCore.Player.GetOfflinePlayer(citizenid)
end

-- Example

local OfflinePlayer = RSGCore.Functions.GetOfflinePlayerByCitizenId('ABC12345')
if OfflinePlayer then
    print(OfflinePlayer.PlayerData.charinfo.firstname)
end
```

--------------------------------

### Get Players On Duty for a Job

Source: https://rsg.mintlify.app/api-reference/endpoint/serverfunctionreference

Returns a list of server IDs for all players currently on duty for a specified job, along with the total count. This is useful for managing job-specific resources or responses. The example prints the count and then iterates through the list of player source IDs.

```lua
function RSGCore.Functions.GetPlayersOnDuty(job)
    local players = {}
    local count = 0
    for src, Player in pairs(RSGCore.Players) do
        if Player.PlayerData.job.name == job then
            if Player.PlayerData.job.onduty then
                players[#players + 1] = src
                count += 1
            end
        end
    end
    return players, count
end

-- Example

local cops, copCount = RSGCore.Functions.GetPlayersOnDuty('vallaw')
print('There are '.. copCount ..' cops on duty')
for i = 1, #cops do
    print('Cop source: '.. cops[i])
end
```

--------------------------------

### Run FiveM Server with run.sh

Source: https://rsg.mintlify.app/essentials/linuxinstall

Execute the run.sh script to start the FiveM server. This command should be run from the directory containing the extracted artifacts and the run.sh file, preferably within a screen session.

```bash
./run.sh
```

--------------------------------

### Get Player by Character Info Property

Source: https://rsg.mintlify.app/api-reference/endpoint/serverfunctionreference

Finds a player by matching a specific character info property (e.g., 'firstname', 'lastname') with a given value. This allows for flexible player lookups. The example demonstrates finding a player by their first name and printing their last name.

```lua
function RSGCore.Functions.GetPlayerByCharInfo(property, value)
    for src in pairs(RSGCore.Players) do
        local charinfo = RSGCore.Players[src].PlayerData.charinfo
        if charinfo[property] ~= nil and charinfo[property] == value then
            return RSGCore.Players[src]
        end
    end
    return nil
end

-- Example

-- Find player by first name
local Player = RSGCore.Functions.GetPlayerByCharInfo('firstname', 'John')
if Player then
    print(Player.PlayerData.charinfo.lastname)
end
```

--------------------------------

### Setup Dynamic Job Prompts

Source: https://rsg.mintlify.app/essentials/prompts

Dynamically sets up prompts based on the player's current job. It clears existing prompts before creating new ones relevant to the job.

```lua
-- CLIENT SIDE
local RSGCore = exports['rsg-core']:GetCoreObject()
local jobPrompts = {}

-- Create prompts based on player's job
local function SetupJobPrompts()
    -- Clear existing prompts
    for _, handle in ipairs(jobPrompts) do
        exports['rsg-core']:deletePrompt(handle)
    end
    jobPrompts = {}

    local PlayerData = RSGCore.Functions.GetPlayerData()
    local jobName = PlayerData.job.name

    if jobName == 'vallaw' then
        -- Law enforcement prompts
        local handle = exports['rsg-core']:createPrompt(
            'sheriff_office_valentine',
            vector3(-275.5, 807.8, 118.6),
            RSGCore.Shared.Keybinds['E'],
            'Access Sheriff Office',
            {
                type = 'client',
                event = 'police:client:openOffice',
                args = { office = 'valentine' }
            }
        )
        table.insert(jobPrompts, handle)

    elseif jobName == 'valmedic' then
        -- Medic prompts
        local handle = exports['rsg-core']:createPrompt(
            'doctor_office_valentine',
            vector3(-290.3, 810.2, 118.3),
            RSGCore.Shared.Keybinds['E'],
            'Access Medical Supplies',
            {
                type = 'client',
                event = 'medic:client:openSupplies',
                args = { office = 'valentine' }
            }
        )
        table.insert(jobPrompts, handle)
    end
end

-- Update prompts when job changes
RegisterNetEvent('RSGCore:Client:OnJobUpdate', function(job)
    SetupJobPrompts()
end)

-- Setup on login
RegisterNetEvent('RSGCore:Client:OnPlayerLoaded', function()
    SetupJobPrompts()
end)
```

--------------------------------

### Purchase Item with Server Callback

Source: https://rsg.mintlify.app/essentials/callbacks

Handles item purchases by checking inventory space, removing money, and adding the item. Includes refund logic if item addition fails.

```lua
-- SERVER
RSGCore.Functions.CreateCallback('rsg-shop:server:purchaseItem', function(source, cb, itemName, amount, price)
    local src = source
    local Player = RSGCore.Functions.GetPlayer(src)

    if not Player then
        cb({ success = false, message = 'Player not found' })
        return
    end

    local totalPrice = price * amount

    -- Check if player has enough money
    if Player.Functions.GetMoney('cash') < totalPrice then
        cb({ success = false, message = 'Not enough money' })
        return
    end

    -- Check if player has inventory space
    if not exports['rsg-inventory']:CanAddItem(src, itemName, amount) then
        cb({ success = false, message = 'Not enough inventory space' })
        return
    end

    -- Remove money
    if not Player.Functions.RemoveMoney('cash', totalPrice, 'shop-purchase') then
        cb({ success = false, message = 'Failed to remove money' })
        return
    end

    -- Add item
    if exports['rsg-inventory']:AddItem(src, itemName, amount, nil, nil, 'shop-purchase') then
        cb({ success = true, message = 'Purchase successful' })
    else
        -- Refund money if item add fails
        Player.Functions.AddMoney('cash', totalPrice, 'shop-refund')
        cb({ success = false, message = 'Failed to add item' })
    end
end)
```

```lua
-- CLIENT
local itemName = 'bread'
local amount = 3
local pricePerUnit = 5

RSGCore.Functions.TriggerCallback('rsg-shop:server:purchaseItem', function(result)
    if result.success then
        lib.notify({ title = 'Shop', description = result.message, type = 'success' })
    else
        lib.notify({ title = 'Shop', description = result.message, type = 'error' })
    end
end, itemName, amount, pricePerUnit)
```

--------------------------------

### Create Simple Meta Item

Source: https://rsg.mintlify.app/inventory/metaitems

Provides a server-side example of creating a 'bread' item with custom metadata including quality, crafter name, and craft date using the AddItem function.

```lua
-- SERVER SIDE
local src = source
local Player = RSGCore.Functions.GetPlayer(src)
if not Player then return end

local info = {
    quality = 100,
    craftedBy = GetPlayerName(src),
    craftDate = os.date('%Y-%m-%d %H:%M:%S')
}

exports['rsg-inventory']:AddItem(src, 'bread', 1, nil, info, 'crafted-by-player')

lib.notify(src, {
    description = 'You crafted fresh bread!',
    type = 'success'
})
```

--------------------------------

### Creating a Server Callback

Source: https://rsg.mintlify.app/api-reference/endpoint/servereventreference

Demonstrates the proper server-side method for creating a callback function that clients can trigger. It includes fetching player data and returning a value via the callback.

```lua
-- SERVER SIDE - Create callback
RSGCore.Functions.CreateCallback('myCallback', function(source, cb, arg1)
    local Player = RSGCore.Functions.GetPlayer(source)
    if not Player then
        cb(nil)
        return
    end

    cb(Player.PlayerData.money.cash)
end)
```

--------------------------------

### Lua fxmanifest.lua Configuration

Source: https://rsg.mintlify.app/lua-reference/luabegining

Example of an fxmanifest.lua file for a FiveM resource, specifying game version, description, and script file paths for client, server, and shared scripts.

```lua
fx_version 'cerulean'
game 'rdr3'
rdr3_warning 'I acknowledge that this is a prerelease build of RedM, and I am aware my resources *will* become incompatible once RedM ships.'

description 'My First Script'
version '1.0.0'

client_scripts {
    'client/client.lua'
}

server_scripts {
    'server/server.lua'
}

shared_scripts {
    'shared/config.lua'
}
```

--------------------------------

### Download Artifacts with wget

Source: https://rsg.mintlify.app/essentials/linuxinstall

Use wget to download the FiveM artifact archive from a provided URL. Ensure you replace the example URL with the direct link to the desired artifact version.

```bash
wget https://runtime.fivem.net/artifacts/fivem/build_proot_linux/master/5742-ded89bc6acf29a720a7686a1de70d28b62c75af8/fx.tar.xz
```

--------------------------------

### Basic Progress Bar Example

Source: https://rsg.mintlify.app/api-reference/endpoint/oxlibreference

Display a progress bar for an action with a specified duration, label, and cancellation options. Handles completion or cancellation notifications.

```lua
if lib.progressBar({
    duration = 5000,
    label = 'Cooking meal...', 
    useWhileDead = false,
    canCancel = true,
    disable = {
        move = true,
        car = true,
        combat = true
    },
}) then
    -- Action completed
    lib.notify({ description = 'Meal cooked!', type = 'success' })
else
    -- Action cancelled
    lib.notify({ description = 'Cooking cancelled', type = 'error' })
end
```

--------------------------------

### Multiple Prompts Creation

Source: https://rsg.mintlify.app/essentials/prompts

Shows how to efficiently create multiple prompts by iterating over a table of store data. Each store gets its own prompt linked to a client event.

```lua
-- CLIENT SIDE
local storeLocations = {
    {
        id = 'valentine_general',
        coords = vector3(-322.5, 773.2, 116.2),
        label = 'Valentine General Store'
    },
    {
        id = 'rhodes_general',
        coords = vector3(1295.3, -1293.7, 76.9),
        label = 'Rhodes General Store'
    },
    {
        id = 'strawberry_general',
        coords = vector3(-1776.5, -396.8, 159.7),
        label = 'Strawberry General Store'
    }
}

-- Create prompts for all stores
for _, store in ipairs(storeLocations) do
    exports['rsg-core']:createPrompt(
        store.id,
        store.coords,
        RSGCore.Shared.Keybinds['E'],
        'Open ' .. store.label,
        {
            type = 'client',
            event = 'store:client:openMenu',
            args = { storeId = store.id }
        }
    )
end
```

--------------------------------

### Triggering a Server Callback from Client

Source: https://rsg.mintlify.app/api-reference/endpoint/servereventreference

Shows how a client can trigger a server-side callback and receive a response. This example demonstrates passing an argument and handling the returned data.

```lua
-- CLIENT SIDE - Trigger callback
RSGCore.Functions.TriggerCallback('myCallback', function(cashAmount)
    print('Player has $' .. cashAmount)
end, someArgument)
```

--------------------------------

### Example: NPC Shopkeeper with ox_target

Source: https://rsg.mintlify.app/api-reference/endpoint/oxtargetreference

Demonstrates creating an NPC with multiple interaction options using ox_target. Includes browsing goods and selling items, with conditional visibility for selling.

```lua
CreateThread(function()
    -- Create NPC
    local model = `U_M_M_VALTHESKINNER_01`
    lib.requestModel(model, 5000)

    local coords = vector3(-324.28, 803.50, 117.88)
    local npc = CreatePed(model, coords.x, coords.y, coords.z, 90.0, false, false, false, false)

    SetEntityCanBeDamaged(npc, false)
    SetEntityInvincible(npc, true)
    FreezeEntityPosition(npc, true)
    SetBlockingOfNonTemporaryEvents(npc, true)

    -- Add targeting
    exports.ox_target:addEntity(npc, {
        {
            label = 'Browse Goods',
            icon = 'fa-solid fa-shopping-basket',
            distance = 2.5,
            onSelect = function()
                TriggerServerEvent('shop:server:open', 'general')
            end
        },
        {
            label = 'Sell Items',
            icon = 'fa-solid fa-dollar-sign',
            distance = 2.5,
            canInteract = function()
                -- Only show if player has items to sell
                return exports['rsg-inventory']:GetItemCount(source, {'meat', 'pelt'}) > 0
            end,
            onSelect = function()
                TriggerEvent('shop:client:sellMenu')
            end
        }
    })
end)
```

--------------------------------

### Accessing Inventory Items (Server-Side)

Source: https://rsg.mintlify.app/api-reference/endpoint/playerinformationreference

Provides examples for iterating through all inventory items, checking for specific items, and counting item quantities on the server.

```lua
-- SERVER SIDE
local Player = RSGCore.Functions.GetPlayer(source)
if not Player then return end

-- Get all items
for slot, item in pairs(Player.PlayerData.items) do
    print('Slot', slot, ':', item.amount, 'x', item.label)
end

-- Check if has specific item
local hasBread = exports['rsg-inventory']:HasItem(source, 'bread', 5)

if hasBread then
    print('Player has at least 5 bread')
end

-- Get item count
local breadCount = exports['rsg-inventory']:GetItemCount(source, 'bread')
print('Player has', breadCount, 'bread')
```

--------------------------------

### Weapon Degradation Calculation Example

Source: https://rsg.mintlify.app/inventory/weapons

An example illustrating how weapon quality is calculated based on the configured degradation rate and the number of shots fired. This calculation is typically performed on the server.

```lua
-- Example degradation calculation
local shotCount = 10                      -- Player fired 10 shots
local degradation = Config.DegradeRate * shotCount  -- 0.01 * 10 = 0.1
local currentQuality = 95.5               -- Current weapon quality
local newQuality = currentQuality - degradation     -- 95.5 - 0.1 = 95.4
```

--------------------------------

### Infinite Loop Example

Source: https://rsg.mintlify.app/lua-reference/threads

Demonstrates how to create a thread that runs continuously using a `while true` loop. The loop prints a message and waits for one second before repeating.

```lua
CreateThread(function()
    while true do
        -- This runs continuously
        print('Still running...')
        Wait(1000)
    end
end)
```

--------------------------------

### Show a Context Menu

Source: https://rsg.mintlify.app/api-reference/endpoint/oxlibreference

Display a previously registered context menu to the player using lib.showContext.

```lua
lib.showContext('example_menu')

```

--------------------------------

### Consumable Food Item Example

Source: https://rsg.mintlify.app/essentials/shared

Example of defining a consumable food item, specifying properties like name, label, weight, image, and decay time. This is used for items that can be consumed.

```lua
['bread'] = {
    name = 'bread',
    label = 'Bread',
    weight = 100,
    type = 'item',
    image = 'consumable_bread_roll.png',
    unique = false,
    useable = true,
    shouldClose = true,
    description = 'Fresh baked bread',
    decay = 300,        -- 5 hours
    delete = true
},

['cooked_meat'] = {
    name = 'cooked_meat',
    label = 'Cooked Meat',
    weight = 400,
    type = 'item',
    image = 'consumable_meat_cooked.png',
    unique = false,
    useable = true,
    shouldClose = true,
    description = 'Perfectly cooked meat',
    decay = 480,        -- 8 hours
    delete = true
},
```

--------------------------------

### OxLib Localization Setup

Source: https://rsg.mintlify.app/api-reference/endpoint/oxlibreference

Configure ox_lib for localization by adding it to fxmanifest.lua and creating locale JSON files. Use lib.locale() to retrieve translated strings.

```lua
ox_lib 'locale'

files {
    'locales/*.json',
}
```

```json
{
    "horse_name": "Horse Name",
    "horse_desc": "Enter a name for your horse",
    "purchase_success": "Purchase successful!",
    "not_enough_money": "You don't have enough money"
}
```

```lua
lib.notify({
    title = lib.locale('purchase_success'),
    description = lib.locale('not_enough_money'),
    type = 'error'
})
```

--------------------------------

### RSGCore.Functions.GetPlayers

Source: https://rsg.mintlify.app/api-reference/endpoint/serverfunctionreference

Get a list of all connected player server IDs.

```APIDOC
## RSGCore.Functions.GetPlayers

### Description
Get all players. Returns the server ids of all players.

### Returns
- **table** - An array of player server IDs.

### Example
```lua
local Players = RSGCore.Functions.GetPlayers()
print(RSGCore.Debug(Players))
```
```

--------------------------------

### Defining Functions in Lua

Source: https://rsg.mintlify.app/lua-reference/luabegining

Demonstrates how to define basic functions, functions with return values, and functions with multiple return values in Lua.

```lua
-- Basic function
local function greet(name)
    print('Hello, ' .. name .. '!')
end

greet('Arthur') -- Output: Hello, Arthur!

-- Function with return value
local function add(a, b)
    return a + b
end

local sum = add(5, 3) -- sum = 8

-- Function with multiple return values
local function getCoords()
    return 100.0, 200.0, 30.0
end

local x, y, z = getCoords()
```
Tokens:
Raw