Jump On

https://docs.jumpon-studios.com/
Admin
Jump On provides a knowledge base and scripts for game platforms like FiveM and RedM, covering...
Tokens:165,333
Snippets:919
Trust Score:4.5
Update:1 year ago
Show doc for...
Tokens:
Raw
### Register Command for Job Start

Source: https://docs.jumpon-studios.com/FiveM/car-shop-delivery

This snippet demonstrates registering a chat command '/farm'. When a player types this command in the game console or chat, it executes the local function 'StartFarmConcess()'. This provides a manual way to start the job, often for testing or administrative purposes.

```lua
-- Command to start the job (can be remove)
RegisterCommand('farm', function()
    StartFarmConcess()
end)
```

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

### Server Action: Initialize SQL Values

Source: https://docs.jumpon-studios.com/RedM/stable

Fires after the script starts and all database values have been updated.

```lua
exports.kd_stable:registerAction('initSQLValues', function()
end)

```

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

### Start Timer UI - lua

Source: https://docs.jumpon-studios.com/jo_libs/modules/ui/client

Starts the timer's UI with a specified duration and an optional low-time threshold. The 'low' parameter determines when the timer color changes to red. Requires prior initialization via jo.ui.initTimer().

```lua
jo.ui.startTimer(time, low)
```

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

### Inventory Creation

Source: https://docs.jumpon-studios.com/jo_libs/modules/framework-bridge/framework

This section details the parameters and provides an example for creating a new inventory using the framework.

```APIDOC
## Create Inventory

### Description
Creates a new inventory with specified properties and an optional whitelist.

### Method
`jo.framework:createInventory(invName, name, invConfig)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **invName** (string) - Required - Unique id of the inventory
- **name** (string) - Required - Label of the inventory
- **invConfig** (table) - Required - Configuration of the inventory
  - **invConfig.maxSlots** (integer) - Max slot of the inventory
  - **invConfig.maxWeight** (float) - Max weight of the inventory
  - **invConfig.acceptWeapons** (boolean) - Optional - Whether the inventory accepts weapons
  - **invConfig.shared** (boolean) - Optional - If the inventory is shared between players
  - **invConfig.ignoreStackLimit** (boolean) - Optional - If the inventory can overcoming stack limits
  - **invConfig.whitelist** (table) - Optional - Restrict the list of items that can be put in the inventory
    - **invConfig.whitelist[index].item** (string) - Name of the whitelisted item
    - **invConfig.whitelist[index].limit** (integer) - Stack limit of this item

### Request Example
```lua
local id = "locker:sheriff"
local label = "Sheriff's locker"
local definition = {
  maxSlots = 100,
  maxWeight = 1000.0,
  acceptWeapons = false,
  shared = true,
  whitelist = {
    { item = "mdt_report", limit = 1000 }
  }
}
jo.framework:createInventory(id, label, definition)
```

### Response
None

### Response Example
None
```

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

### Example Action: Spawn Horse Lantern

Source: https://docs.jumpon-studios.com/RedM/stable

An example of registering an action named 'spawnHorse'. This action is designed to set a lantern ID for a horse entity if it has one defined in its data. It accesses horse data and updates the entity's state.

```lua
exports.kd_stable:registerAction('spawnHorse', function(source,horse,horseID)
  local horseData = Horses[source][horseID]
  local lanternID = horseData.components.saddle_lanterns?.id or false
  if lanternID then
    Entity(horse).state:set('kd_stable_lanternID',tonumber(lanternID),true)
  end
end)
```

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

### Execute Code When Jo Libraries are Ready

Source: https://docs.jumpon-studios.com/jo_libs

This example shows how to use the `jo.ready()` function to execute a callback function once all Jo Libraries modules have been successfully loaded and are ready for use.

```lua
jo.ready(function()
  print('All modules are loaded')
end)
```

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

### Initialize Framework (Client)

Source: https://docs.jumpon-studios.com/RedM/clothing-store

Initializes the framework on the client-side. This function is typically called once when the game or script starts. It may set up global variables or perform initial configurations.

```lua
-- variable "Core" - global variable for core script
-- variable "CoreInv" - global variable for inventory scriot
Config.InitFramework = function()
end
```

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

### Move Entity with Gizmo in Lua

Source: https://docs.jumpon-studios.com/jo_libs/modules/gizmo/client

Demonstrates how to use the `jo.gizmo.moveEntity` function in Lua. It shows the setup of entity ID, configuration table with camera and movement settings, and an optional `allowPlace` callback function. The example logs the result of the function call.

```lua
local entity = 1234566
local cfg = {
  enableCam = true,
  maxDistance = 5.0,
  maxCamDistance = 10.0,
  minY = -20.0,
  maxY = 20.0,
  movementSpeed = 0.1
}
local function allowPlace(position)
  log("Position:", position)
  return true
end
local result = jo.gizmo.moveEntity(entity, cfg, allowPlace)
log(result)
```

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

### Start Mining Job Client Event

Source: https://docs.jumpon-studios.com/FiveM/mining-job

This Lua code snippet demonstrates how to trigger the 'StartMiningFarm' client event to begin the mining job. It's a simple event trigger commonly used in FiveM frameworks.

```lua
TriggerEvent('StartMiningFarm')
```

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

### Server: Get Script Configuration (Lua Export)

Source: https://docs.jumpon-studios.com/RedM/stable

An export function to retrieve the entire script configuration, allowing access to various settings.

```lua
exports.kd_stable:getConfig()
```

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

### Language Override Example

Source: https://docs.jumpon-studios.com/RedM/housing

Demonstrates how to customize in-game text by overriding default language entries. Users can modify specific text labels by adding key-value pairs to `overwriteLang.lua`.

```lua
-- In overwriteLang.lua
Lang.houseManagerTitle = "Property Manager"
Lang.buyHouseMoney = "Purchase with Cash"
Lang.rentPaidSuccessfully = "Rent paid successfully! Welcome home."
```

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

### Lua Server-Side Game Start Validation

Source: https://docs.jumpon-studios.com/FiveM/airsoft

A server-side Lua function that is triggered when a player attempts to start a game. It receives the player's source ID and party setup details, returning a boolean to indicate whether the game can proceed. This function is designed to prevent game starts under specific conditions.

```lua
------------- 
-- SERVER SIDE
-------------
if IsDuplicityVersion() then
  --Fired when the player select "Start the game"
  ---@param source integer player ID
  ---@param party table setup of the party
  ---@param party.joueurs table list of players in the lobby
  function CanStartParty(source, party)
    --return false to cancel the starting of the game
    return true
  end
end
```

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

### Getting Ped Texture Asset Hashname

Source: https://docs.jumpon-studios.com/jo_libs/modules/ped-texture/client

This function retrieves the hashname of a ped texture based on gender, category, and texture data (either ID or a detailed table). The example shows how to get the hashname for an eyebrow texture for a male character.

```lua
local isMale = true
local layername = "eyebrow"
local id = 5
local texture = jo.pedTexture.getOverlayAssetFromId(isMale, layername, id)
print(texture)
-- Expected output: mp_u_faov_eyebrow_005
```

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

### Lua Filter Example: Modify Horse Data

Source: https://docs.jumpon-studios.com/RedM/stable

An example demonstrating how to register a filter to modify horse data, specifically changing the horse's name.

```lua
kd_stable:registerFilter('filterHorseData', function(horseData)
  horseData = "New name"
  return horseData
end)

```

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

### Light Client Module

Source: https://docs.jumpon-studios.com/jo_libs/modules/light/client

The Light Client module provides functions to create and manage dynamic light sources with smooth transitions. It emphasizes performance considerations, range optimization, smooth transitions using the 'ease' parameter, and the impact of color choices on mood.

```APIDOC
## Light Client Module

### Description

The Light Client module is a powerful tool for creating and managing dynamic light sources with smooth transitions within your RedM script. It offers comprehensive control over the creation, movement, and fading of lights, including properties like color, intensity, and range.

### Tips for Using Lights

*   **Performance**: Lights can be computationally expensive. Minimize the number of active lights for better performance.
*   **Range**: Smaller light ranges (5-15 units) often yield better visual results and improved efficiency.
*   **Transitions**: Utilize the `ease` parameter for smooth, natural-looking transitions when modifying light properties.
*   **Colors**: Choose colors strategically to evoke different moods. Warm colors like orange and yellow are suitable for fire effects, while cool colors such as blue and cyan can be used for magical elements.
```

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

### Client Initialize the framework

Source: https://docs.jumpon-studios.com/RedM/stable

Function to initialize your custom framework. This function is called when the framework is being set up and can be used to set up global variables like `Core` and `CoreInv`.

```APIDOC
## Client Initialize the framework

Function to init your framework

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```lua
-- variable "Core" - global variable for core script
-- variable "CoreInv" - global variable for inventory scriot
Config.InitFramework = function()
end
```

### Response
#### Success Response (200)
None

#### Response Example
None
```

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

### Project Configuration Settings

Source: https://docs.jumpon-studios.com/RedM/housing

Defines core operational parameters for the project, such as rent durations, grace periods, and extension policies. These settings directly impact player interaction with rental systems.

```lua
Config.rentMaxDays = 10                         -- Maximum number of days players can rent at once (daily rent)
Config.rentMaxWeek = 2                          -- Maximum number of weeks players can rent at once (weekly rent)
Config.extraDaysAllowedBeforeExpulsion = 1.0    -- Grace period (in days) after rent expires before eviction
Config.allowRentExtensionAnytime = false        -- Allow players to extend rent before it expires
```

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

### Menu Creation and Item Management

Source: https://docs.jumpon-studios.com/jo_libs/modules/menu/functions

Demonstrates how to create a menu, add various types of items with different configurations, and manage menu state.

```APIDOC
## Menu Class Methods

### `jo.menu.create(id, data)`

Creates a new menu instance.

#### Parameters
- **id** (string) - The unique identifier for the menu.
- **data** (table) - Configuration table for the menu (e.g., title, subtitle).

### `menu:addItem(position, itemData)`

Adds an item to the menu. If position is omitted, the item is added to the end.

#### Parameters
- **position** (integer, optional) - The index at which to insert the item.
- **itemData** (table) - Data defining the menu item (title, description, price, onClick, etc.).

### `menu:removeItem(index)`

Removes an item from the menu by its index. Requires `push()` to apply changes.

#### Parameters
- **index** (integer) - The index of the item to remove.

### `menu:deleteValue(keys)`

Deletes a specific property of a menu. Requires `push()` to apply changes.

#### Parameters
- **keys** (string|table) - The property name(s) to delete.

### `menu:updateValue(keys, value)`

Updates a specific property of a menu. Requires `push()` to apply changes.

#### Parameters
- **keys** (string|table) - The property name(s) to update.
- **value** (any) - The new value for the property.

### `menu:sort(first, last)`

Sorts menu items alphabetically by title.

#### Parameters
- **first** (integer, optional) - The starting index for sorting. Defaults to 1.
- **last** (integer, optional) - The ending index for sorting. Defaults to the last item index.

### `menu:reset()`

Resets the menu to its initial state, moving the cursor to the first item.

### `menu:setCurrentIndex(index)`

Changes the currently active item index.

#### Parameters
- **index** (integer) - The item index to set as active.

### Request Example
```lua
-- Create a menu
local menu = jo.menu.create("shopMenu", {
  title = "General Store",
  subtitle = "Available Items"
})

-- Add items
menu:addItem({
  title = "Hunting Knife",
  description = "A sharp knife for skinning animals",
  price = { money = 12.50 },
  onClick = function(currentData)
    print("Purchasing Hunting Knife")
  end
})

menu:addItem(1, {
  title = "Horse Brush",
  description = "Keep your horse clean and happy",
  price = { money = 5.75 },
  icon = "brush",
  disabled = false,
  textRight = "New!"
})

-- Update an item's value
menu:updateValue({"items", 1, "title"}, "Updated Knife Title")

-- Remove an item
menu:removeItem(2) -- Removes the second item

-- Sort items
menu:sort()

-- Reset menu
-- menu:reset()

-- Set current index
-- menu:setCurrentIndex(1)
```
```

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

### Get All Registered Prompts using jo.prompt.getAll()

Source: https://docs.jumpon-studios.com/jo_libs/modules/prompts/prompt/client

The jo.prompt.getAll() function returns a table containing all currently registered prompts within the system. This is useful for debugging or getting an overview of all active prompts. The returned table structure should be inspected for detailed information.

```lua
jo.prompt.getAll()
```

```lua
local groups = jo.prompt.getAll
log(groups)
```

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

### Create and Manage Menus with Lua

Source: https://docs.jumpon-studios.com/jo_libs/modules/menu/functions

Demonstrates how to create a shop menu, add various types of items with different properties (icons, prices, statistics, sliders), handle item clicks, and manage child menus. It also shows how to send the menu data to the NUI and display it.

```lua
-- Create a menu
local menu = jo.menu.create("shopMenu", {
  title = "General Store",
  subtitle = "Available Items"
})

-- Add items using single parameter (adds to the end of the list)
menu:addItem({
  title = "Hunting Knife",
  description = "A sharp knife for skinning animals",
  prefix = "knife", -- Icon before the title
  price = { money = 12.50 },
  statistics = {
    { label = "Damage", type = "bar", value = { 7, 10 } },
    { label = "Durability", type = "bar", value = { 8, 10 } }
  },
  onClick = function(currentData)
    print("Purchasing Hunting Knife")
    -- Code to purchase the item would go here
  end
})

-- Add item at specific position (position 1 - at the beginning)
menu:addItem(1, {
  title = "Horse Brush",
  description = "Keep your horse clean and happy",
  price = { money = 5.75 },
  icon = "brush",     -- Left icon
  disabled = false,
  textRight = "New!", -- Text shown on the right
  onClick = function(currentData)
    print("Purchasing Horse Brush")
    -- Code to purchase the item would go here
  end
})

-- Add another item with sliders
menu:addItem({
  title = "Hunting Outfit",
  description = "Camouflage clothing for hunting",
  price = { money = 45.00, gold = 5 },
  sliders = {
    {
      title = "Colors",
      current = 1,
      values = { "Brown", "Green", "Black" }
    }
  },
  onChange = function(currentData)
    local selectedColor = currentData.item.sliders[1].value.label
    print("Selected color: " .. selectedColor)
  end
})

-- Add a child menu item (opens another menu when selected)
menu:addItem({
  title = "Weapons →",
  child = "weaponsMenu", -- This will open the "weaponsMenu" when activated
  icon = "revolver"
})

-- Send the menu to the NUI layer
menu:send()

-- Set this menu as the current menu and show it
jo.menu.setCurrentMenu("shopMenu")
jo.menu.show(true)
```

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

### Example Filter: Restricting Access to Specific Clothes

Source: https://docs.jumpon-studios.com/RedM/clothing-store

An example of registering a filter to restrict access to specific clothing items. This filter checks the player's job and returns false if they are not a 'tailor', preventing them from buying the clothes. It also sends a notification to the player.

```lua
kd_clothingstore:registerFilter('canAccessToSpecificClothes', function(canAccess, source, clothesData, moneyType)
	local job = GetJob(source)
	if job ~= "tailor" then
		return false, SendNotif("Only tailer can buy clothes")
	end
	return canAccess
end)
```

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

### Create a Light Source with Jump On Studios

Source: https://docs.jumpon-studios.com/jo_libs/modules/light/client

The jo.light.create function initializes a new dynamic light source at specified coordinates. It allows customization of intensity, RGB color, range, and transition easing. The function returns a LightClass object representing the created light.

```lua
local myLight = jo.light.create(
    vec3(100.0, 200.0, 30.0), -- position
    0.8,                      -- intensity
    { 255, 0, 0 },            -- RGB (red)
    10.0,                     -- range
    500                       -- ease time (ms)
)
```

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

### Initialize a new timeout instance - Lua

Source: https://docs.jumpon-studios.com/jo_libs/modules/timeout/shared

The TimeoutClass:set() method initializes a new timeout instance without immediately starting it. It takes the delay duration, the callback function, and optional arguments. The timeout must be explicitly started later. This is useful for pre-configuring timeouts.

```lua
local msec = 1000
local function callback()
  print("Timeout completed")
end
local args = { name = "Test", value = 100 }

-- Initialize a new timeout without starting it
local timeout = TimeoutClass:set(msec, callback, args)
print("Timeout created with ID: " .. timeout.id)

-- The timeout has been created but won't execute until start() is called
-- Expected output: Just prints the timeout ID, callback won't run automatically
```

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

### jo.component.getWearableState

Source: https://docs.jumpon-studios.com/jo_libs/modules/component/functions

Gets the wearable state of a specific component category for a ped.

```APIDOC
## GET jo.component.getWearableState

### Description
Gets the wearable state of a specific component category for a ped.

### Method
GET

### Endpoint
/jo/component/getWearableState

### Parameters
#### Path Parameters
None

#### Query Parameters
- **ped** (integer) - Required - The entity ID.
- **category** (string|integer) - Required - The category to check the wearable state for.

### Request Example
```json
{
  "ped": 123,
  "category": "hats"
}
```

### Response
#### Success Response (200)
- **state** (string) - The wearable state of the category (e.g., "Equipped", "Available").

#### Response Example
```json
{
  "state": "Equipped"
}
```
```

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

### Load NUI Input Library

Source: https://docs.jumpon-studios.com/jo_libs/modules/input/client

Loads the NUI (Non-User Interface) input system. This function is essential for initializing the input manager before using other NUI-related input functions. It does not take any parameters.

```lua
jo.input.loadNUI()
```

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

### Get Player Job

Source: https://docs.jumpon-studios.com/jo_libs/modules/framework-bridge/framework

Retrieves the current job assigned to a specific player.

```APIDOC
## Get Player Job

### Description
Returns the current job assigned to a player.

### Method
`jo.framework:getJob(source)`

### Endpoint
`/` (Implicit)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **source** (integer) - Required - The source ID of the player

### Request Example
```lua
local source = 1
print(jo.framework:getJob(source))
```

### Response
#### Success Response (200)
- **return value** (string) - The job name of the player

#### Response Example
```
"police"
```
```

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

### Configure Valentine Stable Settings

Source: https://docs.jumpon-studios.com/RedM/stable

Sets up configuration for the 'Valentine' stable, including its ID, name, location, associated ped model, blip settings, menu disabling options, available horses and wagons, component purchasing, and preview/spawn locations.

```lua
Config.stables = {
	{
		id = "valentine",--must be unique
		name = "Valentine",
		location = vec4(-365.15,792.68,115.18,178.47),
		pedModel = `u_m_m_bwmstablehand_01`,
		blip = `blip_shop_horse`,--set to false to turn the blip off
    disableHorseMenu = false, --set to true to disable the horse menu part
    disableWagonMenu = false, --set to true to disable the wagon menu part
		horsesAvailable = {},--let empty to allow all horses, use false to disable
		canBuyHorseComponents = true, --use false to disable the buying of horse components
		previewHorse = vec4(-369.59,793.00,115.15,177.26), --location to preview new horse
		previewMyHorse = vec4(-371.76,786.87,115.16,272.08), --location to preview your horse
		equipMyHorse = vec4(-371.76,786.87,115.16,272.08), --location for the ride horse scene
		wagonsAvailable = {},--let empty to allow all wagons, use false to disable
		previewWagon = vec4(-371.76,786.87,115.16,272.08), --location to preview wagon
		spawnWagon = vec4(-370.69, 775.85, 116.26, 269.11), --location to spawn wagon
		storeSaddle = vec4(-365.235, 790.888, 116.175,0.0),
		inside = { --polyzone
			vec3(-376.765, 793.418, 116.124),
			vec3(-363.036, 793.695, 116.188),
			vec3(-362.191, 784.502, 116.180),
			vec3(-376.236, 783.673, 116.177)
		},
		parkWagon = { --polyzone to store the wagon (optional)
			vec3(1199.763, -179.827, 100.658),
			vec3(1201.357, -169.945, 100.649),
			vec3(1211.116, -169.303, 101.508),
			vec3(1213.158, -177.519, 101.384)
		}
	},
	...
}
```

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

### jo.component.getBodiesUpperFromSkinTone()

Source: https://docs.jumpon-studios.com/jo_libs/modules/component/functions

Gets the upper body component hash from bodies index and skin tone.

```APIDOC
## GET /websites/jumpon-studios/jo.component.getBodiesUpperFromSkinTone

### Description
Gets the upper body component hash from bodies index and skin tone.

### Method
GET

### Endpoint
/websites/jumpon-studios/jo.component.getBodiesUpperFromSkinTone

### Parameters
#### Query Parameters
- **ped** (integer|string) - Required - The entity ID or model name
- **bodiesIndex** (integer) - Optional - The bodies index. Defaults to 1.
- **skinTone** (integer) - Optional - The skin tone. Defaults to 1.

### Response
#### Success Response (200)
- **return value** (string) - The upper body component hash string.

### Response Example
```json
{
  "returnValue": "hash_string_for_upper_body"
}
```
```

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

### Initialize Model Prices Configuration

Source: https://docs.jumpon-studios.com/RedM/stable

Initializes the Config.modelPrices table and iterates through Config.prices to create nested tables for each category, preparing it to store specific model prices.

```lua
Config.modelPrices = {}
for category in pairs (Config.prices) do
	Config.modelPrices[category] = {}
	Config.modelPrices[category] = {}
end

Config.modelPrices['horse_saddles'][2] = {money = 50,gold = 2}
```

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

### jo.component.getBodiesLowerFromSkinTone()

Source: https://docs.jumpon-studios.com/jo_libs/modules/component/functions

Gets the lower body component hash from bodies index and skin tone.

```APIDOC
## GET /websites/jumpon-studios/jo.component.getBodiesLowerFromSkinTone

### Description
Gets the lower body component hash from bodies index and skin tone.

### Method
GET

### Endpoint
/websites/jumpon-studios/jo.component.getBodiesLowerFromSkinTone

### Parameters
#### Query Parameters
- **ped** (integer|string) - Required - The entity ID or model name
- **bodiesIndex** (integer) - Optional - The bodies index. Defaults to 1.
- **skinTone** (integer) - Optional - The skin tone. Defaults to 1.

### Response
#### Success Response (200)
- **return value** (string) - The lower body component hash string.

### Response Example
```json
{
  "returnValue": "hash_string_for_lower_body"
}
```
```

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

### Create and Show Menu with Palette Slider (Lua)

Source: https://docs.jumpon-studios.com/jo_libs/modules/menu/functions

Demonstrates how to create a menu, add an item with a palette slider, and display the menu. This is useful for selecting color tints or similar options.

```lua
local menu = jo.menu.create('menu1', {})
menu:addItem({
  title = "Item",
  sliders = {
    { type = "palette", title = "tint", tint = "tint_makeup", max = 63, current = 14 }
  }
})
menu:send()
jo.menu.setCurrentMenu('menu1')
jo.menu.show(true)
```

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

### Get Player Job - Lua

Source: https://docs.jumpon-studios.com/jo_libs/modules/framework-bridge/user

Returns the current job title assigned to a player as a string.

```lua
local source = 1
local user = jo.framework:getUser(source)
local job = user:getJob()
print(job)
```

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

### Get Items from Inventory

Source: https://docs.jumpon-studios.com/jo_libs/modules/framework-bridge/framework

Retrieves all items from a specific inventory, including their quantities and metadata.

```APIDOC
## Get Items from Inventory

### Description
Retrieves all items from a specific inventory with their quantities and metadata.

### Method
`jo.framework:getItemsFromInventory(invId)`

### Endpoint
`/` (Implicit)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **invId** (string) - Required - The unique ID of the inventory

### Request Example
```lua
local source = 1
local id = "locker:sheriff"
local items = jo.framework:getItemsFromInventory(source, id)
for key, item in pairs(items) do
  print(item.item)
end
```

### Response
#### Success Response (200)
- **return value** (table) - A list of items with the following structure:
  - **item.amount** (integer) - The amount of the item
  - **item.id** (integer) - The id of the item
  - **item.item** (string) - The name of the item
  - **item.metadata** (table) - The metadata of the item

#### Response Example
```json
[
  {
    "amount": 1,
    "id": 1,
    "item": "mdt_report",
    "metadata": {}
  }
]
```
```

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

### Include Raw Keys Library in fxmanifest.lua

Source: https://docs.jumpon-studios.com/jo_libs/modules/raw-keys

Shows how to integrate the Raw Keys library into your project by specifying the initiator as a shared script and listing the 'raw-keys' module in the fxmanifest.lua file. This makes the `jo.rawKeys` global variable available in your resources.

```lua
shared_scripts {
  '@jo_libs/init.lua'
}
```

```lua
jo_libs {
  'raw-keys',
}
```

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

### Prompt Nui Client API

Source: https://docs.jumpon-studios.com/jo_libs/modules/prompts/prompt-nui/client

Functions to manage NUI-based prompts, including creating groups and checking key completion.

```APIDOC
## JO Functions 

### `jo.promptNui.createGroup()` 

Creates a new prompt group with a specified title and optional position.

#### Syntax 
```lua
jo.promptNui.createGroup(title, position)
```

#### Parameters 
* `title` (string|boolean) - The title for the new prompt group. Set to `false` to have no title.
* `position` (string, Optional) - The screen position for the group. Allowed values are: `"bottom-right"`,`"center-right"`,`"top-right"`,`"bottom-left"`,`"center-left"`,`"top-left"`. Defaults to `"bottom-right"`.

#### Return Value 
* GroupClass - A new instance of a prompt group.

#### Example 
```lua
-- Example 1: Create a group with a standard title and a specified position
local group1 = jo.promptNui.createGroup("Main Menu", "top-left")

-- Example 2: Create a group with an icon in the title using HTML tags
local group2 = jo.promptNui.createGroup("<img src='icon.png'> Options", "center-right")

-- Example 3: Create a group without a title by passing nil
local group3 = jo.promptNui.createGroup(nil)

-- Example 4: Create a group with a false title (no title) and a custom position
local group4 = jo.promptNui.createGroup(false, "top-right")

-- Example 5: Create a group with a red title
local group4 = jo.promptNui.createGroup("<span style='color:red'>My Red Menu</span>")
```

### `jo.promptNui.isCompleted()` 

Checks whether a specified key has been held for the required duration to trigger an action. Optionally ensures that the key does not trigger repeatedly unless explicitly allowed.

#### Syntax 
```lua
jo.promptNui.isCompleted(key, fireMultipleTimes)
```

#### Parameters 
* `key` (string) - The key identifier to check.
* `fireMultipleTimes` (boolean|nil, Optional) - If true, allows the key to trigger multiple times. Defaults to `false`.

#### Return Value 
* boolean - True if the key press is complete and valid, otherwise `false`.

#### Example 
```lua
CreateThread(function()
  while true do
    if jo.promptNui.isCompleted("A", true) then
      print("G IS COMPLETED")
    end

    if jo.promptNui.isCompleted("K") then
      print("K IS COMPLETED")
    end
    Wait(0)
  end
end)
```
```

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

### Get Framework Name

Source: https://docs.jumpon-studios.com/jo_libs/modules/framework-bridge/framework

Retrieves the name of the currently active framework being used by the server.

```APIDOC
## Get Framework Name

### Description
Returns the name of the current active framework being used.

### Method
`jo.framework:get()`

### Endpoint
`/` (Implicit)

### Parameters
None

### Request Example
```lua
local frameworkName = jo.framework:get()
print(frameworkName)
```

### Response
#### Success Response (200)
- **return value** (string) - The name of the current framework. Possible values: `"VORP"`, `"RedEM"`, `"RedEM2023"`, `"qbr"`, `"rsg"`, `"qr"`, `"rpx"`

#### Response Example
```
"VORP"
```
```

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

### jo.component.getHeadFromSkinTone

Source: https://docs.jumpon-studios.com/jo_libs/modules/component/functions

Gets the head component hash for a ped based on head index and skin tone.

```APIDOC
## GET jo.component.getHeadFromSkinTone

### Description
Gets the head component hash for a ped based on head index and skin tone.

### Method
GET

### Endpoint
/jo/component/getHeadFromSkinTone

### Parameters
#### Path Parameters
None

#### Query Parameters
- **ped** (integer) - Required - The entity ID.
- **headIndex** (integer) - Optional - The head index, defaults to 1.
- **skinTone** (integer) - Optional - The skin tone, defaults to 1.

### Request Example
```json
{
  "ped": 123,
  "headIndex": 1,
  "skinTone": 3
}
```

### Response
#### Success Response (200)
- **hash** (string) - The head component hash string.

#### Response Example
```json
{
  "hash": "HEAD_COMPONENT_HASH"
}
```
```

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

### Compare Raw Keys Module with Native Input Handling

Source: https://docs.jumpon-studios.com/jo_libs/modules/raw-keys

Demonstrates the difference between the native Lua implementation for detecting key presses/releases and the more streamlined approach offered by the Raw Keys module. The module simplifies the code by abstracting away native control constants.

```lua
CreateThread(function()
  local key = `INPUT_LOOT` -- "E" key if the player didn't edit their key settings
  while true do
    if IsControlJustPressed(0, key) then
      print('Key E pressed')
    end
    if IsControlJustReleased(0, key) then
      print('Key E released')
    end
    Wait(0)
  end
end)
```

```lua
jo.rawKeys.listen("E", function(isPressed)
  if isPressed then
    print('Key E pressed')
  else
    print('Key E released')
  end
end)
```

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

### Framework Class API

Source: https://docs.jumpon-studios.com/jo_libs/modules/framework-bridge/framework

This section details the methods available within the `jo.framework` class for managing player inventories and currency.

```APIDOC
## Server jo.framework:addItemInInventory()

### Description
Adds a specific item to a custom inventory with optional metadata and wait parameter.

### Method
Server

### Endpoint
jo.framework:addItemInInventory(source, invId, item, quantity, metadata, needWait)

### Parameters
#### Path Parameters
- **source** (integer) - Required - The source ID of the player
- **invId** (string) - Required - The unique ID of the inventory
- **item** (string) - Required - The name of the item
- **quantity** (integer) - Required - The quantity of the item
- **metadata** (table) - Optional - The metadata of the item
- **needWait** (boolean) - Optional - If need to wait after the SQL insertion (default: false)

### Request Example
lua
```lua
local source = 1
local id = "locker:sheriff"
local item = "mdt_report"
local quantity = 1
local metadata = { id = 321 }
jo.framework:addItemInInventory(source, id, item, quantity, metadata)
```

### Response
#### Success Response
This method does not explicitly return a value indicating success or failure, but operates based on provided parameters.
```

```APIDOC
## Server jo.framework:addMoney()

### Description
A function to give money to a player.

### Method
Server

### Endpoint
jo.framework:addMoney(source, amount, moneyType)

### Parameters
#### Path Parameters
- **source** (integer) - Required - The source ID of the player
- **amount** (number) - Required - The amount of money to add
- **moneyType** (integer) - Optional - 0: dollar, 1: gold, 2: rol (default: 0)

### Request Example
lua
```lua
local source = 1
local amount = 10.5
local moneyType = 0
local isAdded = jo.framework:addMoney(source,amount,moneyType)
print(isAdded)
```

### Response
#### Success Response (boolean)
- **Return Value** (boolean) - Return true if the money is successfully added.
```

```APIDOC
## Server jo.framework:canUseItem()

### Description
Checks if a player has the required quantity of a specific item in their inventory and optionally removes it.

### Method
Server

### Endpoint
jo.framework:canUseItem(source, item, amount, meta, remove)

### Parameters
#### Path Parameters
- **source** (integer) - Required - The source ID of the player
- **item** (string) - Required - The name of the item need to use
- **amount** (integer) - Required - The quantity of the item
- **meta** (table) - Optional - The metadata of the item
- **remove** (boolean) - Optional - If the item has to be removed (default: false)

### Request Example
lua
```lua
local source = 1
local item = "water"
local amount = 1
local canUseWater = jo.framework:canUseItem(source, item, amount, nil, nil)
print(canUseWater)
```

### Response
#### Success Response (boolean)
- **Return Value** (boolean) - Return true if the player has enough quantity of the item.
```

```APIDOC
## Server jo.framework:canUserBuy()

### Description
Checks if a player has sufficient funds of a specified currency type.

### Method
Server

### Endpoint
jo.framework:canUserBuy(source, amount, moneyType, removeIfCan)

### Parameters
#### Path Parameters
- **source** (integer) - Required - The source ID of the player
- **amount** (number) - Required - The amount of money the player needs to have
- **moneyType** (integer|string) - Optional - 0: dollar, 1: gold, 2: rol (default: 1)
- **removeIfCan** (boolean) - Optional - Remove the money if the player has enough (default: false)

### Request Example
lua
```lua
local price = 103
local source = 1
print(jo.framework:canUserBuy(source, 103))
-- Expected output : true if the player has more than $103
```

### Response
#### Success Response (boolean)
- **Return Value** (boolean) - Returns true if the player has more money than the amount.
```

```APIDOC
## Server jo.framework:canUserPayWith()

### Description
A function that checks if a player can pay multiple prices.

### Method
Server

### Endpoint
jo.framework:canUserPayWith(source, prices, removeIfCan)

### Parameters
#### Path Parameters
- **source** (integer) - Required - The source ID of the player
- **prices** (table) - Required - The prices to check
- **removeIfCan** (boolean) - Optional - Remove the prices if the player can pay

### Response
#### Success Response (boolean)
- **Return Value** (boolean) -
```

```APIDOC
## Server jo.framework:createInventory()

### Description
Creates a custom inventory with configurable slots, weight limits, and item restrictions.

### Method
Server

### Endpoint
jo.framework:createInventory(invName, name, invConfig)

### Parameters
#### Path Parameters
- **invName** (string) - Required - The name of the inventory
- **name** (string) - Required - The name of the inventory
- **invConfig** (table) - Required - The configuration for the inventory

### Request Example
This method is typically called server-side to set up inventories and does not have a direct client-side request example.
```

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

### EVENT_LOOT_PLANT_START

Source: https://docs.jumpon-studios.com/jo_libs/modules/game-events/client

Data structure for the EVENT_LOOT_PLANT_START event, related to the start of a planting or item distribution process.

```APIDOC
## EVENT_LOOT_PLANT_START

### Description
This event signifies the beginning of a process where rewards or items are planted or distributed.

### Method
N/A (Event-based)

### Endpoint
N/A (Event-based)

### Parameters
#### Event Data
- **num_given_rewards** (integer) - The number of rewards given.
- **reward** (integer) - The type or ID of the reward.
- **inventory_item** (integer) - The inventory item involved.
- **value_3** to **value_35** (integer) - Miscellaneous values associated with the event.
- **num** (integer) - A numerical count.
- **value_13** to **value_25** (integer) - Additional miscellaneous values.
- **weapon** (integer) - The weapon associated with the event.
- **initiator_entity** (integer) - The entity that initiated the action.
- **target_entity** (integer) - The target entity of the action.
- **looted_entity_model** (integer) - The model of the looted entity.
- **looted_composite** (integer) - The composite identifier of the looted entity.
```

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

### Get User Skin

Source: https://docs.jumpon-studios.com/jo_libs/modules/framework-bridge/framework

Retrieves a player's skin data with standardized properties and formatting.

```APIDOC
## Get User Skin

### Description
Retrieves a player's skin data with standardized properties and formatting.

### Method
`jo.framework:getUserSkin(source)`

### Endpoint
`/` (Implicit)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **source** (integer) - Required - The source ID of the player

### Request Example
```lua
local source = 1
local skin = jo.framework:getUserSkin(source)
log(skin)
```

### Response
#### Success Response (200)
- **return value** (table) - The skin data.

#### Response Example
```json
{
  "shape_：「shape_1」: 0,
  "shape_：「shape_2」: 0,
  "skin_：「skin_1」: 0,
  "skin_：「skin_2」: 0,
  "face_：「face_1」: 0,
  "face_：「face_2」: 0,
  "hair_：「hair_1」: 0,
  "hair_：「hair_2」: 0,
  "beard_：「beard_1」: 0,
  "beard_：「beard_2」: 0,
  "eyebrows_：「eyebrows_1」: 0,
  "eyebrows_：「eyebrows_2」: 0,
  "makeup_：「makeup_1」: 0,
  "makeup_：「makeup_2」: 0,
  "blush_：「blush_1」: 0,
  "blush_：「blush_2」: 0,
  "complexion_：「complexion_1」: 0,
  "complexion_：「complexion_2」: 0,
  "sunDamage_：「sunDamage_1」: 0,
  "sunDamage_：「sunDamage_2」: 0,
  "freckles_：「freckles_1」: 0,
  "freckles_：「freckles_2」: 0,
  "mole_：「mole_1」: 0,
  "mole_：「mole_2」: 0,
  "dirt_：「dirt_1」: 0,
  "dirt_：「dirt_2」: 0,
  "age_：「age_1」: 0,
  "age_：「age_2」: 0,
  "hair_color": 0,
  "beard_color": 0,
  "eyebrows_color": 0,
  "makeup_color": 0,
  "blush_color": 0,
  "skin_：「skin」": 0
}
```
```

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

### User Class: Constructor

Source: https://docs.jumpon-studios.com/jo_libs/modules/framework-bridge/user

Creates and returns a new User instance for the specified player.

```APIDOC
## Constructor

### Server jo.framework.UserClass:get() 

Creates and returns a new User instance for the specified player.

### Method

`GET` (implicitly, as it's a factory method)

### Endpoint

`/framework/UserClass` (conceptual, called via `jo.framework.UserClass:get()`)

### Parameters

#### Path Parameters

None

#### Query Parameters

None

#### Request Body

None

### Parameters

`source` (integer) - Required - The source ID of the player

### Request Example

```lua
local user = jo.framework.UserClass:get(source)
-- OR --
local user = jo.framework:getUser(source)
```

### Response

#### Success Response (200)

- **UserClass** (UserClass) - A User class object containing player data and methods

#### Response Example

(Returns a UserClass object, not a JSON response)
```

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

### Configure Colorways and Palettes (Lua)

Source: https://docs.jumpon-studios.com/RedM/clothing-store-colorways

This snippet shows the configuration for the kd_clothingstore_colorways add-on. It defines the input key for opening the colorways menu and specifies which color palette types are enabled. This configuration is essential for setting up the add-on's core functionality.

```lua
Config = {}

Config.keys = {
	colorways = 'INPUT_CREATOR_RS'
}

Config.palettes = {
	tint_generic_clean = true,
	tint_hair = true,
	tint_horse = true,
	tint_horse_leather = true,
	tint_leather = true,
	tint_makeup = true
}
```
Tokens:
Raw