This documentation is for developers who are making scripts for redm, you should also note that this is a work in progress and anything can be changed at any time until the final release.

You cannot Import encrypted files like with escrow etc, only files that aren’t encrypted can be imported.

Lib usage

To import modules to your script you must add the following to the script fxmanifest.lua file

fxmanifest

   shared_script "@vorp_lib/import.lua"

the global variables below will be available for both server and client, so make sure you dont call vorp exports in your script to avoid calling it twice.

LIB is a global variable that contains a table with CORE and NOTIFY as sub-variables like LIB.CORE and LIB.NOTIFY to access them easily

Variables

CORE

CORE is available for server and client , you wont need to call exports.vorp_core:GetCore()

 -- just simply use the global variable
 LIB.CORE.NotifyObjective(source,"Hello World",5000)
 -- callbacks
 local result = LIB.CORE.Callback.TriggerAwait("my_callback")

NOTIFY

NOTIFY is available for server and client , you wont need to use vorp core notify or even import the notify module

 -- just simply use the global variable
 LIB.NOTIFY:Objective(source,"Hello World",5000)

Module Import

Only Lua files can be imported

List of Modules

modules

Importing Modules

Import

module

string

required

Allows to import any modules from the lib, a list of modules available can be found here

local module = Import "modulename" -- no symbols

local prompts = Import("prompts").Prompts -- every module has a table with the module name as the key for readability

local Lib = Import "prompts"
local Prompts = Lib.Prompts -- [[@as PROMPTS]] -- for intellisense

Import Usage

Single

Modules

The following modules are available in the lib, you can import them using the Import function, documentation for each module will be available below

Entities

This module is used to create entities like peds, vehicles, objects, etc, it has a baseclass for all entities and sub classes for each entity type all creations are instanced objects every creation will have its own instance and wont be shared with other scripts since its imported to your script when you restart your resource the entities will be removed for easy development it has a entity tracker if you wish to track the entities from other scripts (see collector file) for exports

Shared

Map

The map module is used to create blips for now but will be expanded to include more map related features when you restart your resource the blips will be removed for easy development

Blip

This is the baseclass for blips, you can use these methods below or use directly the natives

GetHandle

GetBlipColor

color

string|table

required

Get the color value's for blip colors, can be a single color string or table of color strings

return

integer

Returns the color value's corresponding to the color name's

    -- single string or multiple colors can be requested just for ease of use
    local blue, red, yellow = Map.Blips:GetBlipColor({ 'blue', 'red', 'yellow' }) 
    blip:AddModifierColor(blue) -- or string  "blue"

Inputs

this module is used to create input controls for your resource, single or multiple , without the user having to create loops and a bunch of code all creations are instanced objects every creation will have its own instance and wont be shared with other scripts since its imported to your script when you restart your resource the inputs will be removed for easy development

Input

Prompts

this module is used to create prompts with coordinate-based activation, multiple prompts can be grouped together and managed as one unit all creations are instanced objects every creation will have its own instance and wont be shared with other scripts since its imported to your script when you restart your resource the prompts will be removed for easy development

Prompt

Commands

this module is used to register client-side/server-side commands with permissions, suggestions, and argument validation all creations are instanced objects every creation will have its own instance and wont be shared with other scripts since its imported to your script when you restart your resource the commands will be removed for easy development, if a command is active and suggestion hasnt been marked to add on register, it will be added on character selected automatically

Command

Points

this module is used to create coordinate-based enter/exit areas with radius detection, multiple points can be registered and managed independently all creations are instanced objects every creation will have its own instance and wont be shared with other scripts since its imported to your script when you restart your resource the points will be removed for easy development

Point

Events

this module is used to register game event listeners that can capture and process native game events with automatic data parsing all creations are instanced objects every creation will have its own instance and wont be shared with other scripts since its imported to your script when you restart your resource the event listeners will be removed for easy development

Event

use these methods below to manage event listeners

Start

Pause

Resume

Destroy

DevMode

enabled

boolean

required

Enable or disable developer mode for debugging events

eventsToIgnore

string|array

Optional events to ignore when in dev mode (can be event name string, hash)

return

nil

When enabled, logs all events in the group. Use eventsToIgnore to filter out noise.

    -- Enable dev mode and ignore specific events
    event:DevMode(true, {"EVENT_PED_CREATED", "EVENT_PED_DESTROYED"})
    
    -- Enable dev mode for all events
    event:DevMode(true)
    
    -- Disable dev mode
    event:DevMode(false)

DataView

this module provides JavaScript-like DataView functionality for handling binary data in Lua with support for various data types and endianness this module is based on gottfriedleibniz’s DataView implementation providing efficient binary data manipulation

DataView

Streaming

this module provides utility functions for loading various game assets like models, animations, textures, and more with automatic cleanup and timeout handling all functions handle the loading process with proper validation and error handling, preventing common issues with asset streaming

Asset Loading

Class

this module provides a complete object-oriented programming system for Lua with classes, inheritance, private members, and automatic getters/setters supports both traditional Lua OOP patterns and modern structured approaches with automatic property management was inspired by JavaScript classes

OOP System

use these methods below to create classes with full OOP support

Create

base

table|class

Base class to inherit from, or table of initial methods/properties

className

string

Optional name for the class (used in error messages)

return

class

Returns a new class that can create instances with :New()

    -- Import the class module
    local Lib = Import 'class' --[[@as CLASS]]
    
    -- Create a basic class
    local MyClass = Lib.Class:Create({
        constructor = function(self, name)
            self.name = name
        end,
        
        getName = function(self)
            return self.name
        end
    }, "MyClass")
    
    -- Create instance
    local instance = MyClass:New("Test")
    print(instance:getName()) -- "Test"

Traditional Lua example

 local MyClass = Lib.Class:Create({},"MyClass")

 function MyClass:constructor(name)
    self.name = name
 end

 function MyClass:getName()
    return self.name
 end

 local instance = MyClass:New("Test")
 print(instance:getName()) -- "Test"

New

...

any

Arguments to pass to the constructor

return

instance

Returns a new instance of the class

Creates new instances of the class. Supports both table-based and argument-based constructors.

    -- Table-based constructor
    local instance1 = MyClass:New({
        name = "John",
        age = 30
    })
    
    -- Argument-based constructor  
    local instance2 = MyClass:New("John", 30)

Functions

utility classes for control flow, timing, and conditional execution provides Switch-case patterns, repeating intervals, and one-time timeouts with full control over execution state shared between server and client environments

Switch

use these utilities for advanced control flow and timing operations

value

any

The value to match against cases

creates a switch-case control structure that allows chaining case statements and default handling inspired by JS

     -- Import the functions module
     local Lib = Import 'functions' --[[@as FUNCTIONS]]
     
     -- Basic switch usage
     local result = Lib.Switch(playerLevel)
        :case(1, function(value) 
            return "Beginner" 
        end)
         :case(2, function(value) 
            return "Intermediate" 
        end)
         :case(3, function(value) 
            return "Advanced" 
        end)
         :default(function(value) 
            return "Unknown Level: " .. value 
        end)
        :execute()
     
    print(result)

Notify

notification module for displaying various types of notifications to players from the base game supports both server and client environments with different method signatures

Notify

Exports

Selector

This Selector allows you to select players with a NUI selector that will return the player id that was selected

Select

allow_self

boolean

Allow self selection

amount_of_players

integer

Amount of players to select

distance

number

Distance to select players

allow_in_vehicle

boolean

Allow selection of players in vehicles

allow_on_horse

boolean

Allow selection of players on horses

playerid

integer

The player id that was selected

local result <const> = exports.vorp_lib:Select({
    allow_self = true, 
    amount_of_players = 4,
    distance = 8.0,  
    allow_in_vehicle = true,
    allow_on_horse = true 
})

ProgressBar

Allows you to create a progress bar that will be displayed on screen for a specified amount of time

Start

text

string

required

Text to display in the progress bar

colors

table

required

Table with the colors for the progress bar startColor and endColor are the colors for the text and backgroundColor and fillColor are the colors for the background and the fill of the progress bar image

duration

integer

required

Duration in milliseconds for the progress bar

type

string

required

Type of progress bar only linear is avaliable for now

position

table

required

Table with the position for the progress bar on screen top and left are the position in % for the progress bar

image

string

Image for the progress bar only png is avaliable for now

callback

function

Callback function if you want to use it as async

return

boolean

the result of the progress bar true or false if false the progress bar was cancelled

local data = {
    text = 'Some text here',
    colors = {
        -- for text
        startColor = 'white', -- starting color of the text
        endColor = 'black', -- ending color of the text
        -- these colors are filters they dont really represent the color that well but its an option if you want to change it
        -- for background
        -- https://colorpicker.dev/#21d70d use this website choose hwb and its the first number just add deg to it like this 330deg

        -- backgroundColor = '0deg', -- Changes grey bar to blue-ish
        --fillColor = '120deg',     -- Changes white bar to green-ish
    },
    duration = 5000,
    type = 'linear',                    -- only linear is avaliable for now
    position = { top = 90, left = 50 }, -- in % for position on the screen
    image = 'score_timer_extralong',    -- only png this is optional you can add your own image , images must be in this script images folder
}

-- SYNC
local result = exports.vorp_lib:progressStart(data)
if not result then
    print('cancelled')
else
    print('completed')
end

--OR ASYNC
exports.vorp_lib:progressStart(data, function(result)
    if result then
        print('Progress bar completed')
    else
        print('Progress bar cancelled')
    end
end)

Cancel

Density

Not yet implemented

Collector

Not yet implemented

API Documentation

​Lib usage

​Module Import

​List of Modules

​Importing Modules

​Import Usage

​Modules

​Entities

​Map

​Inputs

​Prompts

​Commands

​Points

​Events

​DataView

​Streaming

​Class

​Functions

​Notify

​Exports

​Selector

​ProgressBar

​Density

​Collector

Lib usage

Module Import

List of Modules

Importing Modules

Import Usage

Modules

Entities

Map

Inputs

Prompts

Commands

Points

Events

DataView

Streaming

Class

Functions

Notify

Exports

Selector

ProgressBar

Density

Collector