ES Extended

https://esx-brasil.github.io
Admin
ES Extended is a popular economy-based roleplay framework for FiveM, offering core features and...
Tokens:10,340
Snippets:79
Trust Score:8.3
Update:11 months ago
Show doc for...
Tokens:
Raw
### Configure Server for ES Extended

Source: https://esx-brasil.github.io/installation

Adds necessary ACE permissions and starts the ES Extended framework and its associated UI menus in the server configuration file. Ensure mysql-async is started before ES Extended.

```lua
add_principal group.admin group.user
add_ace resource.es_extended command.add_ace allow
add_ace resource.es_extended command.add_principal allow
add_ace resource.es_extended command.remove_principal allow
add_ace resource.es_extended command.stop allow


start mysql-async
start es_extended

start esx_menu_default
start esx_menu_list
start esx_menu_dialog
```

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

### Resource Initialization Example (resources.cfg)

Source: https://esx-brasil.github.io/faq

This snippet provides an example of a resources.cfg file, listing the order in which ESX resources should be started. Proper initialization order is crucial, as some resources depend on others (e.g., esx_policejob after esx_society).

```cfg
start chat
start sessionmanager
restart sessionmanager
start hardcap
start mysql-async
start es_extended
start instance
start cron
start skinchanger
start esx_skin
start esx_menu_default
start esx_menu_list
start esx_menu_dialog
start esx_phone
start esx_addonaccount
start esx_addoninventory
start esx_datastore
start esx_society
start esx_service
start esx_billing
start esx_jobs
start esx_joblisting
start esx_taxijob
start esx_mecanojob
start esx_policejob
start esx_property
start esx_realestateagentjob
start esx_bankerjob
start esx_ambulancejob
start esx_vehicleshop
start esx_status
start esx_basicneeds
start esx_clotheshop
start esx_garage
start esx_holdup
start esx_drugs
start esx_atm
```

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

### Install ES Extended with FVM

Source: https://esx-brasil.github.io/installation

Installs the ES Extended framework and UI menus using the FVM package manager. This method simplifies dependency management and updates.

```bash
fvm install --save --folder=essential esx-brasil/es_extended
fvm install --save --folder=esx esx-brasil/esx_menu_default
fvm install --save --folder=esx esx-brasil/esx_menu_dialog
fvm install --save --folder=esx esx-brasil/esx_menu_list
```

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

### Install ES Extended with Git

Source: https://esx-brasil.github.io/installation

Clones the ES Extended framework and UI menu repositories from GitHub into the resources directory. This method is useful for developers who want direct access to the source code.

```bash
cd resources
git clone https://github.com/ESX-Brasil/es_extended [essential]/es_extended
git clone https://github.com/ESX-Brasil/esx_menu_default [esx]/[ui]/esx_menu_default
git clone https://github.com/ESX-Brasil/esx_menu_dialog [esx]/[ui]/esx_menu_dialog
git clone https://github.com/ESX-Brasil/esx_menu_list [esx]/[ui]/esx_menu_list
```

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

### Server Configuration Example (server.cfg)

Source: https://esx-brasil.github.io/faq

This snippet shows an example of a server.cfg file for ESX, including network endpoints, license keys, database connection strings, and client limits. Ensure to replace placeholders like YOUR_IP_ADRESS and <key> with your actual server details.

```cfg
endpoint_add_tcp "0.0.0.0:30120"
endpoint_add_udp "0.0.0.0:30120"
sv_listingIPOverride "YOUR_IP_ADRESS"

set sv_licenseKey "<key>" # https://keymaster.fivem.net/ for onesync you must pay fivem, or instead you can buy cheap onesync keys from sites
set steam_webApiKey "none"
set mysql_connection_string "mysql://username:password@adress/database?dateStrings=true"
sv_maxClients 5
sv_hostname "Your Server Label"
sv_scriptHookAllowed 0
sv_endpointPrivacy true

add_principal group.admin group.user
add_ace resource.es_extended command.add_ace allow
add_ace resource.es_extended command.add_principal allow
add_ace resource.es_extended command.remove_principal allow

exec resources.cfg
```

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

### Example: esx:showAdvancedNotification Usage

Source: https://esx-brasil.github.io/es_extended/client/events/showadvancednotification

An example demonstrating how to use the esx:showAdvancedNotification event to send a notification. This includes specifying the event name, target source, and the content of the notification such as title, subject, message, icon, and icon type.

```lua
TriggerClientEvent('esx:showAdvancedNotification', source, 'title', 'subject', 'msg', 'CHAR_AMMUNATION', 3)
```

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

### Example: Displaying Button Input in Help Notification

Source: https://esx-brasil.github.io/es_extended/client/events/showhelpnotification

An example demonstrating how to use the esx:showHelpNotification event to display a message that includes a button input prompt. The '~INPUT_CONTEXT~' placeholder is used to represent the context button, providing visual feedback to the player.

```lua
TriggerClientEvent('esx:showHelpNotification', source, 'Hit ~INPUT_CONTEXT~ to do shit!')
```

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

### Server-Side Usage Example: Kill Notifications

Source: https://esx-brasil.github.io/es_extended/common/events/onplayerdeath

Example of how to use the esx:onPlayerDeath event on the server-side to display kill notifications.

```APIDOC
## Server-Side Usage Example: Kill Notifications

### Description
This example demonstrates how to register the `esx:onPlayerDeath` event on the server and use the provided data to trigger client-side notifications for player kills.

### Method
Event Handler Registration

### Endpoint
N/A (Server-side script)

### Request Example
```lua
RegisterServerEvent('esx:onPlayerDeath')
AddEventHandler('esx:onPlayerDeath', function(data)
    data.victim = source

    if data.killedByPlayer then
        TriggerClientEvent('esx:showNotification', -1, GetPlayerName(data.victim) .. ' was killed by ' .. GetPlayerName(data.killerServerId) .. ' from ' .. data.distance .. ' units')
    else
        TriggerClientEvent('esx:showNotification', -1, GetPlayerName(data.victim) .. ' died')
    end
end)
```

### Response
#### Success Response
N/A (Triggers client events)

#### Response Example
(Client-side notification triggered by `esx:showNotification`)
```

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

### Example: Transferring Items Safely (Lua)

Source: https://esx-brasil.github.io/es_extended/server/xplayer/functions/addinventoryitem

This example demonstrates how to safely transfer items between players using Lua. It first checks if the target player can carry the items using xPlayer.canCarryItem before removing from the source and adding to the target inventory. If the target player cannot hold the items, a notification is shown.

```Lua
if targetXPlayer.canCarryItem(itemName, itemCount) then
    sourceXPlayer.removeInventoryItem(itemName, itemCount)
    targetXPlayer.addInventoryItem   (itemName, itemCount)
else
    sourceXPlayer.showNotification('Target player could not hold all of that.')
end
```

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

### Client-Side Usage Example: Player Alive Status

Source: https://esx-brasil.github.io/es_extended/common/events/onplayerdeath

Example of how to use the esx:onPlayerDeath and playerSpawned events on the client-side to track if the player is dead.

```APIDOC
## Client-Side Usage Example: Player Alive Status

### Description
This example shows how to use `esx:onPlayerDeath` on the client-side to set a boolean flag `IsDead` to true when the player dies, and reset it to false when the player spawns. This is useful for controlling game logic, such as disabling menus when the player is dead.

### Method
Event Handlers

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

### Request Example
```lua
local IsDead = false

AddEventHandler('esx:onPlayerDeath', function(data)
    IsDead = true
end)

AddEventHandler('playerSpawned', function(spawn)
    IsDead = false
end)
```

### Response
#### Success Response
N/A (Modifies client-side variable)

#### Response Example
(The `IsDead` variable will be updated based on player death and respawn events.)
```

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

### Iterate and Print Weapon Ammo - Lua

Source: https://esx-brasil.github.io/es_extended/server/xplayer/functions/getloadout

This example demonstrates how to iterate through the player's loadout obtained from xPlayer.getLoadout() and print the ammo count for each weapon. It utilizes Lua's ipairs function for table iteration.

```lua
for k,v in ipairs(xPlayer.getLoadout()) do
    print(v.ammo)
end
```

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

### Get All Active Players (Lua)

Source: https://esx-brasil.github.io/es_extended/client/functions/game/getplayers

Retrieves all active players on the server. Optional arguments allow filtering to exclude the current player, specifying a key-value return format, and choosing to return player ped handles or client IDs. The default return format is an index-value table of client IDs.

```lua
local players = ESX.Game.GetPlayers()

for k,v in ipairs(players) do
    local targetPed = GetPlayerPed(v)
    print(('A player with server id %s found at %s!'):format(GetPlayerServerId(v), GetEntityCoords(targetPed)))
end
```

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

### Get Player Weapon Information (Lua)

Source: https://esx-brasil.github.io/es_extended/server/xplayer/functions/getweapon

Retrieves the loadout number and weapon object if the player possesses the specified weapon. It takes the weapon name as input and returns the weapon's data if found.

```Lua
local loadoutNum, weapon = xPlayer.getWeapon('WEAPON_PISTOL')

if weapon then
    print(xPlayer.loadout[loadoutNum].label)
else
    print('weapon not found!')
end
```

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

### Get Player Loadout - Lua

Source: https://esx-brasil.github.io/es_extended/server/xplayer/functions/getloadout

The xPlayer.getLoadout() function retrieves the player's current weapon loadout. It returns a table where each entry represents a weapon with its name, ammo count, label, and components. This is useful for checking or displaying player inventory.

```lua
xPlayer.getLoadout()
```

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

### Set Vehicle Properties with ESX.Game.SetVehicleProperties (Lua)

Source: https://esx-brasil.github.io/es_extended/client/functions/game/setvehicleproperties

This Lua function sets various properties for a vehicle object. It takes the vehicle entity and a table of properties as input. The example demonstrates how to set the plate and turbo modification for the vehicle the player is currently in.

```lua
local playerPed = PlayerPedId()

if IsPedInAnyVehicle(playerPed, false) then
    local vehicle = GetVehiclePedIsIn(playerPed, false)

    ESX.Game.SetVehicleProperties(vehicle, {
        plate = 'ESX',
        modTurbo = true
    })
end

```

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

### Get Player Coordinates (Lua)

Source: https://esx-brasil.github.io/es_extended/server/xplayer/functions/getcoords

Retrieves the player's current coordinates on the server. An optional boolean argument can be used to return coordinates as a vector3 type.

```lua
local coords = xPlayer.getCoords(true)
local distance = #(coords - vector3(610.0, 120.2, 60.3))

print(distance)
```

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

### Get Missing Player Accounts (Lua)

Source: https://esx-brasil.github.io/es_extended/server/xplayer/functions/getmissingaccounts

Retrieves a list of missing player accounts. This function is intended for internal use only during player data saving operations. It accepts a callback function that receives the missing accounts data.

```lua
xPlayer.getMissingAccounts(cb)
```

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

### Get ESX Player Object by Server ID

Source: https://esx-brasil.github.io/es_extended/server/functions/getplayerfromid

This function retrieves an ESX player object using their server ID. It returns nil if the player ID is invalid. The function expects a numeric player ID as input.

```lua
RegisterNetEvent('esx_ambulancejob:healMe')
AddEventHandler('esx_ambulancejob:healMe', function()
    local xPlayer = ESX.GetPlayerFromId(source)

    if xPlayer.job.name == 'ambulance' then
        xPlayer.triggerEvent('esx_basicneeds:healPlayer')
    end
end)
```

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

### Get Player Data by Identifier (Lua)

Source: https://esx-brasil.github.io/es_extended/server/functions/getplayerfromidentifier

This Lua function retrieves an ESX player object using their Rockstar identifier. It returns the player object if found, otherwise returns nil. Dependencies include the ESX framework.

```lua
local xPlayer = ESX.GetPlayerFromIdentifier('888452e629a590b9d79245f0030b1f7b9a81d558')

if xPlayer then
    xPlayer.showNotification('Welcome Hawaii!')
else
    print('Hawaii is not in your server, good')
end
```

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

### Get Ped Mugshot and Display Notification (Lua)

Source: https://esx-brasil.github.io/es_extended/client/functions/game/getpedmugshot

This Lua code snippet demonstrates how to use ESX.Game.GetPedMugshot to capture a player's mugshot and display it in an advanced notification. It includes a crucial warning about unregistering the mugshot using UnregisterPedheadshot to prevent exceeding the game's limit of 34 mugshots.

```lua
ESX = nil

Citizen.CreateThread(function()
    while ESX == nil do
        TriggerEvent('esx:getSharedObject', function(obj) ESX = obj end)
        Citizen.Wait(0)
    end

    while true do
        Citizen.Wait(10)

        if IsControlJustReleased(0, 22) then -- Spacebar Key
            notification('Hello')
        end
    end
end)

function notification(msg)
    local mugshot, mugshotStr = ESX.Game.GetPedMugshot(GetPlayerPed(-1))
    ESX.ShowAdvancedNotification('Test', 'Testing!', msg, mugshotStr, 1)
    UnregisterPedheadshot(mugshot)
end

```

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

### Get Closest Player Client ID and Distance (Lua)

Source: https://esx-brasil.github.io/es_extended/client/functions/game/getclosestplayer

This function retrieves the client ID and distance of the player closest to a specified coordinate. It takes an optional 'coords' argument (a table or vector3) representing the search location; if omitted, it defaults to the player's current coordinates. It returns the closest player's client ID (-1 if none found) and the distance to that player.

```lua
ESX.Game.GetClosestPlayer(coords)
```

```lua
local closestPlayer, closestPlayerDistance = ESX.Game.GetClosestPlayer()

if closestPlayer == -1 or closestPlayerDistance > 3.0 then
    ESX.ShowNotification('There\'s no player near you!')
else
    ESX.ShowNotification(('Found %s, they are %s unit(s) away'):format(GetPlayerName(closestPlayer), closestPlayerDistance))
end
```

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

### ESX.CreatePickup Function

Source: https://esx-brasil.github.io/es_extended/server/functions/createpickup

This function creates a pickup in the game. It supports creating pickups for items, money, accounts, and weapons, with specific parameters for each type.

```APIDOC
## ESX.CreatePickup

### Description
Creates a pickup in the game. This function can be used to create pickups for items, money, accounts, or weapons. Specific parameters like `components` and `tintIndex` are available for weapon pickups.

### Method
Function Call

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

### Parameters
#### Arguments
- **type** (string) - No - The pickup type. Valid inputs: `item_standard` for items, `item_money` for cash, `item_account` for an account, and `item_weapon` for weapons.
- **name** (string) - No - The name of the item, account, or weapon.
- **count** (number) - No - The count of the item, cash, account, or weapon ammo.
- **label** (string) - No - The label displayed for the pickup.
- **playerId** (number) - No - The server ID of the player who created the pickup. This is used to determine the pickup's spawn point.
- **components** (table) - Yes - Only used when `type` is `item_weapon`. An index-value table containing weapon components.
- **tintIndex** (number) - Yes - Only used when `type` is `item_weapon`. A tint index for the weapon.

### Request Example
```lua
-- Example for creating an item pickup
ESX.CreatePickup('item_standard', 'bread', 5, 'Fresh Bread', source)

-- Example for creating a weapon pickup with components and tint
ESX.CreatePickup('item_weapon', 'WEAPON_PISTOL', 1, 'Pistol', source, { [1] = 1, [2] = 1 }, 2)
```

### Response
#### Success Response
This function does not return a value.
```

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

### ESX.ShowHelpNotification

Source: https://esx-brasil.github.io/es_extended/client/functions/showhelpnotification

This function shows a help notification with a message. It supports displaying button inputs and customizable options like sound and duration.

```APIDOC
## ESX.ShowHelpNotification

### Description
Displays a help notification with a message to the player. This notification can optionally include button inputs, a sound effect, and a specific display duration.

### Method
`ESX.ShowHelpNotification(msg, thisFrame, beep, duration)`

### Parameters
#### Arguments
- **msg** (string) - No - The message to display in the notification.
- **thisFrame** (boolean) - Yes - false - If true, only shows this frame. Useful for scripts showing notifications in a loop.
- **beep** (boolean) - Yes - true - If true, plays a beep sound with the notification.
- **duration** (number) - Yes - -1 (5000 ms) - The duration in milliseconds to display the notification. Defaults to 5000ms.

### Request Example
```lua
ESX.ShowHelpNotification('Hit ~INPUT_CONTEXT~ to do shit!')
```

### Response
This function does not return a value. It triggers a UI notification.
```

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

### Trigger Client Event for Help Notification

Source: https://esx-brasil.github.io/es_extended/client/events/showhelpnotification

This client event triggers a help notification on the player's screen, supporting parsed messages that can include button inputs. It is intended for server-to-client communication. The event takes the message string as an argument.

```lua
TriggerClientEvent('esx:showHelpNotification', source, msg)
```

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

### Show Help Notification with ESX

Source: https://esx-brasil.github.io/es_extended/client/functions/showhelpnotification

Displays a help notification in the game with a specified message. It supports optional parameters for controlling the frame display, sound effects, and notification duration. This function is essential for providing in-game feedback to players.

```lua
ESX.ShowHelpNotification('Hit ~INPUT_CONTEXT~ to do shit!')
```

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

### Trigger Server Callback with ESX.TriggerServerCallback

Source: https://esx-brasil.github.io/es_extended/client/functions/triggerservercallback

Triggers a server callback and handles the asynchronous response. It accepts the callback name, a callback function to execute upon completion, and optional arguments to pass to the server. This function is asynchronous and requires careful handling of its callback.

```lua
local myAgument = 'hello'

ESX.TriggerServerCallback('esx_example:test', function(isBusy, numKills)
    print(isBusy, numKills)
    print('this code is an asynchronous task')
end, myAgument)

print('this code is running in sync')
```

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

### Spawn Object in ESX.Game (Lua)

Source: https://esx-brasil.github.io/es_extended/client/functions/game/spawnobject

Spawns an object visible to everyone on the server. This is an asynchronous function that waits for the object model to stream. It takes the object model or hash, coordinates, and an optional callback function.

```lua
ESX.Game.SpawnObject('prop_cs_cuffs_01', vector3(120.0, -200.0, 30.0), function(object)
    print(DoesEntityExist(object), 'this code is async!')
end)

print('this code is sync!')
```

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

### Add Weapon Component to Player's Weapon (Lua)

Source: https://esx-brasil.github.io/es_extended/server/xplayer/functions/addweaponcomponent

This function adds a specified weapon component to a player's weapon. The available components are defined in the weapon configuration file. It requires the weapon name and the component name as string arguments.

```Lua
xPlayer.addWeaponComponent(weaponName, weaponComponent)
```

```Lua
xPlayer.addWeaponComponent('WEAPON_ASSAULTRIFLE', 'clip_drum')
xPlayer.addWeaponComponent('WEAPON_ASSAULTRIFLE', 'flashlight')
```

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

### esx:onPlayerDeath Event

Source: https://esx-brasil.github.io/es_extended/common/events/onplayerdeath

Handles player death events, providing information about the victim, killer, and cause of death.

```APIDOC
## esx:onPlayerDeath Event

### Description
This event is triggered when a player dies. It provides a data table containing information about the death, such as the victim's and killer's coordinates, the cause of death, and whether the killer was another player.

### Method
Event Handler

### Endpoint
N/A (This is an event)

### Parameters
#### `data` Table Information
- **victimCoords** (table) - Coordinates of the victim at the time of death.
- **killerCoords** (table) - Coordinates of the killer at the time of death.
- **deathCause** (string) - The hash of the weapon, model, or object that killed the victim.
- **killedByPlayer** (boolean) - Indicates if the player was killed by another player. This field and related data are only populated when killed by a player.
- **distance** (number) - The distance (in GTA units) between the victim and killer when the death occurred.
- **killerServerId** (number) - The server ID of the killer.
- **killerClientId** (number) - The client ID of the killer.

### Request Example
```lua
AddEventHandler('esx:onPlayerDeath', function(data)
    -- Your logic here
end)
```

### Response
#### Success Response
N/A (This is an event handler)

#### Response Example
```lua
-- The 'data' table passed to the handler would look like this when killed by a player:
{
    victimCoords = { x = 123.4, y = 567.8, z = 90.1 },
    killerCoords = { x = 120.0, y = 560.0, z = 90.0 },
    deathCause = 'WEAPON_PISTOL',
    killedByPlayer = true,
    distance = 15.5,
    killerServerId = 2,
    killerClientId = 3
}
-- And like this when not killed by a player:
{
    victimCoords = { x = 123.4, y = 567.8, z = 90.1 },
    deathCause = 'WEAPON_FALL',
    killedByPlayer = false
}
```
```

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

### ESX.Scaleform.ShowFreemodeMessage

Source: https://esx-brasil.github.io/es_extended/client/functions/scaleform/showfreemodemessage

This function displays a freemode message for the player with a specified title, message, and duration.

```APIDOC
## ESX.Scaleform.ShowFreemodeMessage

### Description
Displays a freemode message for the player.

### Method
`FUNCTION`

### Endpoint
`N/A`

### Parameters
#### Arguments
- **title** (string) - No - - - Title text
- **msg** (string) - No - - - Message text
- **sec** (number) - No - - - Time in seconds to show scaleform

### Request Example
```lua
ESX.Scaleform.ShowFreemodeMessage('~o~fact of the day', '~y~Hawaii is a king', 5)
```

### Response
#### Success Response (N/A)
This function does not return a value.

#### Response Example
N/A
```

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

### Trigger ESX Notification (Server-Side)

Source: https://esx-brasil.github.io/es_extended/client/events/shownotification

This event is triggered on the server-side to display a notification to a specific player. It takes the player's source ID and the notification message as arguments. The message supports various color codes for formatting.

```lua
TriggerClientEvent('esx:showNotification', source, '~y~Hello ~b~world~s~!')
```

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

### Teleport Entity with ESX.Game.Teleport

Source: https://esx-brasil.github.io/es_extended/client/functions/game/teleport

The ESX.Game.Teleport function teleports a specified entity to given coordinates. It is an asynchronous function that waits for collision to load before completing. It accepts the entity to teleport, coordinates (as a table or vector3, with an optional heading), and a callback function to execute after teleportation.

```lua
local playerPed = PlayerPedId()

ESX.Game.Teleport(playerPed, {x = 120.0, y = -200.0, z = 30.0, heading = 100.0}, function()
    print('this code is async!')
end)

print('this code is sync!')
```

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

### Register Item as Usable with ESX

Source: https://esx-brasil.github.io/es_extended/server/functions/registerusableitem

Registers a specified item to be usable within the ESX framework. It takes the item name and a callback function as arguments. The callback function is executed when the item is used, typically handling player inventory updates and notifications.

```lua
ESX.RegisterUsableItem(item, cb)
```

```lua
ESX.RegisterUsableItem('bread', function(playerId)
    local xPlayer = ESX.GetPlayerFromId(playerId)
    xPlayer.removeInventoryItem('bread', 1)
    xPlayer.showNotification('That was delicious.. right?')
end)
```

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

### Spawn Local Object with ESX.Game

Source: https://esx-brasil.github.io/es_extended/client/functions/game/spawnlocalobject

Spawns an object that is only visible to the local player. This is an asynchronous function that waits for the object model to stream in before execution. It takes the object model or hash, spawn coordinates, and an optional callback function.

```lua
ESX.Game.SpawnLocalObject('prop_cs_cuffs_01', vector3(120.0, -200.0, 30.0), function(object)
    print(DoesEntityExist(object), 'this code is async!')
end)

print('this code is sync!')
```

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

### Registering a Server Callback with ESX

Source: https://esx-brasil.github.io/es_extended/server/functions/registerservercallback

Registers a server-side callback function that can be triggered by clients. It takes a unique name for the callback and a function to be executed on the server. The callback function receives arguments sent from the client and must invoke its own callback to acknowledge completion.

```javascript
ESX.RegisterServerCallback('esx_myscript:setNewName', function(playerId, newName, cb)) {
    local xPlayer = ESX.GetPlayerFromId(playerId)
    xPlayer.setName(newName)

    cb(true)
}
```

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

### Request Scaleform Movie Handle (Lua)

Source: https://esx-brasil.github.io/es_extended/client/functions/scaleform/utils/requestscaleformmovie

Requests and returns a scaleform handle for the specified movie. This function takes the movie name as a string argument and returns a scaleform handle. It is commonly used to interact with scaleform interfaces within the game environment.

```Lua
local scaleform = ESX.ScaleForm.Utils.RequestScaleformMovie('MP_BIG_MESSAGE_FREEMODE')
```

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

### Display Advanced Notification with ESX

Source: https://esx-brasil.github.io/es_extended/client/functions/showadvancednotification

This function is used to display a custom notification to the player. It requires sender, subject, message, texture dictionary, icon type, and optional parameters for flashing, saving to brief, and HUD color. The texture dictionary can be a pre-existing image or a player's mugshot.

```lua
ESX.ShowAdvancedNotification(sender, subject, msg, textureDict, iconType, flash, saveToBrief, hudColorIndex)
```

```lua
function notification(msg)
    local mugshot, mugshotStr = ESX.Game.GetPedMugshot(PlayerPedId())
    ESX.ShowAdvancedNotification('title', 'subject', 'msg', mugshotStr, 1)
    UnregisterPedheadshot(mugshot)
end
```

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

### Add Account Money to Player (Lua)

Source: https://esx-brasil.github.io/es_extended/server/xplayer/functions/addaccountmoney

The xPlayer.addAccountMoney function is used to add a specified amount of money to a player's account. It requires the account name (e.g., 'bank', 'money') and the amount to add. Ensure the account name is valid and defined in the ESX configuration.

```lua
local xPlayer = ESX.GetPlayerFromId(playerId)
xPlayer.addAccountMoney('bank', 1000)
```

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

### Display Freemode Message with ESX.Scaleform.ShowFreemodeMessage

Source: https://esx-brasil.github.io/es_extended/client/functions/scaleform/showfreemodemessage

This function displays a freemode message to the player. It requires a title, message content, and the duration in seconds for which the message should be visible. This is useful for in-game notifications or informational pop-ups.

```Lua
ESX.Scaleform.ShowFreemodeMessage(title, msg, sec)
```

```Lua
ESX.Scaleform.ShowFreemodeMessage('~o~fact of the day', '~y~Hawaii is a king', 5)
```

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

### Add Inventory Item to Player (Lua)

Source: https://esx-brasil.github.io/es_extended/server/xplayer/functions/addinventoryitem

This Lua function adds a specified item and count to a player's inventory. It does not perform checks for weight limits, so it's recommended to use xPlayer.canCarryItem before calling this function to ensure the player can carry the added items.

```Lua
xPlayer.addInventoryItem(item, count)
```

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

### ESX.ShowAdvancedNotification

Source: https://esx-brasil.github.io/es_extended/client/functions/showadvancednotification

This function allows you to display advanced notifications to the player. You can customize the sender, subject, message, icon, and other visual aspects.

```APIDOC
## ESX.ShowAdvancedNotification

### Description
Shows an advanced notification to the player with customizable parameters.

### Method
ESX.ShowAdvancedNotification

### Parameters
#### Arguments
- **sender** (string) - No - - - Message header
- **subject** (string) - No - - - Message subject
- **msg** (string) - No - - - Message content
- **textureDict** (string) - No - - - Texture directory, see Texture Directory for accepted values
- **iconType** (number) - No - - - Icon type, see Icon Types for accepted values
- **flash** (boolean) - Yes - false - Flash the notification?
- **saveToBrief** (boolean) - Yes - true - Save to brief? Located in Pause Menu > Help
- **hudColorIndex** (number) - Yes - nil - The background color, see https://gyazo.com/68bd384455fceb0a85a8729e48216e15 for available colors

### Request Example
```lua
function notification(msg)
    local mugshot, mugshotStr = ESX.Game.GetPedMugshot(PlayerPedId())
    ESX.ShowAdvancedNotification('title', 'subject', 'msg', mugshotStr, 1)
    UnregisterPedheadshot(mugshot)
end
```

### Response
This function does not return a value. Its purpose is to display a notification.

### Texture Directory
To specify a texture directory, you can either parse an existing notification image or create a player mugshot using ESX.

### Icon Types
- **1** - Chat Box
- **2** - Email
- **3** - Add Friend Request
- **7** - Right Jumping Arrow
- **8** - RP Icon
- **9** - $ Icon
```

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

### ESX Server-Side: Handle Player Deaths and Notifications

Source: https://esx-brasil.github.io/es_extended/common/events/onplayerdeath

This server-side script registers an event handler for esx:onPlayerDeath. It processes the death data, determines if the player was killed by another player, and sends a notification to all clients. It utilizes player names and the distance of the kill for richer notifications.

```lua
RegisterServerEvent('esx:onPlayerDeath')
AddEventHandler('esx:onPlayerDeath', function(data)
    data.victim = source

    if data.killedByPlayer then
        TriggerClientEvent('esx:showNotification', -1, GetPlayerName(data.victim) .. 'was killed by ' .. GetPlayerName(data.killerServerId) .. ' from ' .. data.distance .. ' units')
    else
        TriggerClientEvent('esx:showNotification', -1, GetPlayerName(data.victim) .. ' died')
    end
end)
```

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

### Check Player Item Carry Capacity (Lua)

Source: https://esx-brasil.github.io/es_extended/server/xplayer/functions/cancarryitem

The xPlayer.canCarryItem function determines if a player has sufficient inventory space to carry a given item and quantity. It is crucial for managing item limits and preventing overflow.

```lua
if targetXPlayer.canCarryItem(itemName, itemCount) then
    sourceXPlayer.removeInventoryItem(itemName, itemCount)
    targetXPlayer.addInventoryItem   (itemName, itemCount)

    sourceXPlayer.showNotification(_U('gave_item', itemCount, sourceItem.label, targetXPlayer.name))
    targetXPlayer.showNotification(_U('received_item', itemCount, sourceItem.label, sourceXPlayer.name))
else
    sourceXPlayer.showNotification(_U('ex_inv_lim', targetXPlayer.name))
end
```

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

### Trigger Client Event: esx:showAdvancedNotification

Source: https://esx-brasil.github.io/es_extended/client/events/showadvancednotification

This server-side event triggers an advanced notification for a specified client. It requires the client's source, notification title, subject, message, icon name, and icon type. This is the server-side equivalent of the client-side ESX.ShowAdvancedNotification function.

```lua
TriggerClientEvent('esx:showAdvancedNotification', source, title, subject, msg, icon, iconType)
```

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

### Set Player Inventory Item Count - Lua

Source: https://esx-brasil.github.io/es_extended/server/xplayer/functions/setinventoryitem

Sets the quantity of a specified item within a player's inventory. This function takes the item's name (string) and the new count (number) as parameters. It is advised to use xPlayer.canCarryItem to check weight limits before calling this function, as it does not perform this validation itself.

```lua
xPlayer.setInventoryItem(item, count)
```

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

### Remove Weapon Component - Lua

Source: https://esx-brasil.github.io/es_extended/server/xplayer/functions/removeweaponcomponent

This Lua function removes a specified weapon component from a player's inventory if they possess it. It takes the weapon name and component name as arguments. The available components are defined in the weapon configuration file.

```lua
xPlayer.removeWeaponComponent(weaponName, weaponComponent)
```

```lua
local weaponName, weaponComponent = 'WEAPON_PISTOL', 'clip_extended'

if xPlayer.hasWeaponComponent(weaponName, weaponComponent) then
    xPlayer.removeWeaponComponent(weaponName, weaponComponent)
end
```

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

### xPlayer.hasWeapon

Source: https://esx-brasil.github.io/es_extended/server/xplayer/functions/hasweapon

Checks if the player has the specified weapon. Returns true if the player has the weapon, false otherwise.

```APIDOC
## xPlayer.hasWeapon

### Description
This function returns whether the player has the specified weapon.

### Method
N/A (This appears to be a function call within a script, not a traditional HTTP API endpoint)

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
#### Argument
- **weaponName** (string) - No - The name of the weapon to check for.

### Request Example
```lua
if xPlayer.hasWeapon('WEAPON_PISTOL') then
    print('found weapon')
else
    print('weapon not found!')
end
```

### Response
#### Success Response (Boolean)
- **return value** (boolean) - Returns `true` if the player has the weapon, `false` otherwise.

#### Response Example
```json
// No direct JSON response, returns a boolean value in script execution
```
```

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

### Check Player Weapon with xPlayer.hasWeapon (Lua)

Source: https://esx-brasil.github.io/es_extended/server/xplayer/functions/hasweapon

This Lua function checks if the player possesses a specified weapon. It takes the weapon name as a string argument and returns a boolean indicating whether the player has the weapon. This is useful for game logic that depends on weapon possession.

```lua
if xPlayer.hasWeapon('WEAPON_PISTOL') then
    print('found weapon')
else
    print('weapon not found!')
end
```

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

### ESX Client-Side: Track Player Death State

Source: https://esx-brasil.github.io/es_extended/common/events/onplayerdeath

This client-side script utilizes the esx:onPlayerDeath event to set a boolean flag 'IsDead' to true when the player dies. It also resets this flag to false when the player respawns using the 'playerSpawned' event, which is useful for controlling UI elements or game logic.

```lua
local IsDead = false

AddEventHandler('esx:onPlayerDeath', function(data)
    IsDead = true
end)

AddEventHandler('playerSpawned', function(spawn)
    IsDead = false
end)
```
Tokens:
Raw