ESX: Legacy

https://docs.esx-legacy.com/en
Admin
ESX: Legacy is a premier, open-source, and community-driven framework for FiveM servers, designed to...
Tokens:62,409
Snippets:382
Trust Score:4.5
Update:11 months ago
Show doc for...
Tokens:
Raw
### Client-side Command Example in Lua

Source: https://docs.esx-legacy.com/en/tutorial/developing

An example of registering a client-side command in Lua for FiveM using `RegisterCommand`. This script demonstrates checking player load status and printing a configuration value. It highlights that client-side commands are not accessible from the server console.

```lua
-- Using the native from fivem since ESX.RegisterCommand doesn't exist on the clientside
-- This command won't exist on the serverside, so you won't be able to use it in the console.
RegisterCommand('clientTest', function (source, args, rawCommand)
  print(Config.cool)
  if ESX.IsPlayerLoaded() then
    print("Player has already loaded")
  else
    print("Player is not loaded")
  end
end, false)

```

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

### Starting Inventory Items Configuration

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/config/main

Specifies the items and quantities players receive in their inventory upon character creation. Can be set to 'false' to grant no starting items, or a table listing items and their counts.

```lua
StartingInventoryItems = {
    bread = 2, -- Give the player 2 bread buns
    water = 4 -- Give the player 4 water bottles
}
```

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

### ESX Menu Example Implementation - Lua

Source: https://docs.esx-legacy.com/en/esx_core/esx_menu_default

Provides a complete example of how to define menu elements, locales, and then open a menu using ESX.UI.Menu.Open. It demonstrates creating selectable elements, a slider element, and handling both selection and cancellation logic within the respective callback functions.

```lua
    local Elements = {
        {label = "I`m An Element", name = "element1"},
        {label = "Bread - £200", name = "bread", value = 1, type = 'slider', min = 1,max = 100},
        {label = '<span style="color:green;">HEY! IM GREEN!/span>', name = "geen_element"}
      }
 
    local Locales = {
      backspace = "Back",
      select = "Select"
    }
 
      ESX.UI.Menu.Open("default", GetCurrentResourceName(), "Example_Menu", {
        title = "Example Menu", -- The Name of Menu to show to users,
        align    = 'top-left', -- top-left | top-right | bottom-left | bottom-right | center | 
        elements = Elements, -- define elements as the pre-created table
        locales = Locales -- define optional button locales as the pre-created table
      }, function(data,menu) -- OnSelect Function
        ---	for a simple element
        if data.current.name == "element1" then
          print("Element 1 Selected")
          menu.close()
        end
 
        -- for slider elements
 
        if data.current.name == "bread" then
          print(data.current.value)
 
          if data.current.value == 69 then
            print("Nice!")
            menu.close()
          end
        end
      end, function(data, menu) -- Cancel Function
        print("Closing Menu")
        menu.close() -- close menu
      end)
```

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

### Server-side Command Example in Lua with ESX

Source: https://docs.esx-legacy.com/en/tutorial/developing

An example of registering a server-side command using ESX's `RegisterCommand` function in Lua. This script shows how to access player information (name and job) and configuration values. It includes a help description for the command.

```lua
-- Command introduced by ESX to register commands more easily
-- For more information see the accoring docs for ESX.RegisterCommand
ESX.RegisterCommand('test', 'user', function(xPlayer, args, showError)
  print(xPlayer.getName() .. " has the job " .. xPlayer.job.label)
  print(Config.cool)
end, true, {help = 'My cool test command!'})

```

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

### Lua Example Function Signature Annotation

Source: https://docs.esx-legacy.com/en/tutorial/coding_practices/annotations

Provides a practical example of annotating a Lua function signature. This function `addNumbers` takes two numbers and returns their sum, with clear annotations for parameters and the return value, demonstrating effective code documentation.

```lua
--- Add two numbers together
---@param num1 number The first number
---@param num2 number The second number
---@return number sum result of both numbers
function addNumbers(num1, num2)
    -- Calculate the sum of num1 and num2
    local sum = num1 + num2
 
    -- Return the sum
    return sum
end

addNumbers(5, 10) -- Returns 15
```

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

### Get Licenses List (Callback)

Source: https://docs.esx-legacy.com/en/esx_addons/esx_license

Retrieves a list of all available license types within the system. Returns a table of license types.

```APIDOC
## Get Licenses List (Callback)

### Description
Retrieves a list of all available license types configured in the system.

### Method
`TriggerEvent` (Client-side or Server-side to Server-side)

### Event Name
`esx_license:getLicensesList`

### Parameters
- **cb** (function) - Callback function that receives a table containing all available license types.

### Request Example
```lua
TriggerEvent('esx_license:getLicensesList', function(licensesList)
  print('Available licenses:', json.encode(licensesList))
end)
```
```

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

### Get Licenses List Event for ESX (Callback)

Source: https://docs.esx-legacy.com/en/esx_addons/esx_license

Fetches a list of all available license types. It uses a callback function to return the list of licenses.

```Lua
TriggerEvent('esx_license:getLicensesList', cb)
```

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

### Get Licenses (Callback)

Source: https://docs.esx-legacy.com/en/esx_addons/esx_license

Retrieves all licenses associated with a specific player. Returns a table of licenses.

```APIDOC
## Get Licenses (Callback)

### Description
Retrieves all licenses for a given player.

### Method
`TriggerEvent` (Client-side or Server-side to Server-side)

### Event Name
`esx_license:getLicenses`

### Parameters
- **target** (number) - The server ID of the player whose licenses to retrieve.
- **cb** (function) - Callback function that receives a table containing the player's licenses.

### Request Example
```lua
TriggerEvent('esx_license:getLicenses', targetPlayerId, function(licenses)
  print('Player licenses:', json.encode(licenses))
end)
```
```

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

### Lua Infinite Loop Example (Avoid)

Source: https://docs.esx-legacy.com/en/tutorial/coding_practices

An example of an infinite loop in Lua that should be avoided. This pattern can lead to server crashes due to excessive resource consumption without proper Wait conditions.

```lua
CreateThread(function()
    while true do
        Wait(0)
        if ESX.PlayerData.job.name == 'police' then
            if IsControlJustPressed(0, 38) then
                -- Do something
            end
        end
    end
end)
```

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

### Get All Licenses Event for ESX (Callback)

Source: https://docs.esx-legacy.com/en/esx_addons/esx_license

Retrieves all licenses associated with a target player. It takes the target player identifier and a callback function that returns a table of licenses.

```Lua
TriggerEvent('esx_license:getLicenses', target, cb)
```

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

### fxmanifest.lua for FiveM Script

Source: https://docs.esx-legacy.com/en/tutorial/developing

An example of an `fxmanifest.lua` file required for FiveM scripts. It specifies the script's metadata, game version, Lua version, shared, client, and server scripts, along with ESX imports and dependencies.

```lua
-- This file is always required for a fivem script

fx_version 'cerulean'
game 'gta5'

description 'My really cool script'
author 'My name'

lua54 'yes' -- Not always needed, needed for functions that require Lua 5.4

-- Files that should be loaded on both server and client.
-- DO NOT LOAD CONFIGS/FILES CONTAINING SENSITIVE DATA LIKE API KEYS AND WEBHOOKS HERE.
shared_scripts {
    'config.lua' -- Not needed but suggested to not hardcode everything.
}

client_scripts {
  'client.lua',
}

server_scripts {
  'server.lua',
}

shared_scripts {
  '@es_extended/imports.lua', -- Import ESX functions and PlayerData
  '@es_extended/locale.lua', -- Import the Locale system
}

dependencies {
  'es_extended' -- Ensure the script starts after es_extended so that the functions work.
}

```

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

### ESX Legacy: Melee Weapon Configuration Example (Lua)

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/config/weapon

Demonstrates the structure for defining a melee weapon in the ESX Legacy configuration. Includes weapon name, label, and an empty components table.

```lua
{
    name = 'WEAPON_KNIFE',
    label = "Knife",
    components = {}
}
```

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

### Lua Example Class Annotation - ExtendedPlayer

Source: https://docs.esx-legacy.com/en/tutorial/coding_practices/annotations

Illustrates an annotated Lua class definition for `ExtendedPlayer`. This example details various player-related fields like `accounts`, `coords`, `group`, `inventory`, and `job`, along with a function `getCoords` with parameter and return type annotations.

```lua
---@class ExtendedPlayer
---@field accounts table<string, table> The accounts of the player
---@field coords vector3 The last known position of the Player
---@field group string The current permission group of the player
---@field identifier string The players Rockstar Identifier(has char index with multichar in the front, example: char1:[identifier])
---@field inventory table The players inventory
---@field job table The players job and grade
---@field loadout table The current weapons of the player
---@field name string Returns the name of the FiveM name or consists out of the "firstname lastname" when ESX identity installed.
---@field playerId number The playerId/source of a player
---@field source number The playerId/source of a player
---@field variables table
---@field weight number Current player weight
---@field maxWeight number The max weight a player can handle
---@field metadata table Saved metadata
---@field license string Player license
ExtendedPlayer = {}

--Returns the player's current coordinates on the server. The optional boolean useVector argument is for returning a vector3 type. 
--Keep in mind that the coords sync interval can be adjusted in the configuration file in case you want to get precise player coords.
---@param useVector? boolean Returns an vector3 type if set to true, and normally a table with x, y and z pairs
---@return vector3|{x: number, y: number, z: number} coords
function ExtendedPlayer.getCoords(useVector)
    return coords
end
```

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

### Starting Account Money Configuration

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/config/main

Sets the initial amount of money players receive in their various accounts upon character creation. Supports default accounts like 'bank' and 'money', as well as custom accounts defined elsewhere.

```lua
StartingAccountMoney = {
    bank = 50000, -- Give the player 50 Thousand on his bank account
    money = 1500, -- Give the player 1500 cash.
    black_money = 500, -- Give the player 500 Black money,
 
    -- This can also be done with custom accounts:
    bitcoin = 3.5 -- Give the player 3.5 bitcoins
}
```

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

### Get Player Playtime

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/server/xplayer

Retrieves the total playtime of a player in seconds. The example shows how to convert this playtime into a more readable format of days, hours, and minutes.

```lua
local xPlayer = ESX.GetPlayerFromId(playerId)

local playtime = xPlayer.getPlayTime()
local days = math.floor(playtime / 86400)
local hours = math.floor((playtime % 86400) / 3600)
local minutes = math.floor((playtime % 3600) / 60)
print(("Playtime: ^5%s^0 Days | ^5%s^0 Hours | ^5%s^0 Minutes"):format(days, hours, minutes))
```

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

### Configuration Object Example in Lua

Source: https://docs.esx-legacy.com/en/tutorial/developing

A basic Lua code snippet defining a global `Config` object. This object is used to store configuration variables, such as a string message, which can be accessed throughout the script.

```lua
Config = {
    cool = "This is very cool"
}

```

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

### Get ESX Garages Export

Source: https://docs.esx-legacy.com/en/esx_addons/esx_garage

Retrieves the table of configured garages from the esx_garage script. This export is useful for dynamically accessing garage information within your FiveM server.

```lua
local garages = exports['esx_garage']:getGarages()
```

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

### Get Player Accounts (Lua)

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/server/xplayer

Retrieves all of the player's accounts, optionally in a minimal format (only balances). Returns a table containing account details or just balances.

```lua
local xPlayer = ESX.GetPlayerFromId(playerId)
local accounts = xPlayer.getAccounts()

print("Player has " .. accounts.bank.money .. " in their " .. accounts.bank.name .. " account.")
```

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

### Get License (Callback)

Source: https://docs.esx-legacy.com/en/esx_addons/esx_license

Triggers an event to check if a player possesses a specific license. Returns a boolean indicating possession.

```APIDOC
## Get License (Callback)

### Description
Checks if a player has a specific license.

### Method
`TriggerEvent` (Client-side or Server-side to Server-side)

### Event Name
`esx_license:getLicense`

### Parameters
- **licenseType** (string) - The type of license to check for (e.g., 'drive_bike').
- **cb** (function) - Callback function that receives a boolean indicating if the player has the license.

### Request Example
```lua
TriggerEvent('esx_license:getLicense', 'drive_bike', function(hasLicense)
  if hasLicense then
    print('Player has the drive_bike license.')
  else
    print('Player does not have the drive_bike license.')
  end
end)
```
```

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

### DMV School Configuration Example (Lua)

Source: https://docs.esx-legacy.com/en/esx_addons/esx_dmvschool

This snippet demonstrates the structure for configuring zones within the esx_dmvschool script. It specifies the position, size, color, and type for a marker zone. This configuration is crucial for defining interactive areas within the game world.

```lua
Config.Zones = {
	ZoneName = {
		Pos   = {x = 239.471, y = -1380.960, z = 32.741},
		Size  = {x = 1.5, y = 1.5, z = 1.0},
		Color = {r = 204, g = 204, b = 0},
		Type  = 1
	},
}
```

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

### Get All Usable Items in ESX Legacy

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/server/functions

Returns a table listing all items that have been registered as usable. The keys of the table are the item names, and the values are booleans indicating whether the item is usable. This helps in iterating through and checking item usability.

```lua
local usableItems = ESX.GetUsableItems()

for item, usable in pairs(usableItems) do
    if usable then
        print("Item " .. item .. " is usable")
    else
        print("Item " .. item .. " is not usable")
    end
end
```

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

### ESX Impound Configuration Structure

Source: https://docs.esx-legacy.com/en/esx_addons/esx_garage

Defines the structure for configuring impound lots within the esx_garage script. This includes setting the get out point, spawn point, sprite, scale, color, and cost for each impound location.

```lua
Config.Impounds = {
    ImpoundName = {
        GetOutPoint = {x = 0.0, y = 0.0, z = 0.0},
        SpawnPoint = {x = 0.0, y = 0.0, z = 0.0, heading = 0.0},
        Sprite = 357,
        Scale = 0.8,
        Colour = 3,
        Cost = 3000,
    }
}
```

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

### Get Player Height - Lua

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/playerdata

Retrieves and prints the player character's height. Server-side examples use ESX.GetPlayerFromId, and client-side examples use ESX.PlayerData.

```lua
-- Server-side example
local xPlayer = ESX.GetPlayerFromId(source)
print("The character's height is: " .. xPlayer.height)
```

```lua
-- Client-side example
print("The character's height is: " .. ESX.PlayerData.height)
```

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

### Lua Controlled Loop with Wait and Conditional Exit

Source: https://docs.esx-legacy.com/en/tutorial/coding_practices

A recommended pattern for implementing loops in Lua, ensuring a 'Wait' function is included to prevent server crashes. This example demonstrates a loop that continues only while a specific condition is met, making it safer.

```lua
AddEventHandler('esx:setJob', function(job)
    if job.name == 'police' then
        startPoliceThread()
    end
end)

local function startPoliceThread()
    CreateThread(function()
        while ESX.PlayerData.job.name == 'police' do
            Wait(0)
            if IsControlJustPressed(0, 38) then
                -- Do something
            end
        end
    end)
end

if ESX.PlayerData.job.name == 'police' then
    startPoliceThread()
end
```

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

### Get Player First Name - Lua

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/playerdata

Retrieves and prints the player character's first name. Server-side examples use ESX.GetPlayerFromId, while client-side examples use ESX.PlayerData.

```lua
-- Server-side example
local xPlayer = ESX.GetPlayerFromId(source)
print("The character is called: " .. xPlayer.firstName)
```

```lua
-- Client-side example
print("The character is called: " .. ESX.PlayerData.firstName)
```

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

### ESX Legacy Weapon Shop Configuration Example (Lua)

Source: https://docs.esx-legacy.com/en/esx_addons/esx_weaponshop

This snippet demonstrates the configuration structure for the esx_weaponshop addon, specifically for defining weapon shop zones. It includes settings for legal status, blip appearance, items available for purchase, and their locations.

```lua
Config.Zones = {
    ShopName = {
        Legal = true, -- Legal or illegal shop
        Blip = {
            Enabled = true,
			Sprite = 110,
			Color = 81,
			Display = 4,
			Scale = 0.7,
			ShortRange = true
        },
        Items = {
            { name = 'WEAPON_PISTOL', price = 500 },
        },
        Locations = {
            vector3(-662.1, -935.3, 20.8),
        }
    }
}
```

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

### Get Player Name - Lua

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/playerdata

Retrieves and prints the player's name. The server-side example uses ESX.GetPlayerFromId to find the player, while the client-side example accesses ESX.PlayerData directly.

```lua
-- Server-side example
local xPlayer = ESX.GetPlayerFromId(source)
print("The player is called: " .. xPlayer.name)
```

```lua
-- Client-side example
print("The player is called: " .. ESX.PlayerData.name)
```

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

### Get Player ID (Source) - Lua

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/playerdata

Retrieves and prints the player's server ID, also known as the source. The server-side example uses ESX.GetPlayerFromId, while the client-side example accesses ESX.PlayerData.

```lua
-- Server-side example
local xPlayer = ESX.GetPlayerFromId(source)
print("The player's server id/source': " .. xPlayer.playerId)
```

```lua
-- Client-side example
print("The player's server id/source': " .. ESX.PlayerData.playerId)
```

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

### Get Player Rockstar License - Lua

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/playerdata

Retrieves and prints the player's Rockstar Games identifier (license). Examples are provided for both server-side (using ESX.GetPlayerFromId) and client-side (using ESX.PlayerData).

```lua
-- Server-side example
local xPlayer = ESX.GetPlayerFromId(source)
print("The player's license is: " .. xPlayer.license)
```

```lua
-- Client-side example
print("The player's license is: " .. ESX.PlayerData.license)
```

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

### ESX Legacy: Gun Weapon Configuration Example (Lua)

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/config/weapon

Illustrates the configuration for a firearm in ESX Legacy, including name, label, ammo details (label and hash), tint configuration, and a list of available weapon components with their respective names, labels, and hashes.

```lua
{
    name = 'WEAPON_APPISTOL',
    label = "AP Pistol",
    ammo = {
        label = 'round(s)',
        hash = `AMMO_PISTOL`
    },
    tints = Config.DefaultWeaponTints,
    components = {
        { name = 'clip_default',  label = 'default Magazine',     hash = `COMPONENT_APPISTOL_CLIP_01` },
		{ name = 'clip_extended', label = 'extended Magazine',    hash = `COMPONENT_APPISTOL_CLIP_02` },
		{ name = 'flashlight',    label = 'flashlight',           hash = `COMPONENT_AT_PI_FLSH` },
		{ name = 'suppressor',    label = 'suppressor',           hash = `COMPONENT_AT_PI_SUPP` },
		{ name = 'luxary_finish', label = 'luxary Weapon Finish', hash = `COMPONENT_APPISTOL_VARMOD_LUXE` }
    }
}
```

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

### Get Player Weight Information - Lua

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/playerdata

Retrieves and prints the player's current weight and maximum weight capacity. Both client and server-side examples are provided, accessing ESX.PlayerData and ESX.GetPlayerFromId respectively.

```lua
-- Client-side example for current weight
print("The player's current weight is: " .. ESX.PlayerData.weight)
```

```lua
-- Server-side example for max weight and remaining capacity
local xPlayer = ESX.GetPlayerFromId(source)
local holdCapacity = xPlayer.maxWeight - xPlayer.weight
print("The player can still hold " .. holdCapacity .. "kg")
```

```lua
-- Client-side example for max weight and remaining capacity
local holdCapacity = ESX.PlayerData.maxWeight - ESX.PlayerData.weight
print("The player can still hold " .. holdCapacity .. "kg")
```

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

### Get Player Sex/Gender - Lua

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/playerdata

Checks and prints the player character's gender, where 0 represents male and 1 represents female. Examples are provided for both server-side (using ESX.GetPlayerFromId) and client-side (using ESX.PlayerData).

```lua
-- Server-side example
local xPlayer = ESX.GetPlayerFromId(source)
if xPlayer.sex == 0 then
    print("Player is male")
elseif xPlayer.sex == 1 then
    print("Player is female")
end
```

```lua
-- Client-side example
if ESX.PlayerData.sex == 0 then
    print("Player is male")
elseif ESX.PlayerData.sex == 1 then
    print("Player is female")
end
```

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

### Get Player Full Name - Lua

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/playerdata

Retrieves and prints the player character's full name by concatenating first and last names. Examples are provided for both server-side (using ESX.GetPlayerFromId) and client-side (using ESX.PlayerData).

```lua
-- Server-side example
local xPlayer = ESX.GetPlayerFromId(source)
print("The character is called: " .. xPlayer.firstName .. " " .. xPlayer.lastName)
```

```lua
-- Client-side example
print("The character is called: " .. ESX.PlayerData.firstName .. " " .. xPlayer.lastName)
```

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

### Retrieving the Global Interact Key in ESX Legacy

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/client/modules/interactions

Retrieves the globally configured key used for player interactions in ESX Legacy. By default, this is typically the 'E' key, but can be customized. The example shows how to get this key and print it to the console.

```lua
local key = ESX.GetInteractKey()

print("Interact key: " .. key)
```

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

### Request Particle Effect Asset - ESX Streaming

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/client/modules/streaming

Requests a named particle effect asset for use in visual effects. It can be invoked with a callback or return the asset name directly. Example usage involves starting looped particle effects.

```lua
-- TODO: TEST if actually works (Taken from forum)
ESX.Streaming.RequestNamedPtfxAsset('core')
UseParticleFxAssetNextCall('core')
StartParticleFxLoopedAtCoord('ent_amb_fbi_smoke', 0, 0, 0, 0, 0, 0, 1, false, false, false, false)
```

```lua
-- TODO: TEST if actually works (Taken from forum)
local assetName = ESX.Streaming.RequestNamedPtfxAsset('core')
UseParticleFxAssetNextCall(assetName)
StartParticleFxLoopedAtCoord('ent_amb_fbi_smoke', 0, 0, 0, 0, 0, 0, 1, false, false, false, false)
```

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

### Create Property Command - ESX Legacy

Source: https://docs.esx-legacy.com/en/esx_addons/esx_property

Allows administrators to create new properties within the game using a command. This involves setting the street number, price, interior, and entrance position. It requires admin privileges to execute.

```lua
property:create
```

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

### Get Player Source - Lua

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/playerdata

Retrieves and prints the player's source identifier. This is functionally identical to getting the playerId. Server-side uses ESX.GetPlayerFromId, client-side uses ESX.PlayerData.

```lua
-- Server-side example
local xPlayer = ESX.GetPlayerFromId(source)
print("The player's server id/source': " .. xPlayer.source)
```

```lua
-- Client-side example
print("The player's server id/source': " .. ESX.PlayerData.source)
```

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

### Show Help Notification (Lua)

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/client/functions

Displays a help notification in the top-left corner of the screen. It can be shown for a single frame, include a beep sound, or persist for a specified duration.

```lua
RegisterCommand('help', function (source, args, raw) 
    ESX.ShowHelpNotification("We won't give you help, we are truly not sorry.", false, true, 3500)
end)
```

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

### DMV School Checkpoint Action Example (Lua)

Source: https://docs.esx-legacy.com/en/esx_addons/esx_dmvschool

This Lua code illustrates how to define actions for checkpoints in the esx_dmvschool practical driving test. It shows a basic structure for a checkpoint's position and an associated action function that executes when a player reaches it. This allows for custom logic during the driving test.

```lua
Config.CheckPoints = {
	{
		Pos = {x = 255.139, y = -1400.731, z = 29.537},
		Action = function(playerPed, vehicle, setCurrentZoneType)
			-- Do Action
		end
	},
}
```

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

### Shop Zone Configuration (Lua)

Source: https://docs.esx-legacy.com/en/esx_addons/esx_shops

Defines the structure for configuring shop zones in esx_shops. This includes item details, shop position, and blip/marker properties. Ensure all fields are correctly formatted for the resource to function.

```lua
shopName: string = {
  Items = {
      {
          name: string = "bread",
          label: string = "Bread",
          price: number = 5
      }
  },
  Pos: vector3[] = {
        vector3(0.0, 0.0, 0.0)
  },
  Size: number = 0.8 -- Blip Size
  Type: number = 59 -- Blip Type
  Color: number = 25 -- Blip Color
  ShowBlip: boolean = true -- Show Blip on Map
  ShowMarker: boolean = true -- Show Marker
}
```

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

### ESX Garage Configuration Structure

Source: https://docs.esx-legacy.com/en/esx_addons/esx_garage

Defines the structure for configuring garages within the esx_garage script. This includes setting entry points, spawn points, sprite, scale, color, and the impound name for each garage.

```lua
Config.Garages = {
	GarageName = {
        EntryPoint = {x = 0.0, y = 0.0, z = 0.0},
        SpawnPoint = {x = 0.0, y = 0.0, z = 0.0, heading = 0.0},
        Sprite = 357,
		Scale = 0.8,
		Colour = 3,
		ImpoundedName = "impoundName"
    }
}
```

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

### ESX UI Menu Functions

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/client/ui

This section covers functions for registering, opening, closing, and querying the state of UI menus within the ESX framework.

```APIDOC
## ESX.UI.Menu.RegisterType

### Description
Register a custom Menu Type.

### Method
(Client-side function)

### Endpoint
N/A (Client-side function)

### Parameters
#### Arguments
- **type** (string) - The menu key for the type.
- **open** (function) - Function that gets ran when it should be opened.
- **close** (function) - Function that gets ran when it should be closed.

### Request Example
```lua
ESX.UI.Menu.RegisterType("my_menu", myOpenFunction, myCloseFunction)
```
```

```APIDOC
## ESX.UI.Menu.Open

### Description
Open menu of given type and data.

### Method
(Client-side function)

### Endpoint
N/A (Client-side function)

### Parameters
#### Arguments
- **type** (string) - The menu key for the type.
- **namespace** (string) - The namespace for the menu. (Usually script name)
- **name** (string) - The name of the menu.
- **data** (table) - The options for the menu.
- **submit** (function) - The function that gets ran when triggering a button.
- **cancel** (function) - The function that gets ran when canceling the menu.
- **change** (function) - The function that gets ran when data changes.
- **close** (function) - The function that gets ran when the menu closes.

#### Returns
- **type** (string) - The menu key for the type.
- **namespace** (string) - The namespace for the menu. (Usually script name)
- **resourceName** (string) - The script that created it or Unknown
- **name** (string) - The name of the menu
- **data** (table) - The options for the menu
- **submit** (function) - Trigger to force the submit function.
- **cancel** (function) - Trigger to force the cancel function.
- **change** (function) - Trigger to force the change function.
- **close** (function) - Closes the menu.
- **update** (function) - Updates the menu.
- **refresh** (function) - Refreshes the menu.
- **setElement** (function) - Set element data.
- **setElements** (function) - Set elements.
- **setTitle** (function) - Set title of menu
- **removeElement** (function) - Remove element by given query

### Request Example
```lua
RegisterCommand('testOpen', function()
    ESX.UI.Menu.Open('default', GetCurrentResourceName(), 'my_default_menu', {
        title = "My title",
        align = 'bottom-left',
        elements = elements,
        locales = locales
    }, function(data, menu)
        print("Submit data", data, menu)
    end, function(data, menu)
        menu.close()
        print("Cancel data", data, menu)
    end, function(data, menu)
        print("Change data", data, menu)
    end, function()
        print("Closed menu")
    end)
end)
```
```

```APIDOC
## ESX.UI.Menu.Close

### Description
Close the menu of given type, namespace and name.

### Method
(Client-side function)

### Endpoint
N/A (Client-side function)

### Parameters
#### Arguments
- **menuType** (string) - The type of the menu.
- **namespace** (string) - The namespace for the menu. (Usually script name)
- **name** (string) - The name of the menu.

### Request Example
```lua
RegisterCommand('testClose', function()
    ESX.UI.Menu.Close('default', GetCurrentResourceName(), 'my_default_menu')
end)
```
```

```APIDOC
## ESX.UI.Menu.CloseAll

### Description
Close all menu’s.

### Method
(Client-side function)

### Endpoint
N/A (Client-side function)

### Request Example
```lua
RegisterCommand('closeAllMenus', function()
    ESX.UI.Menu.CloseAll()
end)
```
```

```APIDOC
## ESX.UI.Menu.GetOpened

### Description
Get Menu table of given type, namespace and name. Refer to the docs for `ESX.UI.Menu.Open` for detailed infos to the menu data.

### Method
(Client-side function)

### Endpoint
N/A (Client-side function)

### Parameters
#### Arguments
- **menuType** (string) - The type of the menu.
- **namespace** (string) - The namespace for the menu. (Usually script name)
- **name** (string) - The name of the menu.

### Request Example
```lua
RegisterCommand('closeMyMenu', function()
    local myMenu = ESX.UI.Menu.GetOpened('default', GetCurrentResourceName(), 'my_default_menu')
    myMenu.close() 
end)
```
```

```APIDOC
## ESX.UI.Menu.GetOpenedMenus

### Description
Get all open menus. Refer to the docs for `ESX.UI.Menu.Open` for detailed infos to the menu data.

### Method
(Client-side function)

### Endpoint
N/A (Client-side function)

### Parameters
None

### Request Example
(No specific example provided in the source text, but would typically involve calling the function and iterating over the returned table.)
```

```APIDOC
## ESX.UI.Menu.IsOpen

### Description
Check if menu of given type, namespace and name is open.

### Method
(Client-side function)

### Endpoint
N/A (Client-side function)

### Parameters
#### Arguments
- **menuType** (string) - The type of the menu.
- **namespace** (string) - The namespace for the menu. (Usually script name)
- **name** (string) - The name of the menu.

### Request Example
```lua
RegisterCommand('isMenuOpen', function()
    if ESX.UI.Menu.IsOpen('default', GetCurrentResourceName(), 'my_default_menu') then
        print("My epic menu is open!")
    end
end)
```
```

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

### Get Player Identifier

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/server/xplayer

Retrieves the player's unique identifier, typically their Rockstar license.

```lua
local xPlayer = ESX.GetPlayerFromId(playerId)
local identifier = xPlayer.getIdentifier()
```

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

### Debug and Multicharacter Configuration

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/config/main

Settings for enabling debug logging and configuring multicharacter support. `EnableDebug` should be false on production servers. `Multichar` settings are for specific multicharacter systems.

```lua
-- Enable or disable debug logging to console
-- Config.EnableDebug = false

-- Configuration for multicharacter systems
-- Config.Multichar = false
```

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

### Get Account (Event and Export)

Source: https://docs.esx-legacy.com/en/esx_addons/esx_addonaccount

Retrieves an account by its name and owner. This can be used for both shared and non-shared accounts.

```APIDOC
## Get Account

### Description
Retrieves an account by its name and owner. This is used for both shared and non-shared accounts.

### Method
`ESX Event` or `ESX Export`

### Event
`esx_addonaccount:getAccount`

### Event Usage
`TriggerEvent('esx_addonaccount:getAccount', name, owner, cb)`

### Event Example
```lua
TriggerEvent('esx_addonaccount:getAccount', 'society_realestateagent', 'steam:123456789', function(account)
  account.addMoney(500)
end)
```

### Export
`exports['esx_addonaccount']:getAccount`

### Export Usage
`exports['esx_addonaccount']:getAccount(name, owner)`

### Export Example
```lua
local account = exports['esx_addonaccount']:getAccount('property_black_money', 'steam:0123456789')
account.addMoney(500)
```

### Parameters
#### Event Parameters
- **name** (string) - Required - The name of the account.
- **owner** (string) - Required - The identifier of the account owner (e.g., player's license).
- **cb** (function) - Required - A callback function that receives the account object.

#### Export Parameters
- **name** (string) - Required - The name of the account.
- **owner** (string) - Required - The identifier of the account owner (e.g., player's license).

### Response
#### Success Response
The callback function (for event) or the return value (for export) will provide an account object with methods like `addMoney`, `removeMoney`, `setMoney`, etc. The exact methods depend on the account type.
```

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

### Replace Outdated FiveM Native Functions

Source: https://docs.esx-legacy.com/en/tutorial/coding_practices

Shows the modern alternatives to commonly used but outdated FiveM native functions. Using these new functions can lead to improved performance and cleaner code.

```lua
-- Getting the player Ped:
local playerPed = GetPlayerPedId(-1)
-- Replaced by:
local playerPed = PlayerPedId()

-- Getting the distance between two points:
local dist = GetDistanceBetweenCoords(x1, y1, z1, x2, y2, z2, true)
-- Replaced by:
local dist = #(vector3(x1, y1, z1) - vector3(x2, y2, z2))

-- Getting the hash of a string/model:
local hash = GetHashKey('adder')
-- Replaced by:
local hash = joaat('adder')
```

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

### Get Shared Datastore Data

Source: https://docs.esx-legacy.com/en/esx_addons/esx_datastore

Retrieves data from a shared datastore, accessible by all players. This is suitable for global or group-specific data.

```APIDOC
## ESX Datastore: Get Shared Data

### Description
Retrieves data from a specified shared datastore. This function is used for datastores that are not tied to a specific user and can be accessed by multiple clients or server scripts.

### Method
Server Event

### Endpoint
`esx_datastore:getSharedDataStore`

### Parameters
#### Event Parameters
- **name** (string) - Required - The name of the shared datastore to access.
- **callback** (function) - Required - A callback function that receives the datastore object.

### Request Example
```lua
TriggerEvent('esx_datastore:getSharedDataStore', 'police', function(store)
  local weapons = store.get('weapons') or {}
  table.insert(weapons, {name = 'WEAPON_PUMPSHOTGUN', ammo = 50})
  store.set('weapons', weapons)
end)
```

### Response
#### Success Response (Callback)
The callback function receives a `store` object with the following methods:
- **get(key)**: Retrieves a value from the datastore based on the key.
- **set(key, value)**: Sets a value in the datastore for the given key.
- **increment(key, value)**: Increments a numeric value in the datastore.
- **remove(key)**: Removes a key-value pair from the datastore.
```

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

### Create Pickup Functionality in ESX Legacy

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/server/functions

The ESX.CreatePickup function is used to create a pickup in the game world. It requires parameters such as item type, name, count, label, and the player ID to determine the spawn point. Note that this function is not available if a third-party inventory system is installed.

```lua
ESX.CreatePickup("item_standard", "bread", 5, "Bread", 10)
```

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

### Get Player Group - Lua

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/server/xplayer

Retrieves the group of the specified player. Returns the player's group name as a string.

```lua
local xPlayer = ESX.GetPlayerFromId(playerId)
local group = xPlayer.getGroup()
```

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

### Registering Player Interactions with ESX Legacy

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/client/modules/interactions

Registers a new player interaction within the ESX Legacy framework. It requires a unique name, a function to execute when the interaction is triggered, and an optional condition function to determine if the interaction is currently possible. The example demonstrates setting up a point-based interaction.

```lua
local canInteract = false
local point = ESX.Point:new({
    coords = vec3(0, 0, 0),
    hidden = false,
    enter = function()
        canInteract = true
        ESX.TextUI(("Press [%s] to interact"):format(ESX.GetInteractKey()))
    end,
    leave = function()
        canInteract = false
        ESX.HideUI()
    end
})
 
ESX.RegisterInteraction('my_interaction', function()
  print('Interaction pressed')
end, function()
  return canInteract
end)
```

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

### Identity and Distance Give Configuration

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/config/main

Configuration options for player identity loading and item transfer distance. `Identity` enables loading player personal details, and `DistanceGive` sets the maximum range for giving items to other players.

```lua
-- Enable or disable loading player identity details (firstname, lastname, etc.)
-- Config.Identity = true

-- Maximum distance for a player to give an item to another player
-- Config.DistanceGive = 1.5
```

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

### Get Player Name

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/server/xplayer

Returns the player's name. This will be their roleplay name if esx_identity is used, or their FiveM name otherwise.

```lua
local xPlayer = ESX.GetPlayerFromId(playerId)

print("Player is called: " .. xPlayer.getName())
```

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

### Get Shared Account (Event and Export)

Source: https://docs.esx-legacy.com/en/esx_addons/esx_addonaccount

Retrieves a shared account by its name. Shared accounts do not belong to a specific user.

```APIDOC
## Get Shared Account

### Description
Retrieves a shared account by its name. Shared accounts are not associated with any specific user and can be accessed by multiple entities.

### Method
`ESX Event` or `ESX Export`

### Event
`esx_addonaccount:getSharedAccount`

### Event Usage
`TriggerEvent('esx_addonaccount:getSharedAccount', name, cb)`

### Event Example
```lua
TriggerEvent('esx_addonaccount:getSharedAccount', 'society_realestateagent', function(account)
  account.addMoney(500)
end)
```

### Export
`exports['esx_addonaccount']:getSharedAccount`

### Export Usage
`exports['esx_addonaccount']:getSharedAccount(name)`

### Export Example
```lua
local account = exports['esx_addonaccount']:getSharedAccount('society_realestateagent')
account.addMoney(500)
```

### Parameters
#### Event Parameters
- **name** (string) - Required - The name of the shared account.
- **cb** (function) - Required - A callback function that receives the account object.

#### Export Parameters
- **name** (string) - Required - The name of the shared account.

### Response
#### Success Response
The callback function (for event) or the return value (for export) will provide an account object with methods like `addMoney`, `removeMoney`, `setMoney`, etc.
```

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

### Configuration for Food and Drink Items (Lua)

Source: https://docs.esx-legacy.com/en/esx_addons/esx_basicneeds

This configuration table allows registration of items that players can consume to affect their hunger and thirst status. Each item can be defined with its type ('food' or 'drink'), associated prop, status increase amount, whether to remove the item after use, animation details, and prop positioning for consumption.

```lua
Config.Items = {
    ['item'] = { -- Item name
        type = 'food', -- "food" or "drink"
        prop = "prop_name",
        status = 200000, -- how much status will be increased
        remove = true, -- remove item after use
        anim = {dict = 'anim_dict', name = 'anim_name', settings = {8.0, -8, -1, 49, 0, 0, 0, 0}}, -- animation for eating/drinking
        pos = vector3(0.15, 0.03, 0.0), -- prop position
        rot = vector3(15.0, 175.0, 5.0) -- prop rotation
    },
}
```

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

### Configure Accessory Shop Blips and Zones in Lua

Source: https://docs.esx-legacy.com/en/esx_addons/esx_accessories

This Lua code defines the configuration for accessory shop blips and zones. It specifies the position, sprite, and color for blips, and the position for interaction zones. These settings are crucial for the visibility and functionality of accessory shops within the game.

```lua
Config.ShopsBlips = {
	Mask = {
		Pos = {
			vector3(-1338.1, -1278.2, 3.8),
		},
		Blip = {"sprite" = 362, "color" = 2}
	},
}

Config.Zones = {
    AccessoryName = {
        Pos = {
            vector3(-1338.1, -1278.2, 3.8),
        },
    },
}
```

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

### GetPlayerFromIdentifier - Get player by identifier

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/server/functions

Retrieves the xPlayer object for a given player identifier. Note: This is a legacy method; ESX.Player is preferred.

```lua
AddEventHandler('esx:onPlayerJoined', function ()
    local identifier = ESX.GetIdentifier(source)
    if ESX.GetPlayerFromIdentifier(identifier) then
        print("Player with the same identifier is already on the server.")
    end
end)
```

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

### Player Account Configuration

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/config/main

Defines the money accounts available to players in ESX.Legacy. Allows for customization of account labels and rounding behavior. New accounts can be added by defining them in a table format.

```lua
bitcoin = {
    label = "Bitcoin", -- The label that can be used to display it in a hud.
    round = false -- Should it be rounded up to full numbers?
}
```

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

### Get Datastore Data

Source: https://docs.esx-legacy.com/en/esx_addons/esx_datastore

Retrieves data from a specific datastore, optionally linked to a player's identifier. This is used for user-specific data stores.

```APIDOC
## ESX Datastore: Get Data

### Description
Retrieves data from a specified datastore. This function is typically used for non-shared datastores associated with a player.

### Method
Server Event

### Endpoint
`esx_datastore:getDataStore`

### Parameters
#### Event Parameters
- **name** (string) - Required - The name of the datastore to access.
- **owner** (string) - Required - The unique identifier of the player (e.g., 'steam:1234567890').
- **callback** (function) - Required - A callback function that receives the datastore object.

### Request Example
```lua
TriggerEvent('esx_datastore:getDataStore', 'property', 'steam:0123456789', function(store)
   local dressing = store.get('dressing') or {}
end)
```

### Response
#### Success Response (Callback)
The callback function receives a `store` object with the following methods:
- **get(key)**: Retrieves a value from the datastore based on the key.
- **set(key, value)**: Sets a value in the datastore for the given key.
- **increment(key, value)**: Increments a numeric value in the datastore.
- **remove(key)**: Removes a key-value pair from the datastore.
```

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

### Paycheck and Society Payouts Configuration

Source: https://docs.esx-legacy.com/en/esx_core/es_extended/config/main

Controls the enabling and logging of player paychecks and society payouts. `EnablePaycheck` toggles the feature, `LogPaycheck` logs to Discord, and `EnableSocietyPayouts` enables job-based payouts.

```lua
-- Enable or disable player paychecks
-- Config.EnablePaycheck = true

-- Enable or disable logging paychecks to Discord webhook
-- Config.LogPaycheck = false

-- Enable or disable society payouts for jobs
-- Config.EnableSocietyPayouts = true
```
Tokens:
Raw