Version Bump

- Added ability to choose circle/bar type
- Added ability for props when using progbar

.github/workflows/notify-discord.yml

@@ -0,0 +1,17 @@
+name: Discord Commit Notifier
+
+on:
+  push:
+    branches:
+      - '*'  # triggers on all branches
+
+jobs:
+  notify:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Discord Commits
+        uses: Sniddl/discord-commits@v1.6
+        with:
+          webhook: ${{ secrets.DISCORD_WEBHOOK }}
+          template: "avatar-with-link"
+          include-extras: true

_versioncheck.lua

@@ -1,4 +1,4 @@
-function parseVersion(version)
+local function parseVersion(version)
     local parts = {}
     for num in version:gmatch("%d+") do
         table.insert(parts, tonumber(num))
@@ -6,7 +6,7 @@ function parseVersion(version)
     return parts
 end
 
-function compareVersions(current, newest)
+local function compareVersions(current, newest)
     local currentParts = parseVersion(current)
     local newestParts = parseVersion(newest)
     for i = 1, math.max(#currentParts, #newestParts) do
@@ -20,28 +20,48 @@ end
 
 function CheckBridgeVersion()
     if IsDuplicityVersion() then
-		CreateThread(function()
-			Wait(4000)
-			local currentVersionRaw = GetResourceMetadata("jim_bridge", 'version')
-			PerformHttpRequest('https://raw.githubusercontent.com/jimathy/jim_bridge/master/version.txt', function(err, newestVersionRaw, headers)
-				if not newestVersionRaw then
-					print("^1Unable to run version check for ^7'^3jim_bridge^7' (^3"..currentVersionRaw.."^7)")
-					return
-				end
+        CreateThread(function()
+            Wait(4000)
+            local currentVersionRaw = GetResourceMetadata("jim_bridge", 'version')
+			--PerformHttpRequest('https://raw.githubusercontent.com/jimathy/UpdateVersions/master/test.txt', function(err, body, headers)
+			PerformHttpRequest('https://raw.githubusercontent.com/jimathy/jim_bridge/master/version.txt', function(err, body, headers)
+                if not body then
+                    print("^1Unable to run version check for ^7'^3jim_bridge^7' (^3"..currentVersionRaw.."^7)")
+                    return
+                end
 
-				newestVersionRaw = newestVersionRaw:match("[^\r\n]+")
-				local compareResult = compareVersions(currentVersionRaw, newestVersionRaw)
+                local lines = {}
+                for line in body:gmatch("[^\r\n]+") do
+                    table.insert(lines, line)
+                end
 
-				if compareResult == 0 then
-					print("^7'^3jim_bridge^7' - ^2You are running the latest version^7. ^7(^3"..currentVersionRaw.."^7)")
-				elseif compareResult < 0 then
-					print("^7'^3jim_bridge^7' - ^1You are running an outdated version^7! ^7(^3"..currentVersionRaw.."^7 → ^3"..newestVersionRaw.."^7)")
-				else
-					print("^7'^3jim_bridge^7' - ^5You are running a newer version ^7(^3"..currentVersionRaw.."^7 ← ^3"..newestVersionRaw.."^7)")
-				end
-			end)
-		end)
-	end
+                local newestVersionRaw = lines[1] or "0.0.0"
+                local changelog = {}
+                for i = 2, #lines do
+                    table.insert(changelog, lines[i])
+                end
+
+                local compareResult = compareVersions(currentVersionRaw, newestVersionRaw)
+
+                if compareResult == 0 then
+                    print("^7'^3jim_bridge^7' - ^2You are running the latest version^7. ^7(^3"..currentVersionRaw.."^7)")
+                elseif compareResult < 0 then
+                    print("^1----------------------------------------------------------------------^7")
+                    print("^7'^3jim_bridge^7' - ^1You are running an outdated version^7! ^7(^3"..currentVersionRaw.."^7 → ^3"..newestVersionRaw.."^7)")
+                    for _, line in ipairs(changelog) do
+                        print((line:find("http") and "^7" or "^5")..line)
+                    end
+                    print("^1----------------------------------------------------------------------^7")
+                    SetTimeout(1200000, function()
+                        CheckBridgeVersion()
+                    end)
+                else
+                    print("^7'^3jim_bridge^7' - ^5You are running a newer version ^7(^3"..currentVersionRaw.."^7 ← ^3"..newestVersionRaw.."^7)")
+                end
+            end)
+        end)
+    end
 end
 
+
 CheckBridgeVersion()

documentation/animal_ped_support.md

@@ -0,0 +1,58 @@
+## Animal Ped Support
+### isAnimal.lua
+This module provides logic to detect if a Ped or model is an animal and classify it into specific categories (cat, dog, coyote, etc.). Useful for wildlife, animal roles, or pet systems.
+
+❔At player load in, it attempts to get what kind of ped/animal you are but there are functions to double check in scripts
+
+❔Alot of this is used to determine what models/animations are available
+
+Global flags:
+- `isCat`, `isDog`, `isBigDog`, `isSmallDog`, `isCoyote`, `isAnimal` — used to store classification of the player's current ped.
+
+- **isPedAnimal(ped?)**
+
+  - Checks if a ped is an animal based on predefined animal models.
+  - Sets global `isAnimal` to true if matched.
+  - **Example:**
+    ```lua
+    local isPlayerAnimal = isPedAnimal()
+    local isOtherPedAnimal = isPedAnimal(GetPedInVehicleSeat(vehicle, -1))
+    ```
+
+- **isCat(ped)**
+
+  - Returns true if the ped model matches a cat.
+  - **Example:**
+    ```lua
+    if isCat() then print("You're a cat!") end
+    ```
+
+- **isDog(ped)**
+
+  - Returns two values:
+    - `true`, `true` — if ped is a big dog
+    - `true`, `false` — if ped is a small dog
+    - `false`, `nil` — if not a dog
+  - **Example:**
+    ```lua
+    local isDog, isBig = isDog()
+    if isDog then print(isBig and "Big Dog" or "Small Dog") end
+    ```
+
+- **getAnimalModels()**
+
+  - Returns a flat list of all registered animal model hashes.
+  - Can be used to check ped models against
+  - **Example:**
+    ```lua
+    for _, model in pairs(getAnimalModels()) do print(model) end
+    ```
+
+- **getAnimalAnims(ped)**
+
+  - Returns the animation set defined for the given animal model.
+  - **Example:**
+    ```lua
+    local anims = getAnimalAnims(PlayerPedId())
+    if anims then playAnim(anims.sitDict, anims.sitAnim) end
+    ```

documentation/helper_functions/helpers.md

@@ -0,0 +1,177 @@
+### helpers.lua
+This utility module provides functions for resource checks, debugging, formatting, coordinate math, vector calculations, progress bars, and drawing tools.
+
+- **isStarted(script)**
+  - Returns `true` if a resource is started.
+  - **Example:**
+    ```lua
+    if isStarted("myResource") then print("Resource is running") end
+    ```
+
+- **getScript()**
+  - Caches and returns the name of the current resource.
+  - Easier than typing `GetCurrentResourceName()` over and over
+  - **Example:**
+    ```lua
+    print("Current script:", getScript())
+    ```
+
+- **isServer()**
+  - Returns true if running on the server.
+  - This was mainly made becuase `IsDuplicityVersion()` kept confusing me
+  - **Example:**
+    ```lua
+    if isServer() then print("Server-side!") end
+    ```
+
+- **debugPrint(...)** / **eventPrint(...)**
+  - Prints messages with debug context if debugMode is enabled.
+  - **Example:**
+    ```lua
+    debugPrint("Loaded object:", objName)
+    ```
+
+- **jsonPrint(table)**
+  - Pretty-prints a table with colorized JSON if debugMode is enabled.
+  - **Example:**
+    ```lua
+    jsonPrint(myData)
+    ```
+
+- **keyGen()**
+  - Generates a 3-character unique ID.
+  - Good grabbing randomly generated strings
+  - **Example:**
+    ```lua
+    print("Generated Key:", keyGen())
+    ```
+
+- **cv(amount)**
+  - Comma-separates a number (e.g., `1000000` to `1,000,000`).
+  - **Example:**
+    ```lua
+    print(cv(1000000)) -- "1,000,000"
+    ```
+
+- **formatCoord(vec)**
+  - Outputs a formatted string from vector types.
+  - Compacts and adds console colours to the vector to be printed
+  - **Example:**
+    ```lua
+    print(formatCoord(vector3(123.45, 678.9, 10.0)))
+    ```
+
+- **getCenterOfZones(coords)**
+  - Returns average center position of a vector3 list.
+  - A few use cases, but I used it to see how well spaced blips were together
+  - **Example:**
+    ```lua
+    local center = getCenterOfZones({vector3(0,0,0), vector3(10,10,0)})
+    ```
+
+- **countTable(tbl)**
+  - Returns the number of entries in a table.
+  - Simple function to print how many "entires" are in a table
+  - **Example:**
+    ```lua
+    print(countTable({a=1,b=2,c=3})) -- 3
+    ```
+
+- **pairsByKeys(tbl)**
+  - Iterator for sorted keys.
+  - **Example:**
+    ```lua
+    for k, v in pairsByKeys(myTable) do print(k, v) end
+    ```
+
+- **concatenateText(tbl)**
+  - Joins string table entries with newlines.
+  - **Example:**
+    ```lua
+    print(concatenateText({"Line 1", "Line 2"}))
+    ```
+
+- **RotationToDirection(rot)**
+  - Converts a heading vector to a directional vector.
+  - **Example:**
+    ```lua
+    local dir = RotationToDirection(rotation)
+    ```
+
+- **basicBar(percent)**
+  - Returns a bar like `████░░░░░` at 50%.
+  - Basically a progress bar but as a string, I use this in drawTexts when progressbars aren't able to be used
+  - **Example:**
+    ```lua
+    print(basicBar(50))
+    ```
+
+- **normalizeVector(vec)**
+  - Returns a normalized version of a vector3.
+  - **Example:**
+    ```lua
+    local norm = normalizeVector(vector3(3,4,0))
+    ```
+
+- **drawLine(start, end, color)** / **drawSphere(pos, color)**
+  - Debug drawing helpers.
+  - Stays visible for more than one frame
+  - **Example:**
+    ```lua
+    drawLine(vector3(0,0,0), vector3(10,10,10), vector4(255,0,0,255))
+    drawSphere(vector3(5,5,5), vector4(0,255,0,255))
+    ```
+
+- **PerformRaycast(start, end, entity?, flags?)**
+  - Raycast with material detection. Returns ray hit data.
+  - **Example:**
+    ```lua
+    local hit, hitPos, material = PerformRaycast(startVec, endVec, playerPed, 1)
+    if hit == 1 then
+        print("Hit at position:", hitPos)
+        print("Material:", material)
+    end
+    ```
+
+- **adjustForGround(coords)**
+  - Adjusts a z-coordinate to ground height.
+  - **Example:**
+    ```lua
+    coords = adjustForGround(vector3(100, 200, 300))
+    ```
+
+- **ensureNetToVeh(id)** / **ensureNetToEnt(id)**
+  - Resolves net ID to entity safely.
+  - **Example:**
+    ```lua
+    local veh = ensureNetToVeh(netId)
+    ```
+
+- **sendLog(text)** / **sendServerLog(data)**
+  - Logging helpers, includes player name, coords, script source.
+  - **Example:**
+    ```lua
+    sendLog("Suspicious activity detected")
+    ```
+
+- **GetGroundMaterialAtPosition(coords)**
+  - Returns the material hash + readable name from the surface below coords.
+  - **Example:**
+    ```lua
+    local hash, name = GetGroundMaterialAtPosition(vector3(0,0,0))
+    ```
+
+- **GetPropDimensions(model)**
+  - Loads a model and returns width, depth, height.
+  - I use this to parse a model to create a box target instead of entity target when creating distProps/distPeds
+  - **Example:**
+    ```lua
+    local w,d,h = GetPropDimensions("prop_barrel_01a")
+    ```
+
+- **GetEntityForwardVector(entity)**
+  - Returns the forward direction vector based on entity heading.
+  - **Example:**
+    ```lua
+    local fwd = GetEntityForwardVector(PlayerPedId())
+    ```

documentation/helper_functions/loaders.md

@@ -0,0 +1,89 @@
+### loaders.lua
+This module provides loading utilities for common asset types such as models, animations, texture dictionaries, and audio banks. It also provides animation and sound helpers.
+
+- **loadModel(model)**
+  - Loads a model into memory if valid and not already loaded.
+  - **Example:**
+    ```lua
+    loadModel('prop_chair_01a')
+    ```
+
+- **unloadModel(model)**
+  - Unloads a model from memory.
+  - **Example:**
+    ```lua
+    unloadModel('prop_chair_01a')
+    ```
+
+- **loadAnimDict(animDict)**
+  - Loads an animation dictionary into memory.
+  - **Example:**
+    ```lua
+    loadAnimDict('amb@world_human_hang_out_street@male_c@base')
+    ```
+
+- **unloadAnimDict(animDict)**
+  - Removes an animation dictionary from memory.
+  - **Example:**
+    ```lua
+    unloadAnimDict('amb@world_human_hang_out_street@male_c@base')
+    ```
+
+- **loadPtfxDict(ptFxName)**
+  - Loads a particle effect (ptfx) dictionary.
+  - **Example:**
+    ```lua
+    loadPtfxDict('core')
+    ```
+
+- **unloadPtfxDict(dict)**
+  - Unloads a particle effect dictionary from memory.
+  - **Example:**
+    ```lua
+    unloadPtfxDict('core')
+    ```
+
+- **loadTextureDict(dict)**
+  - Loads a streamed texture dictionary.
+  - **Example:**
+    ```lua
+    loadTextureDict('commonmenu')
+    ```
+
+- **loadScriptBank(bank)**
+  - Loads a script audio bank.
+  - Returns true on success.
+  - **Example:**
+    ```lua
+    local success = loadScriptBank('DLC_HEISTS_GENERAL_FRONTEND_SOUNDS')
+    ```
+
+- **loadAmbientBank(bank)**
+  - Loads an ambient audio bank.
+  - Returns true on success.
+  - **Example:**
+    ```lua
+    local success = loadAmbientBank('AMB_REVERB_GENERIC')
+    ```
+
+- **playAnim(animDict, animName, duration?, flag?, ped?, speed?)**
+  - Plays an animation on a ped.
+  - Loads the dictionary if not already loaded.
+  - **Example:**
+    ```lua
+    playAnim('amb@world_human_hang_out_street@male_c@base', 'base', 5000, 1, PlayerPedId(), 1.0)
+    ```
+
+- **stopAnim(animDict, animName, ped?)**
+  - Stops an animation and unloads the dictionary.
+  - **Example:**
+    ```lua
+    stopAnim('amb@world_human_hang_out_street@male_c@base', 'base', PlayerPedId())
+    ```
+
+- **playGameSound(audioBank, soundSet, soundRef, coords, synced, range?)**
+  - Plays a game sound from a coordinate or entity.
+  - **Example:**
+    ```lua
+    playGameSound('DLC_HEIST_HACKING_SNAKE_SOUNDS', 'Beep', vector3(0, 0, 0), false, 15.0)
+    ```

documentation/main_functions/callbacks.md

@@ -0,0 +1,38 @@
+### callback.lua
+
+These functions wrap the native callback handling of the selected framework (e.g., OX, QBCore, ESX) instead of implementing a standalone callback system, ensuring full compatibility.
+
+- **createCallback(callbackName, funct)**
+
+  - Registers a callback function with the appropriate framework.
+  - This function checks which framework is started (e.g., OX, QB, ESX) and registers the callback accordingly.
+  - It adapts the callback function to match the expected signature for the framework.
+  - **Example:**
+    ```lua
+    local table = { ["info"] = "HI" }
+    createCallback('myCallback', function(source, ...)
+        return table
+    end)
+
+    createCallback("callback:checkVehicleOwned", function(source, plate)
+        local result = isVehicleOwned(plate)
+        if result then
+            return true
+        else
+            return false
+        end
+    end)
+    ```
+
+- **triggerCallback(callbackName, ...)**
+
+  - Triggers a server callback and returns the result.
+  - This function uses the appropriate framework's method to call the server-side callback and awaits the result.
+  - **Example:**
+    ```lua
+    local result = triggerCallback('myCallback')
+    jsonPrint(result)
+
+    local result = triggerCallback("callback:checkVehicleOwned", plate)
+    print(result)
+    ```

documentation/main_functions/cameras.md

@@ -0,0 +1,28 @@
+### cameras.lua
+This module provides utilities for managing temporary in-game cameras, useful for cutscenes, cinematic views, or scripted perspectives.
+
+- **createTempCam(ent, coords)**
+
+  - Creates a temporary camera at the specified coordinates or relative to an entity.
+  - If `ent` is an entity, the camera position is calculated as an offset from the entity's position using `GetOffsetFromEntityInWorldCoords`.
+  - If `ent` is a `vector3`, it is used directly as the camera's position.
+  - **Example:**
+    ```lua
+    local cam = createTempCam(PlayerPedId(), GetEntityCoords(PlayerPedId()) + vector3(0, 2.0, 1.0))
+    ```
+
+- **startTempCam(cam)**
+
+  - Activates and renders the temporary camera.
+  - **Example:**
+    ```lua
+    startTempCam(cam)
+    ```
+
+- **stopTempCam()**
+
+  - Deactivates and deletes all currently running custom camera, restoring normal view.
+  - **Example:**
+    ```lua
+    stopTempCam()
+    ```

documentation/main_functions/contextmenus.md

@@ -0,0 +1,45 @@
+### contextmenus.lua
+
+These functions provide a unified way to interact with different context menu systems, such as OX and WarMenu, depending on what's available on the server.
+
+- **openMenu(Menu, data)**
+
+  - Opens a context menu using the preferred menu system.
+  - Automatically selects between supported systems like OX or WarMenu based on availability.
+  - The `Menu` parameter should be a list of menu entries, and the `data` parameter can be used to set headers, subtexts, and actions like `onBack`, `onExit`, and `canClose`.
+  - **Example:**
+    ```lua
+    openMenu({
+        { header = "Option 1", txt = "Description 1", onSelect = function() print("Option 1 selected") end },
+        { header = "Option 2", txt = "Description 2", onSelect = function() print("Option 2 selected") end },
+    }, {
+        header = "Main Menu",
+        headertxt = "Select an option",
+        onBack = function() print("Return selected") end,
+        onExit = function() print("Menu closed") end,
+        canClose = true,
+    })
+    ```
+
+- **isOx()**
+
+  - Checks whether the OX context menu system is available on the server.
+  - Allows to do specific things if ox_lib menu is in use
+  - **Example:**
+    ```lua
+    if isOx() then
+        print("OX Context Menu is available")
+    end
+    ```
+
+- **isWarMenuOpen()**
+
+  - Returns whether WarMenu is currently open.
+  - Useful to prevent opening a new menu if one is already active.
+  - **Example:**
+    ```lua
+    if not isWarMenuOpen() then
+        openMenu("main_menu", menuData)
+    end
+    ```
+  - Returns whether the WarMenu is currently open.

documentation/main_functions/crafting.md

@@ -0,0 +1,39 @@
+### crafting.lua
+
+These functions support crafting logic, such as opening crafting menus, handling multi-craft operations, and creating item data from recipes.
+
+- **craftingMenu(data)**
+
+  - Opens a menu for selecting the quantity to craft.
+  - Presents the player with multiple crafting quantities based on `Config.Crafting.MultiCraftAmounts`.
+  - **Parameters:**
+    - `item` (`string`): The item to craft.
+    - `craft` (`table`): The crafting recipe.
+    - `craftable` (`table`): Crafting options.
+    - `coords` (`vector3`): Where crafting occurs.
+    - `stashName` (`string`): The stash name(s) for item availability.
+    - `onBack` (`function`): Callback when returning.
+    - `metadata` (`table`, optional): Metadata for the crafted item.
+  - **Example:**
+    ```lua
+    craftingMenu({
+         craftable = {
+             Header = "Weapon Crafting",
+             Recipes = {
+                 [1] = {
+                     ["weapon_pistol"] = { ["steel"] = 5, ["plastic"] = 2 },
+                     amount = 1,
+                 },
+                 -- More recipes...
+             },
+             Anims = {
+                 animDict = "amb@prop_human_parking_meter@male@idle_a",
+                 anim = "idle_a",
+             },
+         },
+         coords = vector3(100.0, 200.0, 300.0),
+         stashTable = "crafting_stash",
+         job = "mechanic",
+         onBack = function() print("Returning to previous menu") end,
+    })
+    ```

documentation/main_functions/drawtext.md

@@ -0,0 +1,25 @@
+### drawText.lua
+
+These functions handle drawing and hiding styled on-screen prompts or UI overlays, compatible with different styling frameworks such as OX Lib.
+
+- **drawText(image, input, style, oxStyleTable)**
+
+  - Displays styled text or prompts on screen.
+  - Designed to adapt styling depending on which UI system (e.g., OX) is in use.
+  - **Parameters:**
+    - `image` (`string`): Optional icon or image path.
+    - `input` (`string`): The main text to display.
+    - `style` (`string|table`): Preset or custom styling.
+    - `oxStyleTable` (`table`, optional): Extended style options if using OX UI.
+  - **Example:**
+    ```lua
+    drawText("img_link", { "Test line 1", "Test Line 2" }, "~g~")
+    ```
+
+- **hideText()**
+
+  - Hides any active text or UI element previously drawn with `drawText()`.
+  - **Example:**
+    ```lua
+    hideText()
+    ```

documentation/main_functions/duifunctions.md

@@ -0,0 +1,31 @@
+### duifunctions.lua
+
+These functions support dynamic UI image rendering in 3D environments using runtime texture dictionaries. Ideal for integrating `nui://` or external `http://` image URLs into MLOs or world props.
+
+- **createDui(name, http, size, txd))**
+
+  - Sets up a runtime texture dictionary and links an image from a `nui://` or `http://` URL.
+  - This function should be used once to create the texture dictionary needed for rendering Dui images.
+  - **Example:**
+    ```lua
+    createDui("logo", "https://example.com/logo.png", { x = 512, y = 256 }, scriptTxd)
+    ```
+
+- **DuiSelect(data)**
+
+  - Updates the URL on an existing texture dictionary to change the rendered image.
+  - Can be used at runtime to swap out visuals in MLOs or props.
+  - **Parameters:**
+    - `textureDict` (`string`): The texture dictionary to target.
+    - `texture` (`string`): The specific texture name to override.
+    - `url` (`string`): The new image URL.
+    - `width`, `height` (`number`): The texture resolution.
+  - **Example:**
+    ```lua
+    DuiSelect({
+        name = "logo",
+        texn = "logoTex",
+        texd = "someTxd",
+        size = { x = 512, y = 256 }
+    })
+    ```

documentation/main_functions/input.md

@@ -0,0 +1,25 @@
+### input.lua
+
+This function displays a customizable input dialog for user text or number entry. It supports both simple and complex input structures.
+
+- **createInput(title, opts)**
+  - Opens a styled input dialog with configurable fields, labels, input types, and validation.
+  - Supports multiple field types including `text`, `number`, `password`, `checkbox`, `color`, `slider`, and more.
+  - **Parameters:**
+    - `title` (`string`): Title displayed at the top of the input box.
+    - `opts` (`table`): A table of fields with attributes like `label`, `name`, `type`, `value`, and more.
+  - **Example:**
+    ```lua
+    local userInput = createInput("Enter Details", {
+        { type = "text", text = "Name", name = "playerName", isRequired = true },
+        { type = "number", text = "Age", name = "playerAge", min = 18, max = 99 },
+        { type = "radio", label = "Gender", name = "playerGender", options = {
+            { text = "Male", value = "male" },
+            { text = "Female", value = "female" },
+            { text = "Other", value = "other" },
+        }},
+    })
+    if userInput then
+        print(json.encode(userInput))
+    end
+    ```

documentation/main_functions/inventories.md

@@ -0,0 +1,144 @@
+### inventories.lua
+
+These functions manage inventory locking, item checking, and player inventory retrieval.
+
+- **lockInv(toggle)**
+
+  - Locks or unlocks the player's inventory.
+  - Freezes/unfreezes movement and toggles hotbar state.
+  - **Example:**
+    ```lua
+    lockInv(true)  -- Lock inventory
+    lockInv(false) -- Unlock inventory
+    ```
+
+- **hasItem(items, amount, src)**
+
+  - Checks if a player has the specified item(s) in sufficient quantity.
+  - **Returns:**
+    - `boolean`: Whether the player has the item(s).
+    - `table`: Details of available item counts.
+  - **Example:**
+    ```lua
+    local hasAll, details = hasItem({"health_potion", "mana_potion"}, 2, playerId)
+    if hasAll then
+        -- Proceed with action
+    else
+        -- Inform the player about missing items
+    end
+    ```
+
+- **getPlayerInv(src)**
+
+  - Retrieves the player’s current inventory.
+  - May be used for inventory UI, logging, or crafting systems.
+  - **Example:**
+    ```lua
+    local inventory = getPlayerInv(playerId)
+    for k, item in pairs(inventory) do
+        print(item.name, item.amount)
+    end
+    ```
+
+### itemcontrol.lua
+
+This module includes a variety of utility functions for managing items in player inventories, including giving, removing, durability, and use logic.
+
+- **createUseableItem(item, funct)**
+
+  ⚠️ This doesn't work for `ox_inv`, you will need to add the event info to it's `items.lua`
+  - Registers a useable item and binds it to a callback function.
+  - **Example:**
+    ```lua
+    createUseableItem("bandage", function(source)
+        -- Heal logic here
+    end)
+    ```
+
+- **invImg(item)**
+
+  - Returns the inventory image path for an item.
+  - Automatically grabs the inventory image link based on inventory script
+  - **Example:**
+    ```lua
+    local imagePath = invImg("water_bottle")
+    print(imagePath)
+    ```
+
+- **addItem(item, amount, info, src)**
+
+  ⚠️ Requires Auth callback if called from client side
+  - Adds a specific amount of an item to a player's inventory.
+  - Automatically attempts to add items using detected inventory script
+  - **Example:**
+    ```lua
+    -- Client Side
+    addItem("lockpick", 3, {})
+
+    -- Server Side
+    addItem("lockpick", 3, {}, source)
+    ```
+
+- **removeItem(item, amount, src, slot)**
+
+  - Removes a specific amount of an item from a player’s inventory.
+  - Automatically attempts to remove item using detected inventory script
+  - **Example:**
+    ```lua
+    -- Client Side
+    removeItem(
+        "ammo_pistol",
+        30,
+        nil,
+        slot --[[optional]]--
+    )
+
+    -- Server Side
+    removeItem(
+        "ammo_pistol",
+        30,
+        source,
+        slot --[[optional]]--
+    )
+    ```
+
+- **dupeWarn(src, item, amount)**
+
+  - Logs or handles a potential duplication exploit involving an item.
+  - This is called automatically if a player has been triggered exploit detection
+  - Disabled if debugMode is enabled
+
+- **breakTool(data)**
+
+  - Breaks a tool or item, often due to exceeding durability.
+  - **Example:**
+    ```lua
+    breakTool({ item = "drill", damage = 10 })
+    ```
+
+- **getDurability(item)**
+
+  - Returns the current durability value of a given item.
+  - Searched for the lowest slot number (eg. slot 1) and retreives that items durability
+  - **Example:**
+    ```lua
+    local durability, slot = getDurability("drill")
+    if durability then
+        print("Durability:", durability)
+        print("Slot:", slot)
+    end
+    ```
+
+- **canCarry(itemTable, src)**
+
+  ⚠️ Currently server side only
+  - Checks if a player can carry the item(s) specified in `itemTable`.
+  - **Example:**
+    ```lua
+    local carryCheck = canCarry({ ["health_potion"] = 2, ["mana_potion"] = 3 }, playerId)
+    if carryCheck["health_potion"] and carryCheck["mana_potion"] then
+        -- Player can carry items.
+    else
+        -- Notify player.
+    end
+    ```

documentation/main_functions/jobfunctions.md

@@ -0,0 +1,64 @@
+### jobfunctions.lua
+
+This module provides functions for managing job-based logic, such as checking player roles, toggling duty status, and simulating job-related interactions.
+
+- **makeBossRoles(role)**
+
+  - Sets up boss-level permissions or access for the specified job role.
+  - Often used to determine if a player can access job menus or perform administrative actions.
+  - Used mainly for creating boss locked target tables
+  - **Example:**
+    ```lua
+    makeBossRoles("police")
+    ```
+
+- **jobCheck(job)**
+
+  - Simple check if the player has the specified job.
+  - **Example:**
+    ```lua
+    if jobCheck("mechanic") then
+        -- Allow mechanic features.
+    else
+        -- Deny access.
+    end
+    ```
+
+- **toggleDuty()**
+
+  - Toggles the player’s on/off duty status, typically used for jobs like police, EMS, etc.
+  - **Example:**
+    ```lua
+    toggleDuty()
+    ```
+
+- **washHands(data)**
+
+  - Simulates the action of washing hands, used in job scripts or medical job logic.
+  - Currently only animation and a notfication
+  - **Example:**
+    ```lua
+    washHands({ coords = vector3(200.0, 300.0, 40.0) })
+    ```
+
+- **useToilet(data)**
+
+  - Triggers toilet-use interaction, likely includes animation or sound.
+  - Currently only animation and a notfication
+  - **Example:**
+    ```lua
+    useToilet({ urinal = true })
+    -- Player uses a urinal with corresponding animations and notifications
+
+    useToilet({ urinal = false, sitcoords = vector4(215.76, -810.12, 29.73, 90.0) })
+    -- Player sits down to use a toilet with corresponding animations and notifications
+    ```
+
+- **useDoor(data)**
+
+  - Handles interactions with doors that aren't openable and teleports the player
+  - eg. Recycle Center, it's used to teleport the player from outside a building to the IPL
+  - **Example:**
+    ```lua
+    useDoor({ telecoords = vector4(215.76, -810.12, 29.73, 90.0) })
+    ```

documentation/main_functions/makefunctions.md

@@ -0,0 +1,156 @@
+### makeBlip.lua
+
+This module provides simple utilities for adding static or entity-based blips to the minimap.
+
+❔ This has basic support for RedM too
+- **makeBlip(data)**
+
+  - This function adds a map blip at the provided coordinates and sets various display properties such as sprite, color, scale, and more.
+  - It also handles attaching a preview image to the blip if certain resources are running and a preview is provided.
+  - **Example:**
+    ```lua
+    local blipData = {
+        coords = vector3(123.4, 567.8, 90.1),
+        sprite = 1,
+        col = 2,
+        scale = 0.8,
+        disp = 4,
+        category = 7,
+        name = "My Blip",
+        preview = "http://example.com/preview.png"
+    }
+    local blip = makeBlip(blipData)
+    ```
+
+- **makeEntityBlip(data)**
+
+  - This function adds a map blip attached to the provided entity and sets various display properties such as sprite, color, scale, and more.
+  - It also handles attaching a preview image to the blip if certain resources are running and a preview is provided.
+  - **Example:**
+    ```lua
+    local blipData = {
+        entity = myEntity,
+        sprite = 1,
+        col = 2,
+        scale = 0.8,
+        disp = 4,
+        category = 7,
+        name = "Entity Blip",
+        preview = "http://example.com/preview.png"
+    }
+    local blip = makeEntityBlip(blipData)
+    ```
+
+### makePed.lua
+This module provides tools to create persistent or distance-based NPCs with optional animations, scenarios, and config randomization.
+
+- **makeDistPed(data, coords, freeze, collision, scenario, anim, synced)**
+
+  - Creates a ped that only spawns when nearby (performance optimization).
+  - **Example:**
+    ```lua
+    makeDistPed({model = "a_m_y_business_03" },                                 -- model data
+        vector4(450.0, -980.0, 30.0, 100.0),                                    -- coords
+        true,                                                                   -- freeze entity
+        false,                                                                  -- collision
+        'WORLD_HUMAN_STAND_IMPATIENT',                                          -- Scenario Animation
+        { dict = "amb@world_human_clipboard@male@idle_a", anim = "idle_c" },    -- Anim Table
+        true                                                                    -- Network Synced
+    )
+    ```
+
+- **makePed(data, coords, freeze, collision, scenario, anim, synced)**
+
+  - Spawns a ped with more persistent behavior at the given location.
+  - Supports animation playback and freezing.
+  - **Example:**
+    ```lua
+    makePed({model = "a_m_y_business_03" },                                 -- model data
+        vector4(450.0, -980.0, 30.0, 100.0),                                    -- coords
+        true,                                                                   -- freeze entity
+        false,                                                                  -- collision
+        'WORLD_HUMAN_STAND_IMPATIENT',                                          -- Scenario Animation
+        { dict = "amb@world_human_clipboard@male@idle_a", anim = "idle_c" },    -- Anim Table
+        true                                                                    -- Network Synced
+    )
+    ```
+
+- **GenerateRandomPedData(data)**
+
+  - Returns randomized ped model/configuration based on input table.
+  - Useful for dynamic NPC generation.
+  - **Example:**
+    ```lua
+    local pedData = GenerateRandomPedData({ model = `MP_M_Freemode_01`, custom = {} })
+    ```
+
+### makeProp.lua
+This module allows you to spawn static or distance-loaded props in the world.
+
+- **makeProp(data, freeze, synced)**
+
+  - This function loads the model, creates the object, sets its heading, and freezes it if specified.
+  - **Example:**
+    ```lua
+    local propData = {
+        prop = 'prop_chair_01a',
+        coords = vector4(123.4, 567.8, 90.1, 180.0)
+    }
+    local prop = makeProp(propData, true, false)
+    ```
+
+- **makeDistProp(data, freeze, synced, range)**
+  - Same as `makeProp`, but only spawns if the player is within the specified range.
+  - **Example:**
+    ```lua
+    local propData = {
+        prop = 'prop_chair_01a',
+        coords = vector4(123.4, 567.8, 90.1, 180.0)
+    }
+    makeDistProp(propData, true, false)
+    ```
+
+- **destroyProp(entity)**
+  - Removes a previously created or targeted prop from the world.
+  - **Example:**
+    ```lua
+    destroyProp(barrel)
+    ```
+
+### makeVeh.lua
+This module provides functionality for spawning vehicles, including distance-based optimization and entity management.
+
+- **makeVeh(model, coords)**
+
+  - This function loads the vehicle model, creates the vehicle in the world at the given coordinates, sets initial properties, and returns the vehicle handle.
+  - **Example:**
+    ```lua
+    local vehicle = makeVeh("adder", vector3(250.0, -1000.0, 30.0))
+    ```
+
+- **makeDistVehicle(data, radius, onEnter, onExit)**
+
+  - Creates a vehicle that spawns when the player enters a designated polyzone area.
+  - This is used for `jim-parking` to create a static vehicle that can't move
+  - **Example:**
+    ```lua
+    makeDistVehicle({
+        model = "blista",
+        coords = vector3(400.0, -800.0, 30.0),
+        heading = 180.0
+    }, 50.0)
+    ```
+
+- **removeDistVehicleZone(zoneId)**
+  - Removes a previously created distance-based vehicle zone.
+  - **Example:**
+    ```lua
+    removeDistVehicleZone("garage_zone_1")
+    ```
+
+- **deleteVehicle(vehicle)**
+  - Deletes a specified vehicle entity.
+  - **Example:**
+    ```lua
+    deleteVehicle(vehicle)
+    ```

documentation/main_functions/metahandlers.md

@@ -0,0 +1,32 @@
+### metaHandlers.lua
+
+This module provides access and control over player metadata, which is useful for storing temporary or persistent player-specific values like stats, states, or tags.
+
+- **GetPlayer(source)**
+
+  ⚠️ Server side only
+  - Retrieves the player object (as defined by the framework in use) from the given `source` ID.
+  - **Example:**
+    ```lua
+    local player = GetPlayer(playerId)
+    ```
+
+- **GetMetadata(player, key)**
+
+  - Retrieves the value of a metadata field from the given player.
+  - If called client-side (player is nil), it triggers a server callback to retrieve metadata.
+  - **Example:**
+    ```lua
+    local stress = GetMetadata(player, "stress")
+    print("Player stress level:", stress)
+    ```
+
+- **SetMetadata(player, key, value)**
+
+  ⚠️ Server side only
+  - Updates or assigns a value to a specific metadata key for a player.
+  - The function updates the player's metadata using the active core export.
+  - **Example:**
+    ```lua
+    SetMetadata(player, "stress", 0)
+    ```

documentation/main_functions/notify.md

@@ -0,0 +1,21 @@
+### notify.lua
+
+This module provides a unified interface to trigger styled notifications across supported frameworks.
+
+- **triggerNotify(title, message, type, src)**
+
+  - Sends a notification to a player (or to the entire client if `src` is `nil`).
+  - The notification style is determined by `type` (e.g., `success`, `error`, `info`).
+  - **Parameters:**
+    - `title` (`string`): The title or header of the notification.
+    - `message` (`string`): The body or detail text.
+    - `type` (`string`): Type of message (e.g., "success", "error", "info").
+    - `src` (`number`, optional): Server ID of the player to notify (omit to notify locally).
+  - **Example:**
+    ```lua
+    -- Client-side usage without specifying a player (shows to the current player)
+    triggerNotify("Success", "You have completed the task!", "success")
+
+    -- Server-side usage specifying a player by their server ID
+    triggerNotify("Alert", "You have been warned for misconduct.", "error", source)
+    ```

documentation/main_functions/phones.md

@@ -0,0 +1,21 @@
+### phones.lua
+
+This module allows you to send in-game mail/messages to player phones, depending on the phone system integrated (e.g., QB, NPWD).
+
+- **sendPhoneMail(data)**
+
+  - Sends a mail message to a player's in-game phone app.
+  - Typically used to notify players about deliveries, missions, or reminders.
+  - **Parameters:**
+    - `data` (`table`): Must contain phone/mail system-compatible fields like `sender`, `subject`, `message`, and `receiver`.
+  - **Example:**
+    ```lua
+    sendPhoneMail({
+        subject = "Welcome!",
+        sender = "Admin",
+        message = "Thank you for joining our server.",
+        actions = {
+            { label = "Reply", action = replyFunction }
+        }
+    })
+    ```

documentation/main_functions/playerfunctions.md

@@ -0,0 +1,115 @@
+### playerfunctions.lua
+
+This module contains helper functions for manipulating player states, interactions, and utility checks.
+
+- **instantLookEnt(ent, ent2)**
+
+  - Instantly turns an entity to face a target (entity or coordinates) without animation.
+  - **Example:**
+    ```lua
+    instantLookEnt(nil, vector3(200.0, 300.0, 40.0))
+    instantLookEnt(ped1, ped2)
+    ```
+
+- **lookEnt(entity)**
+
+  - Makes the current player look toward the given entity.
+  - Usually called after when opening a menu or something similar to make the player visually face the location
+  - **Example:**
+    ```lua
+    lookEnt(vector3(200.0, 300.0, 40.0))
+    lookEnt(pedEntity)
+    ```
+
+- **setThirst(src, thirst)**
+
+  ⚠️ Server Side Only
+  - Sets the thirst level of a player.
+  - **Example:**
+    ```lua
+    setThirst(source, 75)
+    ```
+
+- **setHunger(src, hunger)**
+
+  ⚠️ Server Side Only
+  - Sets the hunger level of a player.
+  - **Example:**
+    ```lua
+    setHunger(source, 50)
+    ```
+
+- **chargePlayer(cost, moneyType, newsrc)**
+
+  ⚠️ Server Side Only
+  - Deducts money from a player of the specified type (`cash`, `bank`, etc).
+  - **Example:**
+    ```lua
+    chargePlayer(100, "cash", source)
+    ```
+
+- **fundPlayer(fund, moneyType, newsrc)**
+
+  ⚠️ Server Side Only
+  - Adds money to a player's balance of a given type.
+  - **Example:**
+    ```lua
+    fundPlayer(250, "bank", source)
+    ```
+
+- **ConsumeSuccess(itemName, type, data)**
+
+  - Handles logic when an item is successfully consumed (e.g., food, drink, etc).
+  - Supports hunger and thirst info directly from table eg. `{ hunger = 10, thirst = 20 }`
+  - **Example:**
+    ```lua
+    ConsumeSuccess("health_pack", "food", { hunger = 10 })
+
+    ConsumeSuccess("beer", "alcohol", { thirst = 20 })
+    ```
+
+- **hasJob(job, source, grade)**
+
+  - Checks if a player has a certain job and optionally checks for a specific grade.
+  - Similar to `jobCheck()` but also retrieves as much player job info as possible
+  - **Example:**
+    ```lua
+    -- Check if the player has the 'police' job and is on duty
+    local hasPoliceJob, isOnDuty = hasJob("police")
+    if hasPoliceJob and isOnDuty then
+        -- Grant access to police-specific features
+    end
+
+    -- Check if a specific player has the 'gang_leader' job with at least grade 2
+    local hasGangLeaderJob, _ = hasJob("gang_leader", playerId, 2)
+    if hasGangLeaderJob then
+        -- Allow gang leader actions
+    end
+    ```
+
+- **getPlayer(source)**
+
+  - Retrieves basic player information (name, cash, bank, job, etc.) based on the active core/inventory system.
+  - Can be called server-side (passing a player source) or client-side (for current player).
+  - Called often in my scripts as its makes use of frameworks "GetPlayerData" etc.
+  - **Example:**
+    ```lua
+    -- Get information for a specific player
+    local playerInfo = getPlayer(playerId)
+    print(playerInfo.name, playerInfo.cash, playerInfo.bank)
+
+    -- Get information for the current player (client-side)
+    local myInfo = getPlayer()
+    print(myInfo.name, myInfo.cash, myInfo.bank)
+    ```
+
+- **GetPlayersFromCoords(coords, radius)**
+
+  - Returns a list of players within a specified radius of a set of coordinates.
+  - **Example:**
+    ```lua
+    local nearby = GetPlayersFromCoords(GetEntityCoords(PlayerPedId()), 10.0)
+    for _, playerId in pairs(nearby) do
+        print("Nearby player ID:", playerId)
+    end
+    ```

documentation/main_functions/polyzone.md

@@ -0,0 +1,44 @@
+### polyZone.lua
+
+This module provides helpers for creating and removing polygon or circular zones using PolyZone-compatible data structures.
+
+- **createPoly(data)**
+
+  - Creates a polygonal zone using the detected polyzone library (ox_lib or PolyZone).
+  - Automatically checks which polyzone script is active. When using ox_lib, it converts the provided 2D points to 3D (setting a constant z value) and sets a thickness value.
+  - For PolyZone, it creates the zone and attaches onEnter and onExit callbacks for ease of use.
+  - **Example:**
+    ```lua
+    createPoly({
+        name = 'testZone',
+        debug = true,
+        points = { vec2(100.0, 100.0), vec2(200.0, 100.0), vec2(200.0, 200.0), vec2(100.0, 200.0) },
+        onEnter = function() print("Entered Test Zone") end,
+        onExit = function() print("Exited Test Zone") end,
+    })
+    ```
+
+- **createCirclePoly(data)**
+
+ - When using ox_lib, it creates a sphere zone. For PolyZone, it creates a CircleZone and attaches onEnter and onExit callbacks.
+  - **Example:**
+    ```lua
+    createCirclePoly({
+        name = 'circleZone',
+        coords = vector3(150.0, 150.0, 20.0),
+        radius = 50.0,
+        onEnter = function() print("Entered Circle Zone") end,
+        onExit = function() print("Exited Circle Zone") end,
+    })
+    ```
+
+- **removePolyZone(Location)**
+
+  - Removes a previously created polygon or circle zone by name.
+  - Detects the active polyzone library and calls the appropriate removal method.
+  - **Example:**
+    ```lua
+    local zone = createPoly({...})
+    ---
+    removePolyZone(zone)
+    ```

documentation/main_functions/progressbars.md

@@ -0,0 +1,23 @@
+### progressBars.lua
+This module provides a unified progress bar system compatible with various UI frameworks.
+
+❔It also contains an experimental "Shared Progressbar" system which was created for things like "giving an item to another player"
+
+- **progressBar(data)**
+  - Displays a progress bar using the current configured system (e.g., ox_lib, qb, etc).
+  - **Example:**
+    ```lua
+    local success = progressBar({
+        label = "Processing...",
+        time = 5000,
+        dict = "amb@world_human_hang_out_street@female_hold_arm@base",
+        anim = "base",
+        flag = 49,
+        cancel = true,
+    })
+    if success then
+        print("Success!")
+    else
+        print("Cancelled")
+    end
+    ```

documentation/main_functions/scaleentity.md

@@ -0,0 +1,24 @@
+### scaleEntity.lua
+
+This utility provides a simple interface to scale an entity (ped, object, vehicle) in the world.
+
+⚠️ **Important:** Unless the model's collision is removed or modified, the scale will reset when interacted with by other entities (e.g., walking into it, driving over it).
+
+- **scaleEntity(entity, scale)**
+
+  - Scales the specified entity by the given factor.
+  - **Parameters:**
+    - `entity` (`number`): Entity handle (ped, object, vehicle).
+    - `scale` (`number`): Scale factor (e.g., `1.0` is normal size, `0.5` is half size).
+  - **Example:**
+    ```lua
+    scaleEntity(PlayerPedId(), 0.8) -- Shrinks player slightly
+    ```
+
+- **resetScale(entity)**
+
+  - Resets the entity's scale back to its original default.
+  - **Example:**
+    ```lua
+    resetScale(PlayerPedId()) -- Return to default size
+    ```

documentation/main_functions/shops.md

@@ -0,0 +1,63 @@
+### shops.lua
+
+This module provides functions to open, sell to, and register in-game shops and markets.
+
+- **sellMenu(data)**
+
+  - Opens a UI menu for selling items to a vendor or market system.
+  - A simple system for the ability to sell all of an item in a players inventory
+  - Good for money making eg. pawn shops
+  - **Example:**
+    ```lua
+    sellMenu({
+        sellTable = {
+            Header = "Sell Items",
+            Items = {
+                ["gold_ring"] = 100,
+                ["diamond"] = 500,
+            },
+        },
+        ped = pedEntity,
+        onBack = function() print("Returning to previous menu") end,
+    })
+    ```
+
+- **sellAnim(data)**
+
+  - Plays an animation during the selling process for immersion.
+  - Used in sellMenu, but can be called externally if needed
+  - **Example:**
+    ```lua
+    sellAnim({
+       item = "gold_ring",
+       price = 100,
+       ped = pedEntity,
+       onBack = function() print("Sold Items") end,
+    )
+    ```
+
+- **openShop(data)**
+
+  - Opens a shop interface for purchasing items.
+  - Checks job/gang restrictions, then uses the active inventory system to open the shop.
+  - **Example:**
+    ```lua
+    openShop({
+        shop = "weapon_shop",
+        items = weaponShopItems,
+        coords = vector3(100.0, 200.0, 300.0),
+        job = "police",
+    })
+    ```
+
+- **registerShop(name, label, items, society)**
+
+  - Registers a named shop with associated items and an optional society for fund handling.
+  - Supports either OXInv or QBInv (with QBInvNew flag).
+  - **Example:**
+    ```lua
+    registerShop("fishing_shop", "Bait & Tackle", {
+        { item = "fishing_rod", price = 50 },
+        { item = "bait", price = 5 }
+    }, "fishing_society")
+    ```

documentation/main_functions/skillcheck.md

@@ -0,0 +1,16 @@
+### skillcheck.lua
+
+This module provides a UI-based skill check system, useful for crafting, hacking, or other interactive gameplay scenarios.
+
+- **skillCheck()**
+
+  - Starts a skill check minigame sequence using the provided configuration.
+  - Configuration may define speed, difficulty, bar size, or success zones.
+  - **Example:**
+    ```lua
+    if skillCheck() then
+        print("Success!")
+    else
+        print("Failed :(")
+    end
+    ```

documentation/main_functions/societybank.md

@@ -0,0 +1,28 @@
+### societybank.lua
+
+This module handles financial operations for society accounts, typically used for jobs or organizations.
+
+- **getSocietyAccount(society)**
+
+  - Retrieves the current balance for the specified society.
+  - **Example:**
+    ```lua
+    local balance = getSocietyAccount("police")
+    print("Police account balance: $"..balance)
+    ```
+
+- **chargeSociety(society, amount)**
+
+  - Deducts a specified amount from the society's account.
+  - **Example:**
+    ```lua
+    chargeSociety("police", 500)
+    ```
+
+- **fundSociety(society, amount)**
+
+  - Adds funds to a society’s account.
+  - **Example:**
+    ```lua
+    fundSociety("ambulance", 1200)
+    ```

documentation/main_functions/stashcontrol.md

@@ -0,0 +1,44 @@
+### stashcontrol.lua
+
+This module handles logic for interacting with stashes—shared inventories for crafting, jobs, or storage systems.
+
+- **checkStashItem(stashes, itemTable)**
+
+  - Retrieves (or updates) a local stash cache entry with a timeout.
+  - **Example:**
+    ```lua
+    local found, foundinStash = checkStashItem({"crafting_stash"}, { item = "steel", amount = 2 })
+    if found then print("Found item in "..foundInStash) end
+    ```
+
+- **openStash(data)**
+
+  - Opens a stash using the active inventory system.
+  - Checks for job or gang restrictions before opening the stash.
+  - **Example:**
+    ```lua
+    openStash({
+        stash = "playerStash",
+        label = "Player Stash",
+        coords = vector3(100, 200, 30)
+    })
+    ```
+
+- **getStash(stashName)**
+
+  - Retrieves the stash data by name (usually used for querying contents).
+  - **Example:**
+    ```lua
+    local items = getStash("playerStash")
+    for k, v in pairs(items) do
+        print(k)
+    end
+    ```
+
+- **stashRemoveItem(stashItems, stashName, items)**
+
+  - Removes specified items from a stash. Used during crafting or transfers.
+  - **Example:**
+    ```lua
+    stashRemoveItem(currentItems, "playerStash", { iron = 2, wood = 5 })
+    ```

documentation/main_functions/targets.md

@@ -0,0 +1,108 @@
+### targets.lua
+
+⚠️ This module provides utility functions for adding and removing interaction targets with entities, models, zones, and coordinates. Supports common targeting frameworks like `ox_target`, `qb-target`, and more.
+
+- **createEntityTarget(entity, opts, dist)**
+
+  - Adds interaction targets to a specific in-world entity.
+  - **Example:**
+    ```lua
+    createEntityTarget(entityId, {
+       {
+           action = function()
+               openStorage()
+           end,
+           icon = "fas fa-box",
+           job = "police",
+           label = "Open Storage",
+       },
+    }, 2.0)
+    ```
+
+- **createBoxTarget(data, opts, dist)**
+
+  - Creates an interactable box zone with configurable options.
+  - **Example:**
+    ```lua
+    createBoxTarget(
+       {
+           'storageBox',
+           vector3(100.0, 200.0, 30.0),
+           2.0,
+           2.0,
+           {
+               name = 'storageBox',
+               heading = 100.0,
+               debugPoly = true,
+               minZ = 27.0,
+               maxZ = 32.0,
+           },
+       },
+    {
+       {
+           action = function()
+               openStorage()
+           end,
+           icon = "fas fa-box",
+           job = "police",
+           label = "Open Storage",
+       },
+    }, 2.0)
+    ```
+
+- **createCircleTarget(data, opts, dist)**
+
+  - Creates an interactable circular zone.
+  - **Example:**
+    ```lua
+    createCircleTarget({
+        name = 'centralPark',
+        coords = vector3(200.0, 300.0, 40.0),
+        radius = 50.0,
+        options = { debugPoly = false }
+    }, {
+        { icon = "fas fa-tree", label = "Relax", action = relaxAction }
+    }, 2.0)
+    ```
+
+- **createModelTarget(models, opts, dist)**
+
+  - Adds interactions to all matching models globally.
+  - **Example:**
+    ```lua
+    createModelTarget({ model1, model2 },
+    {
+       {
+           action = function()
+               openStorage()
+           end,
+           icon = "fas fa-box",
+           job = "police",
+           label = "Open Storage",
+       },
+    }, 2.0)
+    ```
+
+- **removeEntityTarget(entity)**
+
+  - Removes all targets linked to the specified entity.
+  - **Example:**
+    ```lua
+    removeEntityTarget(vehicle)
+    ```
+
+- **removeZoneTarget(target)**
+
+  - Removes a named zone-based target.
+  - **Example:**
+    ```lua
+    removeZoneTarget("shop_box")
+    ```
+
+- **removeModelTarget(model)**
+
+  - Removes interactions tied to a model globally.
+  - **Example:**
+    ```lua
+    removeModelTarget("prop_vend_soda")
+    ```

documentation/main_functions/vehicles.md

@@ -0,0 +1,63 @@
+### vehicles.lua
+
+This module provides utilities for reading, modifying, and interacting with vehicle properties and positioning.
+
+- **searchCar(vehicle)**
+
+  - Searches the 'Vehicles' table for a specific vehicle's details.
+  - If the vehicle differs from the last searched, it retrieves its model and updates the carInfo table.
+  - The table includes the vehicle's name, price, and class information.
+  - **Example:**
+    ```lua
+    local info = searchCar(vehicleEntity)
+    print(info.name, info.price, info.class.name, info.class.index)
+    ```
+
+- **getVehicleProperties(vehicle)**
+
+  - Retrieves the properties of a given vehicle using the active framework.
+  - **Example:**
+    ```lua
+    local props = getVehicleProperties(vehicle)
+    if props then
+        print(json.encode(props))
+    end
+    ```
+
+- **setVehicleProperties(vehicle, props)**
+
+  - Sets the properties of a given vehicle if changes are detected.
+  - It compares the current properties with the new ones and applies the update using the active framework.
+  - **Example:**
+    ```lua
+    setVehicleProperties(vehicle, props)
+    ```
+
+- **checkDifferences(vehicle, newProps)**
+
+  - Checks for differences between the current and new vehicle properties.
+  - Compares properties using JSON encoding for deep comparison and logs differences.
+  - **Example:**
+    ```lua
+    if checkDifferences(vehicleEntity, newProperties) then
+        setVehicleProperties(vehicleEntity, newProperties)
+    end
+    ```
+
+- **pushVehicle(entity)**
+
+  - This function ensures that the vehicle is controlled by the current player and is set as a mission entity.
+  - It requests network control and sets the vehicle accordingly to synchronize changes across clients.
+  - **Example:**
+    ```lua
+    pushVehicle(vehicle)
+    ```
+
+- **getClosestVehicle(coords, src)**
+
+  - Finds the closest vehicle to the specified coordinates.
+  - The function uses different APIs based on whether a source is provided.
+  - **Example:**
+    ```lua
+    local closestVeh, distance = getClosestVehicle({ x = 100, y = 200, z = 30 }, source)
+    ```

documentation/main_functions/wrapperfunctions.md

@@ -0,0 +1,37 @@
+### wrapperfunctions.lua
+
+Provides wrapper compatibility functions for command and inventory stash systems across different frameworks (OX, QB, ESX, QS, etc).
+
+- **registerCommand(command, options)**
+
+  ⚠️ Server Side Only
+  - Registers a command using the appropriate framework's API.
+  - **Parameters:**
+    - `command`: Command name (string)
+    - `options`: Table including help, params, callback, autocomplete, restrictedGroup
+  - **Example:**
+    ```lua
+    registerCommand("greet", {
+        "Greets the player",
+        { name = "name", help = "Name of the player to greet" },
+        function(source, args) print("Hello, "..args[1].."!") end,
+        nil,
+        "admin"
+    })
+    ```
+
+- **registerStash(name, label, slots?, weight?, owner?, coords?)**
+
+  ⚠️ Server Side Only
+  - Registers a stash using OX, QS, or Origen inventory systems.
+  - **Example:**
+    ```lua
+    registerStash(
+        "playerStash",
+        "Player Stash",
+        100,
+        8000000,
+        "player123",
+        { x = 100.0, y = 200.0, z = 30.0 }
+    )
+    ```

documentation/scaleforms.md

@@ -0,0 +1,129 @@
+## Scaleforms
+### debugScaleform.lua
+This module renders debug text in-game when `debugMode` is enabled. Useful for live diagnostics or UI placement feedback.
+
+- **debugScaleForm(textTable, loc)**
+  - Displays an overlay of lines of text at the specified screen location.
+  - **Note:** This only works if `debugMode` is set to `true`.
+  - **Parameters:**
+    - `textTable` (`table`): A list of strings to display.
+    - `loc` (`vector2`, optional): Top-left anchor point on screen (default: `vec2(0.05, 0.65)`).
+  - **Example:**
+    ```lua
+    CreateThread(function()
+        while true do
+            debugScaleForm({
+                "Line 1: Debug info",
+                "Line 2: More info"
+            })
+            Wait(0)
+        end
+    end)
+    ```
+
+### instructionalButtons.lua
+This module renders instructional button prompts using native scaleforms in GTA V and RedM.
+
+⚠️ **Note:** Because it uses native scaleforms, it must be run inside a `while` loop to remain visible.
+
+- **makeInstructionalButtons(info)**
+  - Draws instructional buttons using the GTA scaleform `instructional_buttons`.
+  - **Parameters:**
+    - `info` (`table`): An array of tables, where each entry contains:
+      - `keys` (`table`): Control key codes (e.g., `{38, 29}`).
+      - `text` (`string`): The label for the button.
+  - **Example:**
+    ```lua
+    CreateThread(function()
+        while true do
+            makeInstructionalButtons({
+                { keys = {38, 29}, text = "Open Menu" },
+                { keys = {45}, text = "Close Menu" }
+            })
+            Wait(0)
+        end
+    end)
+    ```
+
+- **makeRedInstructionalButtons(info, title)**
+  - Experimental: Displays prompts using RedM-style `PromptSetGroup` API.
+  - **Note:** Still must be run in a loop for visibility.
+  - **Example:**
+    ```lua
+    CreateThread(function()
+        while true do
+            makeRedInstructionalButtons({
+                { keys = {0x760A9C6F}, text = "Mount Horse" },
+                { keys = {0x4CC0E2FE}, text = "Dismount" }
+            }, "Horse Controls")
+            Wait(0)
+        end
+    end)
+    ```
+
+### scaleform_basic.lua
+This module includes helper functions for 3D text rendering and UI overlays using basic native scaleform techniques.
+
+- **DrawText3D(coord, text, highlight)**
+
+  - Draws 3D text in the world at the given coordinates, with optional highlight.
+  - Includes a semi-transparent black background box for visibility.
+  - **Parameters:**
+    - `coord` (`vector3`): World position to draw text.
+    - `text` (`string`): Text content.
+    - `highlight` (`boolean`, optional): Highlights `~w~` sections with yellow.
+  - **Example:**
+    ```lua
+    CreateThread(function()
+        while true do
+            DrawText3D(vector3(100, 200, 300), "Hello World", true)
+            Wait(0)
+        end
+    end)
+    ```
+
+- **DisplayHelpMsg(text)**
+  - Shows a help message in the top-left corner of the screen.
+  - **Example:**
+    ```lua
+    DisplayHelpMsg("Press E to interact")
+    ```
+
+- **displaySpinner(text)**
+  - Shows a busy spinner with a message (e.g., "Saving...").
+  - **Example:**
+    ```lua
+    displaySpinner("Saving data...")
+    ```
+
+- **stopSpinner()**
+  - Hides any active busy spinner (client-only).
+  - **Example:**
+    ```lua
+    stopSpinner()
+    ```
+
+### timerBars.lua
+This module provides a native scaleform-based timer bar HUD. Ideal for displaying tasks, loading indicators, or time-sensitive objectives.
+
+- **createTimerHud(title, data, alpha)**
+
+  ⚠️ This was an attempt to recreate the gta native shooting ranges )fairly specific use case)
+  - Draws a timer bar with custom label and right-aligned values using the native GTA HUD system.
+  - **Parameters:**
+    - `title` (`string`): Title/header displayed on the bar.
+    - `data` (`table`): List of `label = value` entries to display (max 4 rows).
+    - `alpha` (`number`, optional): Opacity of the bar (0-255).
+  - **Example:**
+    ```lua
+    CreateThread(function()
+        while true do
+            createTimerHud("Timer Bar", {
+                { stat = "Health", value = "85%" },
+                { stat = "Armor", value = "50%", multi = 2 },
+                { stat = "Stamina", value = "100%" },
+            }, 180)
+            Wait(0)
+        end
+    end)
+    ```

frameworkCache.lua

@@ -0,0 +1,303 @@
+--[[
+    Cached Resource Initialization Module
+    --------------------------------------
+    Initializes shared resource data (Items, Vehicles, Jobs, Gangs) once and caches it
+    to improve performance and reduce redundant data fetching across scripts.
+]]
+
+-- Define resource names used in different frameworks
+local Exports = {
+    QBExport = "qb-core",
+    QBXExport = "qbx_core",
+    ESXExport = "es_extended",
+    OXCoreExport = "ox_core",
+
+    OXInv = "ox_inventory",
+    QBInv = "qb-inventory",
+    PSInv = "ps-inventory",
+    QSInv = "qs-inventory",
+    CoreInv = "core_inventory",
+    CodeMInv = "codem-inventory",
+    OrigenInv = "origen_inventory",
+    TgiannInv = "tgiann-inventory",
+    JPRInv = "jpr-inventory",
+
+    OXLibExport = "ox_lib",
+
+    QBMenuExport = "qb-menu",
+
+    QBTargetExport = "qb-target",
+    OXTargetExport = "ox_target",
+
+    -- REDM
+    RSGExport = "rsg-core",
+    RSGInv = "rsg-inventory"
+}
+
+-- Prevent reloading if cache is already initialized
+if _G.__jimBridgeDataCache then return end
+_G.__jimBridgeDataCache = {}
+local cache = _G.__jimBridgeDataCache
+
+-- Helper function to check if resource exists in server (instead of if it is already started)
+local function checkExists(resourceName)
+    return GetResourceState(resourceName):find("start") or GetResourceState(resourceName):find("stopped")
+end
+
+-- Ensure oxmysql resource is loaded
+local fileLoader = assert(load(LoadResourceFile("oxmysql", ('lib/MySQL.lua')), ('@@oxmysql/lib/MySQL.lua')))
+fileLoader()
+
+if checkExists(Exports.OXCoreExport) then
+    -- Detected OX_Core in server, wait for it to be started if needed
+    while GetResourceState(Exports.OXCoreExport) ~= "started" do Wait(100) end
+    local fileLoader = assert(load(LoadResourceFile(Exports.OXCoreExport, ('lib/init.lua')), ('@@'..Exports.OXCoreExport..'/lib/init.lua')))
+    fileLoader()
+end
+if checkExists(Exports.ESXExport) then
+    -- Detected ESX in server, wait for it to be started if needed
+    while GetResourceState(Exports.ESXExport) ~= "started" do Wait(100) end
+    local fileLoader = assert(load(LoadResourceFile(Exports.ESXExport, ('/imports.lua')), ('@@'..Exports.ESXExport..'/imports.lua')))
+    fileLoader()
+end
+
+-- Initialize variables for caching
+local Items, Vehicles, Jobs, Gangs, Core = nil, nil, nil, nil, nil
+local itemResource, jobResource, vehResource = "", "", ""
+
+-- Print just to announce it knows the exports/scripts exist in the server
+for _, v in pairs(Exports) do
+    if checkExists(v) then
+        print("^6Bridge^7: '^3"..v.."^7' detected")
+    end
+end
+
+---------------------
+---- Load Items -----
+---------------------
+-- Items initialization based on detected inventory system
+if checkExists(Exports.OXInv) then
+    -- Wait for OX Inventory to start if it's not already started
+    while GetResourceState(Exports.OXInv) ~= "started" do Wait(100) end
+    itemResource = Exports.OXInv
+    Items = exports[Exports.OXInv]:Items()
+
+    -- Get Weapon info and duplicate them if they are uppercase
+    -- (duplicate incase anything checks for the uppercase version)
+    for k, v in pairs(Items) do
+        if k:find("WEAPON") then
+            Items[k:lower()] = Items[k]
+            Items[k:lower()].image = k..".png"
+        end
+        Items[k].image = (v.client and v.client.image) and v.client.image:gsub("nui://"..Exports.OXInv.."/web/images/", "") or k..".png"
+        Items[k].hunger = v.client and v.client.hunger
+        Items[k].thirst = v.client and v.client.thirst
+    end
+
+elseif checkExists(Exports.QBExport) then
+    while GetResourceState(Exports.QBExport) ~= "started" do Wait(100) end
+    itemResource = Exports.QBExport
+    Core = exports[Exports.QBExport]:GetCoreObject()
+    Items = Core.Shared.Items
+    if Items == nil then
+        print("^1ERROR^7: ^1Can NOT find shared ^7Items ^1table^7, ^1possible error in that file^7?")
+        Items = {} -- Fallback to an empty table
+    end
+
+elseif checkExists(Exports.ESXExport) then
+    itemResource = Exports.ESXExport
+    if GetResourceState(Exports.QSInv):find("start") then
+        Items = exports[Exports.QSInv]:GetItemList()
+    else
+        Items = ESX.GetItems()
+        while not next(Items) do
+            Items = ESX.GetItems()
+            Wait(1000)
+        end
+    end
+
+elseif checkExists(Exports.RSGExport) then
+    while GetResourceState(Exports.RSGExport) ~= "started" do Wait(100) end
+    itemResource = Exports.RSGExport
+    Core = exports[Exports.RSGExport]:GetCoreObject()
+    Items = Core.Shared.Items
+    if Items == nil then
+        print("^1ERROR^7: ^1Can NOT find shared ^7Items ^1table^7, ^1possible error in that file^7?")
+        Items = {} -- Fallback to an empty table
+    end
+
+end
+
+---------------------
+--- Load Vehicles ---
+---------------------
+-- Vehicle loading depending on framework
+if checkExists(Exports.QBXExport) or checkExists(Exports.QBExport) then
+    vehResource = Exports.QBExport
+    Core = Core or exports[Exports.QBExport]:GetCoreObject()
+    Vehicles = Core.Shared.Vehicles
+    if Vehicles == nil then
+        print("^1ERROR^7: ^1Can NOT find shared ^7Vehicles ^1table^7, ^1possible error in that file^7?")
+        Vehicles = {} -- Fallback to an empty table
+    end
+
+elseif checkExists(Exports.OXCoreExport) then
+    vehResource = Exports.OXCoreExport
+    Vehicles = {}
+    for k, v in pairs(Ox.GetVehicleData()) do
+        Vehicles[k] = {
+            model = k, hash = GetHashKey(k),
+            price = v.price,
+            name = v.name,
+            brand = v.make
+        }
+    end
+
+elseif checkExists(Exports.ESXExport) then
+    vehResource = Exports.ESXExport
+    while not MySQL do Wait(1000) end
+    Vehicles = {}
+    for _, v in pairs(MySQL.query.await('SELECT model, price, name FROM vehicles')) do
+        Vehicles[v.model] = {
+            model = v.model,
+            hash = GetHashKey(v.model),
+            price = v.price,
+            name = v.name,
+        }
+    end
+
+elseif checkExists(Exports.RSGExport) then
+    vehResource = Exports.RSGExport
+    Core = Core or exports[Exports.RSGExport]:GetCoreObject()
+    Vehicles = Core.Shared.Vehicles
+    if Vehicles == nil then
+        print("^1ERROR^7: ^1Can NOT find shared ^7Vehicles ^1table^7, ^1possible error in that file^7?")
+        Vehicles = {} -- Fallback to an empty table
+    end
+
+end
+
+---------------------
+----- Load Jobs -----
+---------------------
+-- Jobs loading based on framework
+if checkExists(Exports.QBXExport) then
+    jobResource = Exports.QBXExport
+    Core = Core or exports[Exports.QBXExport]:GetCoreObject()
+    Jobs, Gangs = exports[Exports.QBXExport]:GetJobs(), exports[Exports.QBXExport]:GetGangs()
+    if Jobs == nil then
+        print("^1ERROR^7: ^1Can NOT find shared ^7Jobs ^1table^7, ^1possible error in that file^7?")
+        Jobs = {} -- Fallback to an empty table
+    end
+
+elseif checkExists(Exports.OXCoreExport) then
+    jobResource = Exports.OXCoreExport
+    Jobs = {}
+    while not MySQL do Wait(1000) end
+    local tempJobs = MySQL.query.await('SELECT * FROM `ox_groups`')
+    local tempGrades = MySQL.query.await('SELECT * FROM `ox_group_grades`')
+    local gradeMap = {}
+    for _, grade in pairs(tempGrades) do
+        gradeMap[grade.group] = gradeMap[grade.group] or {}
+        gradeMap[grade.group][grade.grade] = { name = grade.label }
+    end
+    for _, job in pairs(tempJobs) do
+        Jobs[job.name] = {
+            label = job.label,
+            grades = gradeMap[job.name] or {}
+        }
+    end
+    Gangs = Jobs
+
+elseif checkExists(Exports.QBExport) then
+    jobResource = Exports.QBExport
+    Core = Core or exports[Exports.QBExport]:GetCoreObject()
+    Jobs, Gangs = Core.Shared.Jobs, Core.Shared.Gangs
+
+elseif checkExists(Exports.ESXExport) then
+    jobResource = Exports.ESXExport
+    ESX = exports[Exports.ESXExport]:getSharedObject()
+    Jobs = ESX.GetJobs()
+    while not next(Jobs) do
+        Wait(100)
+        Jobs = ESX.GetJobs()
+    end
+    for Role, Grades in pairs(Jobs) do
+        -- Check for if user has added grades
+        if Grades.grades == nil or not next(Grades.grades) then
+            goto continue
+        end
+        for grade, info in pairs(Grades.grades) do
+            if info.label and info.label:find("[Bb]oss") then
+                Jobs[Role].grades[grade].isBoss = true
+                goto continue
+            end
+        end
+        local highestGrade = nil
+        for k in pairs(Grades.grades) do
+            local num = tonumber(k)
+            if num and (not highestGrade or num > highestGrade) then
+                highestGrade = num
+            end
+        end
+
+        if highestGrade then
+            Jobs[Role].grades[tostring(highestGrade)].isBoss = true
+        end
+        ::continue::
+    end
+    Gangs = Jobs
+
+elseif checkExists(Exports.RSGExport) then
+    jobResource = Exports.RSGExport
+    Core = Core or exports[Exports.RSGExport]:GetCoreObject()
+    Jobs, Gangs = Core.Shared.Jobs, Core.Shared.Gangs
+    if Jobs == nil then
+        print("^1ERROR^7: ^1Can NOT find shared ^7Jobs ^1table^7, ^1possible error in that file^7?")
+        Jobs = {} -- Fallback to an empty table
+    end
+
+end
+
+-- Save to global cache
+cache.Items = Items
+cache.Vehicles = Vehicles
+cache.Jobs = Jobs
+cache.Gangs = Gangs
+
+CreateThread(function()
+    local counts = {
+        Items = 0,
+        Vehicles = 0,
+        Jobs = 0,
+        Gangs = 0,
+    }
+    for k, v in pairs(cache) do
+        for count in pairs(v) do
+            counts[k] += 1
+        end
+    end
+    print("^6FrameworkCache^7: ^2Loaded ^5"..tostring(counts.Items).."^2 Items from ^7"..itemResource)
+    print("^6FrameworkCache^7: ^2Loaded ^5"..tostring(counts.Vehicles).."^2 Vehicles from ^7"..vehResource)
+    print("^6FrameworkCache^7: ^2Loaded ^5"..tostring(counts.Jobs).."^2 Jobs from ^7"..jobResource)
+    print("^6FrameworkCache^7: ^2Loaded ^5"..tostring(counts.Gangs).."^2 Gangs from ^7"..jobResource)
+end)
+
+RegisterNetEvent("jim_bridge:requestCache", function()
+    local src = source
+    TriggerClientEvent("jim_bridge:receiveCache", src, _G.__jimBridgeDataCache)
+end)
+
+exports("GetSharedData", function()
+    -- Wait for data to be ready before returning it
+    local timeout = GetGameTimer() + 5000
+    while (
+        not _G.__jimBridgeDataCache or
+        (not _G.__jimBridgeDataCache.Items or next(_G.__jimBridgeDataCache.Items) == nil) or
+        (not _G.__jimBridgeDataCache.Vehicles or next(_G.__jimBridgeDataCache.Vehicles) == nil) or
+        (not _G.__jimBridgeDataCache.Jobs or next(_G.__jimBridgeDataCache.Jobs) == nil)
+    ) and GetGameTimer() < timeout do
+        Wait(50)
+    end
+    return _G.__jimBridgeDataCache
+end)

fxmanifest.lua

@@ -1,6 +1,6 @@
 name "Jim_Bridge"
 author "Jimathy"
-version "2.0.02"
+version "2.0.17"
 description "Framework Bridge By Jimathy"
 fx_version "cerulean"
 rdr3_warning 'I acknowledge that this is a prerelease build of RedM, and I am aware my resources *will* become incompatible once RedM ships.'
@@ -16,4 +16,11 @@ files {
 }
 
 -- Version checker
-server_scripts { '_versioncheck.lua' }
+server_scripts {
+    'frameworkCache.lua',
+    '_versioncheck.lua'
+}
+
+client_scripts {
+    'ui_modules/*.lua'
+}

shared/_loaders.lua

@@ -40,6 +40,7 @@ function onPlayerLoaded(func, onStart)
 
     if not loaded then
         local tempFunc = function()
+            Wait(2000)
             debugPrint("^6Bridge^7: ^2Executing onPlayerLoaded")
             func()
         end
@@ -49,7 +50,13 @@ function onPlayerLoaded(func, onStart)
             AddEventHandler('QBCore:Client:OnPlayerLoaded', tempFunc)
         elseif isStarted(ESXExport) then
             onPlayerFramework = ESXExport
-            AddEventHandler('esx:playerLoaded', tempFunc)
+            AddEventHandler('esx:playerLoaded', function()
+                if waitForSharedLoad() then
+                    if isStarted(ESXExport) then Wait(1000) end
+                    tempFunc()
+                end
+            end
+        )
         elseif isStarted(OXCoreExport) then
             onPlayerFramework = OXCoreExport
             AddEventHandler('ox:playerLoaded', tempFunc)
@@ -98,11 +105,19 @@ end
 ---     -- Initialization code on resource start.
 --- end, true)
 --- ```
+local hasPrinted = false
 function onResourceStart(func, thisScript)
-    debugPrint("^6Bridge^7: Registering ^3onResourceStart^7()")
+    debugPrint("^6Bridge^7: ^2Registering ^3onResourceStart^7()")
     AddEventHandler('onResourceStart', function(resourceName)
         if getScript() == resourceName and (thisScript or true) then
-            func()
+            if waitForSharedLoad() then
+                if not hasPrinted then
+                    debugPrint("^6Bridge^7: ^2Shared Load Detected^7.")
+                    hasPrinted = true
+                end
+                if isStarted(ESXExport) then Wait(10000) end
+                func()
+            end
         end
     end)
 end
@@ -138,9 +153,7 @@ function waitForLogin()
     local loggedIn = false
 
     if isStarted(ESXExport) then
-        debugPrint("^6Bridge^7: ^3ESX waitForLogin^7() ^2running^7")
         while (GetGameTimer() - startTime) < timeout do
-            while not ESX do Wait(100) end
             local playerData = ESX.GetPlayerData()
             if playerData and playerData.job then
                 loggedIn = true
@@ -175,4 +188,42 @@ function waitForLogin()
         debugPrint("^6Bridge^7: ^2Player Login Detected^7.")
         return true
     end
+end
+
+local messageShown = false
+function waitForSharedLoad()
+    local timeout = 100000  -- 10 seconds in milliseconds
+    local startTime = GetGameTimer()
+    local loaded = true
+    --Wait(1000)
+    local count = {}
+    local loop = 0
+    while ((not Jobs or not next(Jobs)) and (not Items or not next(Items)) and (not Vehicles or not next(Vehicles))) and (GetGameTimer() - startTime) < timeout do
+        if not messageShown then
+            if (not Jobs or not next(Jobs)) then
+                debugPrint("^4Debug^7: ^2Waiting for Jobs to be loaded")
+            end
+            if (not Items or not next(Items)) then
+                debugPrint("^4Debug^7: ^2Waiting for Items to be loaded")
+            end
+            if (not Vehicles or not next(Vehicles)) then
+                debugPrint("^4Debug^7: ^2Waiting for Vehicles to be loaded")
+            end
+        end
+        messageShown = true
+        --print((GetGameTimer() - startTime) < timeout)
+        Wait(1000)
+        if Jobs and Items and Vehicles then
+            --print("^6Bridge^7: ^2Jobs, Items, and Vehicles Loaded^7.")
+            loaded = true
+            break
+        end
+        loop += 1
+    end
+    if not loaded then
+        print("^4Error^7: ^1Timeout reached while waiting for shared load^7.")
+        return false
+    else
+        return true
+    end
 end

shared/_scriptversioncheck.lua

@@ -15,7 +15,7 @@ function compareVersions(current, newest)
         if c < n then return -1
         elseif c > n then return 1 end
     end
-    return 0 -- equal
+    return 0
 end
 
 function capitalize(str)
@@ -30,42 +30,66 @@ local scriptAuthor = ("^2by ^4"..GetResourceMetadata(getScript(), 'author', nil)
 print(scriptName.." ^7v"..scriptVersion.."^7 - "..scriptDescription.." "..scriptAuthor.."^7")
 
 function CheckVersion()
-    if isServer() then
+    if isServer() and GetResourceMetadata(getScript(), 'author', nil) == "Jimathy" then
         CreateThread(function()
             Wait(4000)
-
             local script = getScript()
             local currentVersionRaw = GetResourceMetadata(script, 'version')
 
             PerformHttpRequest('https://raw.githubusercontent.com/jimathy/UpdateVersions/master/'..script..'.txt', function(err, newestVersionRaw, headers)
                 if not newestVersionRaw then
+                    -- fallback
                     PerformHttpRequest('https://raw.githubusercontent.com/jimathy/'..script..'/master/version.txt', function(err, fallbackVersionRaw, headers)
                         if not fallbackVersionRaw then
                             print("^1Currently unable to run a version check for ^7'^3"..script.."^7' (^3"..currentVersionRaw.."^7)")
                             return
                         end
 
-                        fallbackVersionRaw = fallbackVersionRaw:match("[^\r\n]+"):gsub("v", "")
+                        local lines = {}
+                        for line in fallbackVersionRaw:gmatch("[^\r\n]+") do table.insert(lines, line) end
+                        local fallbackVersion = (lines[1] or "0.0.0"):gsub("v", "")
+                        local changelog = {}
+                        for i = 2, #lines do table.insert(changelog, lines[i]) end
 
-                        local compareResult = compareVersions(currentVersionRaw, fallbackVersionRaw)
+                        local compareResult = compareVersions(currentVersionRaw, fallbackVersion)
                         if compareResult == 0 then
                             print("^7'^3"..script.."^7' - ^2You are running the latest version^7. (^3"..currentVersionRaw.."^7)")
                         elseif compareResult < 0 then
-                            print("^7'^3"..script.."^7' - ^1You are currently running an outdated version^7! (^3"..currentVersionRaw.."^7 → ^3"..fallbackVersionRaw.."^7)")
+                            print("^1----------------------------------------------------------------------^7")
+                            print("^7'^3"..script.."^7' - ^1You are currently running an outdated version^7! (^3"..currentVersionRaw.."^7 → ^3"..fallbackVersion.."^7)")
+                            if #changelog > 0 then
+                                for _, line in ipairs(changelog) do
+                                    print((line:find("http") and "^7" or "^5")..line)
+                                end
+                            end
+                            print("^1----------------------------------------------------------------------^7")
+                            SetTimeout(1200000, function() CheckVersion() end)
                         else
-							print("^7'^3"..script.."^7' - ^5You are running a newer version ^7(^3"..currentVersionRaw.."^7 ← ^3"..fallbackVersionRaw.."^7)")
+                            print("^7'^3"..script.."^7' - ^5You are running a newer version ^7(^3"..currentVersionRaw.."^7 ← ^3"..fallbackVersion.."^7)")
                         end
                     end)
                 else
-                    newestVersionRaw = newestVersionRaw:match("[^\r\n]+"):gsub("v", "")
+                    local lines = {}
+                    for line in newestVersionRaw:gmatch("[^\r\n]+") do table.insert(lines, line) end
+                    local newestVersion = (lines[1] or "0.0.0"):gsub("v", "")
+                    local changelog = {}
+                    for i = 2, #lines do table.insert(changelog, lines[i]) end
 
-					local compareResult = compareVersions(currentVersionRaw, newestVersionRaw)
-					if compareResult == 0 then
+                    local compareResult = compareVersions(currentVersionRaw, newestVersion)
+                    if compareResult == 0 then
                         print("^7'^3"..script.."^7' - ^2You are running the latest version^7. (^3"..currentVersionRaw.."^7)")
                     elseif compareResult < 0 then
-                        print("^7'^3"..script.."^7' - ^1You are currently running an outdated version^7! (^3"..currentVersionRaw.."^7 → ^3"..newestVersionRaw.."^7)")
+                        print("^1----------------------------------------------------------------------^7")
+                        print("^7'^3"..script.."^7' - ^1You are currently running an outdated version^7! (^3"..currentVersionRaw.."^7 → ^3"..newestVersion.."^7)")
+                        if #changelog > 0 then
+                            for _, line in ipairs(changelog) do
+                                print((line:find("http") and "^7" or "^5")..line)
+                            end
+                        end
+                        print("^1----------------------------------------------------------------------^7")
+                        SetTimeout(1200000, function() CheckVersion() end)
                     else
-                        print("^7'^3"..script.."^7' - ^5You are running a newer version ^7(^3"..currentVersionRaw.."^7 ← ^3"..newestVersionRaw.."^7)")
+                        print("^7'^3"..script.."^7' - ^5You are running a newer version ^7(^3"..currentVersionRaw.."^7 ← ^3"..newestVersion.."^7)")
                     end
                 end
             end)
@@ -73,4 +97,4 @@ function CheckVersion()
     end
 end
 
-CheckVersion()
+CheckVersion()

shared/contextmenus.lua

@@ -194,7 +194,7 @@ function openMenu(Menu, data)
         exports[QBMenuExport]:openMenu(Menu)
 
     elseif Config.System.Menu == "gta" then
-        WarMenu.CreateMenu(tostring(Menu), data.header, data.headertxt or " ", {
+        WarMenu.CreateMenu(tostring(Menu), data.header, " ", {
             titleColor = { 222, 255, 255 },
             maxOptionCountOnScreen = 15,
             width = 0.25,
@@ -232,6 +232,7 @@ function openMenu(Menu, data)
                         if pressed and not Menu[k].isMenuHeader then
                             WarMenu.CloseMenu()
                             close = false
+                            Wait(10)
                             Menu[k].onSelect()
                         end
                     end

shared/coreloader.lua

@@ -1,25 +1,8 @@
---[[
-    Resource Initialization Module
-    --------------------------------
-    This module initializes and loads shared data (Items, Vehicles, Jobs, Gangs) from the
-    various frameworks/inventory systems (OX, QB, ESX, etc.). It also corrects export names,
-    caches framework exports into simple variables, and prints debug information if enabled.
-]]
+Items, Vehicles, Jobs, Gangs, Core = {}, nil, nil, nil, nil
 
--------------------------------------------------------------
--- Global Variable Initialization
--------------------------------------------------------------
-Items, Vehicles, Jobs, Gangs, Core, ESX = {}, nil, nil, nil, nil, nil
+-- Shared Exports Initialization
+Exports.PSInv = isStarted("lj-inventory") and "lj-inventory" or Exports.PSInv
 
--------------------------------------------------------------
--- Correct QB Inventory Export
--------------------------------------------------------------
--- Ensure that the QB inventory export is corrected from 'qb-inventory' to 'ps-inventory' or 'lj-inventory' if needed.
-Exports.QBInv = (isStarted("ps-inventory") and "ps-inventory") or (isStarted("lj-inventory") and "lj-inventory") or Exports.QBInv
-
--------------------------------------------------------------
--- Framework Exports and Inventory Identifiers
--------------------------------------------------------------
 OXLibExport, QBXExport, QBExport, ESXExport, OXCoreExport =
     Exports.OXLibExport or "",
     Exports.QBXExport or "",
@@ -27,266 +10,94 @@ OXLibExport, QBXExport, QBExport, ESXExport, OXCoreExport =
     Exports.ESXExport or "",
     Exports.OXCoreExport or ""
 
-OXInv, QBInv, PSInv, QSInv, CoreInv, CodeMInv, OrigenInv =
+OXInv, QBInv, PSInv, QSInv, CoreInv, CodeMInv, OrigenInv, TgiannInv, JPRInv =
     Exports.OXInv or "",
     Exports.QBInv or "",
     Exports.PSInv or "",
     Exports.QSInv or "",
     Exports.CoreInv or "",
     Exports.CodeMInv or "",
-    Exports.OrigenInv or ""
-
-RSGExport, RSGInv =
-    Exports.RSGExport or "",
-    Exports.RSGInv or ""
+    Exports.OrigenInv or "",
+    Exports.TgiannInv or "",
+    Exports.JPRInv or ""
 
+RSGExport, RSGInv = Exports.RSGExport or "", Exports.RSGInv or ""
 QBMenuExport = Exports.QBMenuExport or ""
 QBTargetExport, OXTargetExport = Exports.QBTargetExport or "", Exports.OXTargetExport or ""
 
--------------------------------------------------------------
--- Debug: Print Found Exports
--------------------------------------------------------------
--- Print a list of all exports that are currently started (if debugMode is enabled).
-for _, v in pairs(Exports) do
-    if isStarted(v) then
-        debugPrint("^6Bridge^7: '^3"..v.."^7' export found")
-    end
-end
-
-OxPlayer = nil
-if isStarted(OXCoreExport) then
-    if not isServer() then
-        OxPlayer = Ox.GetPlayer()
-    end
-end
-
--------------------------------------------------------------
--- Resource Variables for Items, Jobs, and Vehicles
--------------------------------------------------------------
-local itemResource, jobResource, vehResource = "", "", ""
-
--------------------------------------------------------------
--- Loading Items
--------------------------------------------------------------
--- Load and compile shared items from the detected inventory system.
-if isStarted(OXInv) then
-    itemResource = OXInv
-    Items = exports[OXInv]:Items()
-    for k, v in pairs(Items) do
-        if v.client and v.client.image then
-            Items[k].image = (v.client.image):gsub("nui://"..OXInv.."/web/images/", "")
-        else
-            Items[k].image = k..".png"
-        end
-        Items[k].hunger = v.client and v.client.hunger or nil
-        Items[k].thirst = v.client and v.client.thirst or nil
-    end
-
-elseif isStarted(QBExport) then
-    itemResource = QBExport
+if isStarted(QBXExport) or isStarted(QBExport) then
     Core = Core or exports[QBExport]:GetCoreObject()
-    Items = Core and Core.Shared.Items or nil
-    if isStarted(QBExport) and not isStarted(QBXExport) then
-        RegisterNetEvent('QBCore:Client:UpdateObject', function()
-            Core = Core or exports[QBExport]:GetCoreObject()
-            Items = Core and Core.Shared.Items or nil
-        end)
-    end
+elseif isStarted(RSGExport) then
+    Core = Core or exports[RSGExport]:GetCoreObject()
+end
 
-elseif isStarted(ESXExport) then
-    itemResource = ESXExport
-    ESX = exports[ESXExport]:getSharedObject()
-    while ESX == nil do
-        print("Waiting for ESX")
-        Wait(0)
-    end
+
+if IsDuplicityVersion() then
     CreateThread(function()
-        while not ESX do Wait(0) end
-        if isServer() then
-            Items = ESX.GetItems()
-            while not createCallback do Wait(100) end
-            createCallback(getScript()..":getItems", function(source)
-                return Items
-            end)
+        local cache = nil
+        local timeout = GetGameTimer() + 5000 -- 5 seconds max wait
+
+        -- Wait until jim_bridge is started and export is available
+        while not cache and GetGameTimer() < timeout do
+            if GetResourceState("jim_bridge"):find("start") then
+                local success, result = pcall(function()
+                    return exports["jim_bridge"]:GetSharedData()
+                end)
+                if success and result then
+                    cache = result
+                    --print(json.encode(cache, {indent = true}))
+                end
+            end
+            Wait(100)
         end
-        if not isServer() then
-            Items = triggerCallback(getScript()..":getItems")
-            debugPrint("^6Bridge^7: ^2Loading ^6"..countTable(Items).." ^3Items^2 from ^7"..itemResource)
+
+        if not cache then
+            print("^1ERROR^7: ^2jim_bridge export not available after timeout^7.")
+            return
+        end
+
+        Items    = cache.Items
+        Vehicles = cache.Vehicles
+        Jobs     = cache.Jobs
+        Gangs    = cache.Gangs
+
+        debugPrint("^6Bridge^7: ^2Shared cache successfully loaded from export^7.")
+    end)
+else
+    local hasCache = false
+    -- 🔹 Client Side: Request from server
+    _G.__jimBridgeDataCache = {}
+
+    RegisterNetEvent("jim_bridge:receiveCache", function(data)
+        if not hasCache then
+            _G.__jimBridgeDataCache = data
+            hasCache = true
+        else
+            return
         end
     end)
 
-elseif isStarted(RSGExport) then
-    itemResource = RSGExport
-    Core = Core or exports[RSGExport]:GetCoreObject()
-    Items = Core and Core.Shared.Items or nil
-    if isStarted(RSGExport) and not isStarted(QBXExport) then
-        RegisterNetEvent('QBCore:Client:UpdateObject', function()
-            Core = Core or exports[RSGExport]:GetCoreObject()
-            Items = Core and Core.Shared.Items or nil
-        end)
-    end
+    TriggerServerEvent("jim_bridge:requestCache")
 
-end
-
-if itemResource == nil then
-    print("^4ERROR^7: ^2No Item info detected ^7- ^2Check ^3starter^1.^2lua^7")
-else
-    while not Items do Wait(100) end
-    debugPrint("^6Bridge^7: ^2Loading ^6"..countTable(Items).." ^3Items^2 from ^7"..itemResource)
-end
-
-
--------------------------------------------------------------
--- Loading Vehicles
--------------------------------------------------------------
--- Compile vehicles from the detected frameworks into a unified table.
-if isStarted(QBXExport) or isStarted(QBExport) then
-    Core = Core or exports[QBExport]:GetCoreObject()
-    Vehicles = Core and Core.Shared.Vehicles
-    if isStarted(QBExport) and not isStarted(QBXExport) then
-        RegisterNetEvent('QBCore:Client:UpdateObject', function()
-            Core = Core or exports[QBExport]:GetCoreObject()
-            Vehicles = Core and Core.Shared.Vehicles
-        end)
-    end
-    vehResource = QBExport
-
-elseif isStarted(OXCoreExport) then
-    Vehicles = {}
-    for k, v in pairs(Ox.GetVehicleData()) do
-        Vehicles[k] = { model = k, hash = GetHashKey(k), price = v.price, name = v.name, brand = v.make }
-    end
-    vehResource = OXCoreExport
-
-elseif isStarted(ESXExport) then
     CreateThread(function()
-        if isServer() then
-            vehResource = ESXExport
-            createCallback(getScript()..":getVehiclesPrices", function(source)
-                return Vehicles
-            end)
-            while not MySQL do Wait(2000) print("^1Waiting for MySQL to exist") end
-            Vehicles = MySQL.query.await('SELECT model, price, name FROM vehicles')
-            --jsonPrint(Vehicles)
-            --while not createCallback do print("waiting") Wait(100) end
-        end
-        if not isServer() then
-            --while not triggerCallback do print("waiting") Wait(100) end
-            local TempVehicles = triggerCallback(getScript()..":getVehiclesPrices")
-            for _, v in pairs(TempVehicles) do
-                Vehicles = Vehicles or {}
+        while not _G.__jimBridgeDataCache or not next(_G.__jimBridgeDataCache) do Wait(50) end
+        local cache = _G.__jimBridgeDataCache
+        Items = cache.Items or {}
+        Vehicles = cache.Vehicles or {}
+        Jobs = cache.Jobs or {}
+        Gangs = cache.Gangs or {}
+
+        if isStarted(ESXExport) then
+            for _, v in pairs(Vehicles) do
                 Vehicles[v.model] = {
                     model = v.model,
-                    hash = GetHashKey(v.model),
+                    hash = v.hash,
                     price = v.price,
                     name = v.name,
                     brand = GetMakeNameFromVehicleModel(v.model):lower():gsub("^%l", string.upper)
                 }
             end
         end
-    end)
 
-elseif isStarted(RSGExport) then
-    Core = Core or exports[RSGExport]:GetCoreObject()
-    Vehicles = Core and Core.Shared.Vehicles
-    if isStarted(RSGExport) then
-        RegisterNetEvent('RSGExport:Client:UpdateObject', function()
-            Core = Core or exports[RSGExport]:GetCoreObject()
-            Vehicles = Core and Core.Shared.Vehicles
-        end)
-    end
-    vehResource = RSGExport
-end
-if vehResource == nil then
-    print("^4ERROR^7: ^2No Vehicle info detected ^7- ^2Check ^3starter^1.^2lua^7")
-else
-    CreateThread(function()
-        while not Vehicles do Wait(1000) print("Waiting") end
-        debugPrint("^6Bridge^7: ^2Loading ^6"..countTable(Vehicles).." ^3Vehicles^2 from ^7"..vehResource)
     end)
 end
-
--------------------------------------------------------------
--- Loading Jobs and Gangs
--------------------------------------------------------------
--- Compile jobs and gangs from the detected framework.
-if isStarted(QBXExport) then
-    jobResource = QBXExport
-    Core = Core or exports[QBExport]:GetCoreObject()
-    Jobs, Gangs = exports[QBXExport]:GetJobs(), exports[QBXExport]:GetGangs()
-
-elseif isStarted(OXCoreExport) then
-    jobResource = OXExport
-    CreateThread(function()
-        if isServer() then
-            createCallback(getScript()..":getOxGroups", function(source)
-                Jobs = MySQL.query.await('SELECT * FROM `ox_groups`')
-                return Jobs
-            end)
-        else
-            local TempJobs = triggerCallback(getScript()..":getOxGroups")
-            Jobs = {}
-            for k, v in pairs(TempJobs) do
-                local grades = {}
-                --for i = 1, #v.grades do
-                --    grades[i] = { name = v.grades[i], isboss = (i == #v.grades) }
-                --end
-                Jobs[v.name] = { label = v.label, grades = grades }
-            end
-            Gangs = Jobs
-        end
-    end)
-
-elseif isStarted(QBExport) then
-    jobResource = QBExport
-    Core = Core or exports[QBExport]:GetCoreObject()
-    Jobs, Gangs = Core.Shared.Jobs, Core.Shared.Gangs
-    if isStarted(QBExport) and not isStarted(QBXExport) then
-        RegisterNetEvent('QBCore:Client:UpdateObject', function()
-            Core = exports[QBExport]:GetCoreObject()
-            Jobs, Gangs = Core.Shared.Jobs, Core.Shared.Gangs
-        end)
-    end
-
-elseif isStarted(ESXExport) then
-    ESX = exports[ESXExport]:getSharedObject()
-    if isServer() then
-        Jobs = ESX.GetJobs()
-        for k, v in pairs(Jobs) do
-            local count = countTable(Jobs[k].grades) - 1
-            Jobs[k].grades[tostring(count)].isBoss = true
-        end
-        Gangs = Jobs
-    end
-    CreateThread(function()
-        while not ESX do Wait(0) end
-        if isServer() then
-            createCallback(getScript()..":getJobs", function(source)
-                return Jobs
-            end)
-        end
-        if not isServer() then
-            Jobs = triggerCallback(getScript()..":getJobs")
-            Gangs = Jobs
-        end
-    end)
-
-elseif isStarted(RSGExport) then
-    jobResource = RSGExport
-    Core = Core or exports[RSGExport]:GetCoreObject()
-    Jobs, Gangs = Core.Shared.Jobs, Core.Shared.Gangs
-    if isStarted(RSGExport) and not isStarted(QBXExport) then
-        RegisterNetEvent('QBCore:Client:UpdateObject', function()
-            Core = exports[RSGExport]:GetCoreObject()
-            Jobs, Gangs = Core.Shared.Jobs, Core.Shared.Gangs
-        end)
-    end
-end
-
-if jobResource == nil then
-    print("^4ERROR^7: ^2No Vehicle info detected ^7- ^2Check ^3starter^1.^2lua^7")
-else
-    while not Jobs do Wait(100) end
-    debugPrint("^6Bridge^7: ^2Loading ^6"..countTable(Jobs).." ^3Jobs^2 from ^7"..jobResource)
-    debugPrint("^6Bridge^7: ^2Loading ^6"..countTable(Gangs).." ^3Gangs^2 from ^7"..jobResource)
-end

shared/crafting.lua

@@ -80,11 +80,6 @@ function craftingMenu(data)
     -- Build a table of all required ingredients (default quantity is 1).
     for i = 1, #Recipes do
         for k in pairs(Recipes[i]) do
-            if k == "hasCrafted" and not data.craftable.craftedItems then
-                -- Retreive list of already crafted items from playermetadata to see if we should class this recipe as "new"
-                craftedItems = GetMetadata(nil, "craftedItems") or {}
-                data.craftable.craftedItems = craftedItems
-            end
             if k ~= "amount" and k ~= "metadata" and k ~= "job" and k ~= "gang" then
                 tempCarryTable[k] = Recipes[i].amount or 1
             end
@@ -93,6 +88,7 @@ function craftingMenu(data)
 
     -- Check if the player can carry the required items (server callback).
     local canCarryTable = triggerCallback(getScript()..':server:canCarry', tempCarryTable)
+
     -- Process each recipe to create menu entries.
     for i = 1, #Recipes do
         if not Recipes[i]["amount"] then Recipes[i]["amount"] = 1 end
@@ -111,10 +107,13 @@ function craftingMenu(data)
                     local metaTable = {}
                     -- Build ingredient details.
                     for l, b in pairs(Recipes[i][tostring(k)]) do
-                        settext = settext..(settext ~= "" and br or "")..(Items[l] and Items[l].label or "error - "..l)..(b > 1 and " x"..b or "")
+                        local label = Items[l] and Items[l].label or "error - "..l
+                        local hasItem = checkStashItem(data.stashName, { [l] = b })
+                        local missingMark = not hasItem and " ❌" or " "
+                        settext = settext..(settext ~= "" and br or "").."[ x"..b.." ] - "..label..(b > 1 and " x"..b or "")..missingMark
+
                         metaTable[Items[l] and Items[l].label or "error - "..l] = b
                         itemTable[l] = b
-                        Wait(0)
                     end
 
                     while not canCarryTable do Wait(0) end
@@ -122,26 +121,17 @@ function craftingMenu(data)
                     setheader = ((metadata and metadata.label) or (Items[tostring(k)] and Items[tostring(k)].label) or "error - "..tostring(k))
                                ..(Recipes[i]["amount"] > 1 and " x"..Recipes[i]["amount"] or "")
 
-                    if not disable then
-                        if not canCarryTable[k] then
-                            setheader = setheader.." 📦"
-                        else
-                            setheader = setheader.." ✔️"
-                        end
-                    elseif not canCarryTable[k] then
-                        setheader = setheader.." 📦"
-                    end
-                    if Recipes[i]["hasCrafted"] ~= nil and craftedItems[k] == nil then
-                        setheader = "✨ "..setheader
-                    end
+                    local statusEmoji = disable and " " or not canCarryTable[k] and " 📦" or " ✔️"
+                    local isNew = (Recipes[i]["hasCrafted"] ~= nil and craftedItems[k] == nil) and "✨ " or ""
+                    setheader = isNew .. setheader .. statusEmoji
 
                     Menu[#Menu + 1] = {
-                        arrow = not disable and canCarryTable[k],
+                        arrow = isOx() and (not disable and canCarryTable[k]),
                         isMenuHeader = disable or not canCarryTable[k],
                         icon = invImg((metadata and metadata.image) or tostring(k)),
                         image = invImg((metadata and metadata.image) or tostring(k)),
-                        header = setheader..((disable or not canCarryTable[k]) and " ❌" or ""),
-                        txt = (isStarted(QBMenuExport) or disable) and settext or nil,
+                        header = setheader,
+                        txt = settext or nil,
                         metadata = metaTable,
                         onSelect = (not disable and canCarryTable[k]) and function()
                             local transdata = {
@@ -162,7 +152,7 @@ function craftingMenu(data)
                     }
                 end
             end
-            Wait(0)
+            --Wait(0)
         end
     end
 
@@ -208,16 +198,23 @@ end
 function multiCraft(data)
     local max = 0
     local stashName = nil
-    for i = 1, 100 do
-        local itemTable = {}
-        for l, b in pairs(data.craft[data.item]) do
-            debugPrint("")
-            itemTable[l] = (b * i)
-        end
+    local maxCreation = 100
 
+    -- Generate item table to check against stash or inventory
+    -- takes into account the ingredients needed for multiple items
+    local multiItemTable = {}
+
+    for i = 1, maxCreation do
+        multiItemTable[i] = {}
+        for l, b in pairs(data.craft[data.item]) do
+            multiItemTable[i][l] = (b * i)
+        end
+    end
+
+    for i = 1, maxCreation do
+        -- if its received a stash name, check if the items are in the stash
         if data.stashName then
-            debugPrint("")
-            local hasItems, stashname = checkStashItem(data.stashName, itemTable)
+            local hasItems, stashname = checkStashItem(data.stashName, multiItemTable[i])
             if hasItems == true then
                 max += 1
                 stashName = stashname
@@ -225,31 +222,34 @@ function multiCraft(data)
                 break
             end
         else
-            debugPrint("")
-            local has, _ = hasItem(itemTable, nil, nil)
+            -- if not check the players inventory for the items
+            local has, _ = hasItem(multiItemTable[i], nil, nil)
             if has then
                 max += 1
             else
                 break
             end
         end
-        Wait(10)
     end
 
-    local dialog = createInput(data.craftable.Header, {
+    local carryMax = triggerCallback(getScript()..":server:getMaxCarryCraft", {
+        item = data.item,
+        max = max
+    })
+
+    local dialog = createInput(data.craftable.Header..(Config.System.Menu == "qb" and ": "..br.."How many to craft? "..br.."Max: "..carryMax or ""), {
         ((Config.System.Menu == "ox") and {
             type = "slider",
-            label = "How many to craft?",
+            label = "How many to craft? "..br.."Max: "..carryMax,
             required = true,
             default = 1,
             min = 1,
-            max = max
+            max = carryMax
         }) or nil,
         ((Config.System.Menu == "qb") and {
             type = "number",
-            label = "How many to craft?"..br.."Max: "..max,
             name = "amount",
-            isRecuired = true,
+            isRequired = true,
             default = 1,
         }) or nil,
     })
@@ -259,14 +259,14 @@ function multiCraft(data)
 
         end
         if Config.System.Menu == "qb" then
-            if dialog["amount"] > max or dialog["amount"] < 1 or dialog["amount"] == nil or dialog["amount"] == "" then
+            dialog["amount"] = tonumber(dialog["amount"])
+            if dialog["amount"] > carryMax or dialog["amount"] < 1 or dialog["amount"] == nil or dialog["amount"] == "" then
                 triggerNotify(nil, "Invalid Amount", "error")
                 craftingMenu(data)
                 return
             end
         end
 
-
         makeItem({
             item = data.item,
             craft = data.craft,
@@ -274,7 +274,6 @@ function multiCraft(data)
             amount = dialog["amount"] or dialog[1],
             coords = data.coords,
             stashName = stashName or nil,
-            --stashTable = data.stashName,
             onBack = data.onBack,
             metadata = data.metadata,
         })
@@ -331,19 +330,27 @@ function makeItem(data)
     local crafted, crafting = true, true
     local cam = createTempCam(PlayerPedId(), data.coords)
     startTempCam(cam)
-
     for i = 1, craftAmount do
         for k, v in pairs(data.craft) do
             if not excludeKeys[k] then
                 if type(v) == "table" then
                     for l, b in pairs(v) do
+                        if isInventoryOpen() then
+                            print("^1Error^7: ^2Inventory is open, you tried to break things")
+                            crafted, crafting = false, false
+                            stopTempCam()
+                            ClearPedTasks(PlayerPedId())
+                            if canReturn then craftingMenu(data) end
+                            CraftLock = false
+                            return
+                        end
                         if crafting and progressBar({
                             label = "Using "..b.." "..Items[l].label,
                             time = 1000,
                             cancel = true,
                             dict = 'pickup_object',
                             anim = "putdown_low",
-                            flag = 48,
+                            flag = 49,
                             icon = l,
                         }) then
                             TriggerEvent((isStarted(QBInv) and QBInvNew and "qb-" or "")..'inventory:client:ItemBox', Items[l], "use", b)
@@ -353,6 +360,16 @@ function makeItem(data)
                         end
                         Wait(200)
                     end
+                    if isInventoryOpen() then
+                        print("^1Error^7: ^2Inventory is open, you tried to break things")
+                        crafted, crafting = false, false
+                        stopTempCam()
+                        ClearPedTasks(PlayerPedId())
+                        if canReturn then craftingMenu(data) end
+                        CraftLock = false
+                        return
+                    end
+
                     if crafted then
                         local craftProp = nil
                         if prop then
@@ -363,6 +380,12 @@ function makeItem(data)
                             local s = data.sound
                             PlaySoundFromEntity(s.soundId, s.audioName, PlayerPedId(), s.audioRef, true, 0)
                         end
+                        if isInventoryOpen() then
+                            --print("^1Error^7: ^2Inventory is open, you tried to break things")
+                            crafted, crafting = false, false
+                            crafted, crafting, CraftLock = false, false, false
+                            return
+                        end
                         if crafting and progressBar({
                             label = bartext..((metadata and metadata.label) or Items[data.item].label),
                             time = bartime,
@@ -371,8 +394,10 @@ function makeItem(data)
                             anim = anim,
                             flag = 49,
                             icon = data.item,
+                            request = true,
                         }) then
-                            TriggerServerEvent(getScript()..":Crafting:GetItem", data.item, data.craft, data.stashName, metadata)
+                            TriggerServerEvent(getScript()..":Crafting:GetItem", data.item, data.craft, data.stashName, metadata, currentToken)
+                            currentToken = nil -- clear client cached token
                             CreateThread(function()
                                 if data.craft["hasCrafted"] ~= nil then
                                     debugPrint("hasCrafted Found, marking '"..data.item.."' as crafted for player")
@@ -412,7 +437,6 @@ function makeItem(data)
     end
     stopTempCam()
     CraftLock = false
-    lockInv(false)
     if canReturn then craftingMenu(data) end
     ClearPedTasks(PlayerPedId())
 end
@@ -431,8 +455,19 @@ end
 --- @param stashName string|table The stash name(s) to remove ingredients from.
 --- @param metadata table (optional) Metadata for the crafted item.
 --- @usage
-RegisterNetEvent(getScript()..":Crafting:GetItem", function(ItemMake, craftable, stashName, metadata)
+RegisterNetEvent(getScript()..":Crafting:GetItem", function(ItemMake, craftable, stashName, metadata, token)
     local src = source
+    debugPrint(GetInvokingResource())
+	if GetInvokingResource() and GetInvokingResource() ~= getScript() and GetInvokingResource() ~= "qb-core" then
+        debugPrint("^1Error^7: ^1Possible exploit^7, ^1vital function was called from an external resource^7")
+        return
+    end
+
+    if not checkToken(src, token, "item", ItemMake) then
+        return
+    end
+
+
     local hasItems, hasTable = hasItem(ItemMake, 1, src)
     if stashName then
         local itemRemove = {}
@@ -441,7 +476,9 @@ RegisterNetEvent(getScript()..":Crafting:GetItem", function(ItemMake, craftable,
                 stashItems = getStash(name)
                 for k, v in pairs(craftable[ItemMake] or {}) do
                     for _, b in pairs(stashItems or {}) do
-                        if k == b.name then itemRemove[k] = v end
+                        if k == b.name then
+                            itemRemove[k] = v
+                        end
                     end
                 end
             end
@@ -449,7 +486,9 @@ RegisterNetEvent(getScript()..":Crafting:GetItem", function(ItemMake, craftable,
             stashItems = getStash(stashName)
             for k, v in pairs(craftable[ItemMake] or {}) do
                 for _, b in pairs(stashItems or {}) do
-                    if k == b.name then itemRemove[k] = v end
+                    if k == b.name then
+                        itemRemove[k] = v
+                    end
                 end
             end
         end

shared/helpers.lua

@@ -21,6 +21,10 @@
 --- end
 --- ```
 function isStarted(script)
+    if not script then
+        print("^1Error^7: ^1Tried to check if ^3nil^2 was started^7, ^1returning ^4false^7")
+        return false
+    end
     return GetResourceState(script):find("start") ~= nil
 end
 
@@ -52,6 +56,25 @@ function isServer()
     return IsDuplicityVersion()
 end
 
+function checkExportExists(resource, export)
+    if not resource or not export then return false end
+
+    local exists = false
+    local ok, result = pcall(function()
+        exists = type(exports[resource][export]) == "function"
+    end)
+
+    if ok and exists then
+        debugPrint(("^3Export Check^7: ^5exports^7['^5%s^7']:^5%s^7() ^2Exists^7"):format(resource, export))
+        return true
+    else
+        debugPrint(("^3Export Check^7: ^5exports^7['^5%s^7']:^5%s^7() ^1Doesn^7'^1t Exist^7"):format(resource, export))
+        return false
+    end
+end
+
+
+
 -------------------------------------------------------------
 -- Debugging and JSON Utilities
 -------------------------------------------------------------
@@ -258,7 +281,7 @@ end
 --- ```
 function countTable(tbl)
     local i = 0
-    for _ in pairs(tbl) do i = i + 1 end
+    for _ in pairs(tbl) do i += 1 end
     return i
 end
 
@@ -470,7 +493,7 @@ end
 --- end
 --- ```
 function ensureNetToVeh(vehNetID)
-    debugPrint("^6Bridge^7: ^3ensureNetToVeh^7: ^2Requesting NetworkDoesNetworkIdExist^7(^6"..vehNetID.."^7)")
+    --debugPrint("^6Bridge^7: ^3ensureNetToVeh^7: ^2Requesting NetworkDoesNetworkIdExist^7(^6"..vehNetID.."^7)")
     local timeout = 100
     while not NetworkDoesNetworkIdExist(vehNetID) and timeout > 0 do
         timeout -= 1
@@ -498,7 +521,7 @@ end
 --- end
 --- ```
 function ensureNetToEnt(entNetID)
-    debugPrint("^6Bridge^7: ^3ensureNetToEnt^7: ^2Requesting NetworkDoesNetworkIdExist^7(^6"..entNetID.."^7)")
+    --debugPrint("^6Bridge^7: ^3ensureNetToEnt^7: ^2Requesting NetworkDoesNetworkIdExist^7(^6"..entNetID.."^7)")
     local timeout = 100
     while not NetworkDoesNetworkIdExist(entNetID) and timeout > 0 do
         timeout -= 1
@@ -546,6 +569,24 @@ end
 
 RegisterNetEvent(getScript()..":server:sendlog", sendServerLog)
 
+
+-- This function was created to help create random numbers
+-- When you create a table of items with a random hunger value for example
+-- `hunger = math.random(10, 20)` this will be set at script start and never change
+-- using `hunger = {10, 20}` and then calling this function will make it generate a random number every time
+-- It also fallsback if it simply recieved a number instead of a table
+-- For example:
+-- local hunger = {10, 20}
+-- local hungerAmount = GetRandomTiming(hunger)
+-- print(hungerAmount) -- number between 10, 20
+function GetRandomTiming(tbl)
+	if type(tbl) == "table" then
+		return math.random(tbl[1], tbl[2])
+	else
+		return tbl
+	end
+end
+
 -------------------------------------------------------------
 -- Material and Prop Functions
 -------------------------------------------------------------

shared/inventories.lua

@@ -15,6 +15,7 @@
 function lockInv(toggle)
     FreezeEntityPosition(PlayerPedId(), toggle)
     LocalPlayer.state:set("inv_busy", toggle, true)
+    LocalPlayer.state:set("invBusy", toggle, true)
     TriggerEvent('inventory:client:busy:status', toggle)
     TriggerEvent('canUseInventoryAndHotbar:toggle', not toggle)
 end
@@ -49,8 +50,9 @@ function hasItem(items, amount, src)
 
             local count = 0
             for _, itemData in pairs(grabInv) do
+                --jsonPrint(itemData)
                 if itemData and itemData.name == item then
-                    count += (itemData.count or itemData.amount or 1)
+                    count += (itemData.amount or itemData.count or 1)
                 end
             end
             foundInv = foundInv:gsub("%-", "^7-^6"):gsub("%_", "^7_^6")
@@ -66,6 +68,9 @@ function hasItem(items, amount, src)
         end
         return true, hasTable
     end
+    -- if can't find inventory, return false
+    print("^1Error^7: ^1Can't find players inventory for some reason")
+    return false, {}
 end
 
 --- Retrieves a player's inventory based on the active inventory system.
@@ -120,9 +125,25 @@ function getPlayerInv(src)
     elseif isStarted(CodeMInv) then
         foundInv = CodeMInv
         if src then
-            grabInv = exports[CodeMInv]:GetInventory(src)
+            grabInv = exports[CodeMInv]:GetInventory(getPlayer(src).citizenId, src)
         else
-            grabInv = exports[CodeMInv]:GetClientPlayerInventory()
+            grabInv = exports[CodeMInv]:getUserInventory()
+        end
+
+    elseif isStarted(TgiannInv) then
+        foundInv = TgiannInv
+        if src then
+            grabInv = exports[TgiannInv]:GetPlayerItems(src)
+        else
+            grabInv = exports[TgiannInv]:GetPlayerItems()
+        end
+
+    elseif isStarted(JPRInv) then
+        foundInv = JPRInv
+        if src then
+            grabInv = Core.Functions.GetPlayer(src).PlayerData.items
+        else
+            grabInv = Core.Functions.GetPlayerData().items
         end
 
     elseif isStarted(QBInv) then
@@ -135,8 +156,11 @@ function getPlayerInv(src)
 
     elseif isStarted(PSInv) then
         foundInv = PSInv
-        if src then grabInv = Core.Functions.GetPlayer(src).PlayerData.items
-        else grabInv = Core.Functions.GetPlayerData().items end
+        if src then
+            grabInv = Core.Functions.GetPlayer(src).PlayerData.items
+        else
+            grabInv = Core.Functions.GetPlayerData().items
+        end
 
     elseif ESX and isStarted(ESXExport) then
         foundInv = ESX
@@ -160,4 +184,63 @@ function getPlayerInv(src)
         print("^4ERROR^7: ^2No Inventory detected ^7- ^2Check ^3starter^1.^2lua^7")
     end
     return grabInv, foundInv
+end
+
+function isInventoryOpen()
+
+    return IsNuiFocused()
+
+end
+
+-------------------------------------------------------------
+-- Item Image Retrieval
+-------------------------------------------------------------
+
+--- Retrieves the NUI link for an item's image from the active inventory system.
+---
+--- @param item string The item name.
+--- @return string string A `nui://` link to the item's image, or an empty string if not found.
+---
+--- @usage
+--- ```lua
+--- local imageLink = invImg("health_potion")
+--- if imageLink ~= "" then print(imageLink) end
+--- ```
+function invImg(item)
+    local imgLink = ""
+    if item ~= "" and Items[item] then
+        if isStarted(OXInv) then
+            imgLink = "nui://"..OXInv.."/web/images/"..(Items[item].image or "")
+
+        elseif isStarted(QSInv) then
+            imgLink = "nui://"..QSInv.."/html/images/"..(Items[item].image or "")
+
+        elseif isStarted(CoreInv) then
+            imgLink = "nui://"..CoreInv.."/html/img/"..(Items[item].image or "")
+
+        elseif isStarted(CodeMInv) then
+            imgLink = "nui://"..CodeMInv.."/html/itemimages/"..(Items[item].image or "")
+
+        elseif isStarted(OrigenInv) then
+            imgLink = "nui://"..OrigenInv.."/html/img/"..(Items[item].image or "")
+
+        elseif isStarted(JPRInv) then
+            imgLink = "nui://"..JPRInv.."/html/images/"..(Items[item].image or "")
+
+        elseif isStarted(QBInv) then
+            imgLink = "nui://"..QBInv.."/html/images/"..(Items[item].image or "")
+
+        elseif isStarted(PSInv) then
+            imgLink = "nui://"..PSInv.."/html/images/"..(Items[item].image or "")
+        elseif isStarted(TgiannInv) then
+            imgLink = "nui://inventory_images/images/"..(Items[item].image or "")
+
+        elseif isStarted(RSGInv) then
+            imgLink = "nui://"..RSGInv.."/html/images/"..(Items[item].image or "")
+
+        else
+            print("^4ERROR^7: ^2No Inventory detected for invImg - Check starter.lua")
+        end
+    end
+    return imgLink
 end

shared/itemcontrol.lua

@@ -31,57 +31,27 @@ validTokens = {}
 --- ```
 function createUseableItem(item, funct)
     if isStarted(ESXExport) then
-        debugPrint("^6Bridge^7: ^2Registering item as ^3Usable^2 with ^7es_extended", item)
+        debugPrint("^6Bridge^7: ^2Registering item as ^3Usable^2 with ^7es_extended^7", item)
         while not ESX do Wait(0) end
         ESX.RegisterUsableItem(item, funct)
+
     elseif isStarted(QBExport) and not isStarted(QBXExport) then
-        debugPrint("^6Bridge^7: ^2Registering item as ^3Usable^2 with ^7qb-core", item)
+        debugPrint("^6Bridge^7: ^2Registering item as ^3Usable^2 with ^7qb-core^7", item)
         Core.Functions.CreateUseableItem(item, funct)
+
     elseif isStarted(QBXExport) then
-        debugPrint("^6Bridge^7: ^2Registering item as ^3Usable^2 with ^7qbx_core", item)
+        debugPrint("^6Bridge^7: ^2Registering item as ^3Usable^2 with ^7qbx_core^7", item)
         exports[QBXExport]:CreateUseableItem(item, funct)
+
+    elseif isStarted(RSGExport) then
+        debugPrint("^6Bridge^7: ^2Registering item as ^3Usable^2 with ^1rsg-core^7", item)
+        Core.Functions.CreateUseableItem(item, funct)
+
     else
         print("^4ERROR^7: No supported framework detected for registering usable item: ^3"..item.."^7")
     end
 end
 
--------------------------------------------------------------
--- Item Image Retrieval
--------------------------------------------------------------
-
---- Retrieves the NUI link for an item's image from the active inventory system.
----
---- @param item string The item name.
---- @return string string A `nui://` link to the item's image, or an empty string if not found.
----
---- @usage
---- ```lua
---- local imageLink = invImg("health_potion")
---- if imageLink ~= "" then print(imageLink) end
---- ```
-function invImg(item)
-    local imgLink = ""
-    if item ~= "" and Items[item] then
-        if isStarted(OXInv) then
-            imgLink = "nui://"..OXInv.."/web/images/"..(Items[item].image or "")
-        elseif isStarted(QSInv) then
-            imgLink = "nui://"..QSInv.."/html/images/"..(Items[item].image or "")
-        elseif isStarted(CoreInv) then
-            imgLink = "nui://"..CoreInv.."/html/img/"..(Items[item].image or "")
-        elseif isStarted(CodeMInv) then
-            imgLink = "nui://"..CodeMInv.."/html/itemimages/"..(Items[item].image or "")
-        elseif isStarted(OrigenInv) then
-            imgLink = "nui://"..OrigenInv.."/html/img/"..(Items[item].image or "")
-        elseif isStarted(QBInv) then
-            imgLink = "nui://"..QBInv.."/html/images/"..(Items[item].image or "")
-        elseif isStarted(RSGInv) then
-            imgLink = "nui://"..RSGInv.."/html/images/"..(Items[item].image or "")
-        else
-            print("^4ERROR^7: ^2No Inventory detected for invImg - Check starter.lua")
-        end
-    end
-    return imgLink
-end
 
 -------------------------------------------------------------
 -- Adding and Removing Items
@@ -162,7 +132,7 @@ end
 --- TriggerServerEvent(getScript()..":server:toggleItem", true, "health_potion", 1)
 --- ```
 RegisterNetEvent(getScript()..":server:toggleItem", function(give, item, amount, newsrc, info, slot, token)
-    debugPrint(GetInvokingResource())
+    --debugPrint(GetInvokingResource())
 	if GetInvokingResource() and GetInvokingResource() ~= getScript() and GetInvokingResource() ~= "qb-core" then
         debugPrint("^1Error^7: ^1Possible exploit^7, ^1vital function was called from an external resource^7")
         return
@@ -174,21 +144,9 @@ RegisterNetEvent(getScript()..":server:toggleItem", function(give, item, amount,
 
     local src = newsrc or source
     if (give == true or give == 1) then
-        if newsrc == nil then -- must be coming from client this would be blank
-            if token == nil then
-                debugPrint("^1Auth^7: ^1No token recieved^7")
-                dupeWarn(src, item, "Auth: Player "..src.." attempted to spawn "..item.." without an auth token")
-            else
-                if type(token) ~= "number" then -- checks if the newsrc is a source or token, if number its coming form the server itself
-                    debugPrint("^1Auth^7: ^2Auth token received^7, ^2checking against server cache^7..")
-                    if token ~= validTokens[src] then
-                        debugPrint("^1Auth^7: ^1Tokens don't match! ^7", token, validTokens[src])
-                        dupeWarn(src, item, "Auth: "..src.." attempted to spawn "..item.." with an incorrect auth token")
-                    else
-                        debugPrint("^1Auth^7: ^2Client and Server Auth tokens match^7!", token, validTokens[src])
-                        validTokens[src] = nil
-                    end
-                end
+        if newsrc == nil then -- this must be coming from client this would be blank
+            if not checkToken(src, token, "item", item) then
+                return
             end
         end
     end
@@ -204,22 +162,32 @@ RegisterNetEvent(getScript()..":server:toggleItem", function(give, item, amount,
             dupeWarn(src, item, amount)
 
         else
-            if isStarted(OXInv) then invName = OXInv
+            if isStarted(OXInv) then
+                invName = OXInv
                 exports[OXInv]:RemoveItem(src, item, remamount, nil)
 
-            elseif isStarted(QSInv) then invName = QSInv
+            elseif isStarted(QSInv) then
+                invName = QSInv
                 exports[QSInv]:RemoveItem(src, item, remamount)
 
-            elseif isStarted(CoreInv) then invName = CoreInv
+            elseif isStarted(CoreInv) then
+                invName = CoreInv
                 exports[CoreInv]:removeItem(src, item, remamount)
 
-            elseif isStarted(OrigenInv) then invName = OrigenInv
+            elseif isStarted(OrigenInv) then
+                invName = OrigenInv
                 exports[OrigenInv]:removeItem(src, item, remamount)
 
-            elseif isStarted(CodeMInv) then invName = CodeMInv
+            elseif isStarted(CodeMInv) then
+                invName = CodeMInv
                 exports[CodeMInv]:RemoveItem(src, item, remamount)
 
-            elseif isStarted(QBInv) then invName = QBInv
+            elseif isStarted(TgiannInv) then
+                invName = TgiannInv
+                exports[TgiannInv]:RemoveItem(src, item, remamount)
+
+            elseif isStarted(JPRInv) then
+                invName = JPRInv
                 while remamount > 0 do
                     if Core.Functions.GetPlayer(src).Functions.RemoveItem(item, 1, slot) then
                         remamount -= 1
@@ -228,10 +196,26 @@ RegisterNetEvent(getScript()..":server:toggleItem", function(give, item, amount,
                         break
                     end
                 end
-                if Config.Crafting.showItemBox then
+                if Config.Crafting ~= nil and Config.Crafting.showItemBox then
+                    TriggerClientEvent("inventory:client:ItemBox", src, Items[item], "remove", amount or 1)
+                end
+
+            elseif isStarted(QBInv) then
+                invName = QBInv
+                while remamount > 0 do
+                    if Core.Functions.GetPlayer(src).Functions.RemoveItem(item, 1, slot) then
+                        remamount -= 1
+                    else
+                        print("^1Error removing "..item.." Amount left: "..remamount)
+                        break
+                    end
+                end
+                if Config.Crafting ~= nil and Config.Crafting.showItemBox then
                     TriggerClientEvent((isStarted(QBInv) and QBInvNew and "qb-" or "").."inventory:client:ItemBox", src, Items[item], "remove", amount or 1)
                 end
-            elseif isStarted(PSInv) then invName = PSInv
+
+            elseif isStarted(PSInv) then
+                invName = PSInv
                 while remamount > 0 do
                     if Core.Functions.GetPlayer(src).Functions.RemoveItem(item, 1, slot) then
                         remamount -= 1
@@ -240,7 +224,7 @@ RegisterNetEvent(getScript()..":server:toggleItem", function(give, item, amount,
                         break
                     end
                 end
-                if Config.Crafting.showItemBox then
+                if Config.Crafting ~= nil and Config.Crafting.showItemBox then
                     TriggerClientEvent("inventory:client:ItemBox", src, Items[item], "remove", amount or 1)
                 end
 
@@ -253,7 +237,7 @@ RegisterNetEvent(getScript()..":server:toggleItem", function(give, item, amount,
                         break
                     end
                 end
-                if Config.Crafting.showItemBox then
+                if Config.Crafting ~= nil and Config.Crafting.showItemBox then
                     TriggerClientEvent("rsg-inventory:client:ItemBox", src, Items[item], "remove", amount or 1)
                 end
 
@@ -282,6 +266,7 @@ RegisterNetEvent(getScript()..":server:toggleItem", function(give, item, amount,
     else
         local amountToAdd = amount or 1
         if isStarted(OXInv) then invName = OXInv
+            jsonPrint(info)
             exports[OXInv]:AddItem(src, item, amountToAdd, info, slot)
 
         elseif isStarted(QSInv) then invName = QSInv
@@ -296,22 +281,33 @@ RegisterNetEvent(getScript()..":server:toggleItem", function(give, item, amount,
         elseif isStarted(OrigenInv) then invName = OrigenInv
             exports[OrigenInv]:addItem(src, item, amountToAdd, info, slot)
 
+        elseif isStarted(TgiannInv) then invName = TgiannInv
+            exports[TgiannInv]:AddItem(src, item, amountToAdd, slot, info)
+
+        elseif isStarted(JPRInv) then invName = JPRInv
+            if Core.Functions.GetPlayer(src).Functions.AddItem(item, amountToAdd, nil, info) then
+                if Config.Crafting ~= nil and Config.Crafting.showItemBox then
+                    TriggerClientEvent("ps-inventory:client:ItemBox", src, Items[item], "add", amountToAdd)
+                end
+            end
+
         elseif isStarted(QBInv) then invName = QBInv
             if Core.Functions.GetPlayer(src).Functions.AddItem(item, amountToAdd, nil, info) then
                 TriggerClientEvent((isStarted(QBInv) and QBInvNew and "qb-" or "").."inventory:client:ItemBox", src, Items[item], "add", amountToAdd)
             end
 
+        elseif isStarted(PSInv) then invName = PSInv
+            if Core.Functions.GetPlayer(src).Functions.AddItem(item, amountToAdd, nil, info) then
+                if Config.Crafting ~= nil and Config.Crafting.showItemBox then
+                    TriggerClientEvent("ps-inventory:client:ItemBox", src, Items[item], "add", amountToAdd)
+                end
+            end
+
         elseif isStarted(RSGInv) then invName = RSGInv
             if Core.Functions.GetPlayer(src).Functions.AddItem(item, amountToAdd, nil, info) then
                 TriggerClientEvent("rsg-inventory:client:ItemBox", src, Items[item], "add", amountToAdd)
             end
 
-        elseif isStarted(PSInv) then invName = PSInv
-            if Core.Functions.GetPlayer(src).Functions.AddItem(item, amountToAdd, nil, info) then
-                if Config.Crafting.showItemBox then
-                    TriggerClientEvent("inventory:client:ItemBox", src, Items[item], "add", amountToAdd)
-                end
-            end
         end
 
         if invName == "" then
@@ -347,13 +343,13 @@ end)
 --- ```lua
 --- dupeWarn(playerId, "health_potion")
 --- ```
-function dupeWarn(src, item, amount)
+function dupeWarn(src, item, message)
     local name = getPlayer(src).name
-    print("^5DupeWarn^7: "..name.." (^1"..tostring(src).."^7) ^2Tried to remove item '^3"..item.."^7' but it wasn't there")
+    print(message or "^5DupeWarn^7: "..name.." (^1"..tostring(src).."^7) ^2Tried to remove item '^3"..item.."^7'^2 but it wasn't there^7")
     if not debugMode then
-        DropPlayer(src, name.."("..tostring(src)..") Kicked for suspected duplicating items: "..item)
+        DropPlayer(src, name.."("..tostring(src)..") kicked by exploit protection")
     end
-    print("^5DupeWarn^7: "..name.."(^1"..tostring(src).."^7) ^2Dropped from server - exploit protection detected an item not being found in players inventory^7")
+    print("^5DupeWarn^7: "..name.."(^1"..tostring(src).."^7) ^2Dropped from server - exploit protection^7")
 end
 
 -------------------------------------------------------------
@@ -404,13 +400,13 @@ end
 function getDurability(item)
     local lowestSlot = 100
     local durability = nil
-    if isStarted(QBInv) or isStarted(PSInv) or isStarted(RSGInv) then
+    if isStarted(QBInv) or isStarted(PSInv) or isStarted(RSGInv) or isStarted(JPRInv) then
         local itemcheck = Core.Functions.GetPlayerData().items
         for k, v in pairs(itemcheck) do
             if v.name == item then
                 if v.slot <= lowestSlot then
                     lowestSlot = v.slot
-                    durability = itemcheck[k].info.durability
+                    durability = itemcheck[k].info and itemcheck[k].info.durability or nil
                 end
             end
         end
@@ -422,7 +418,7 @@ function getDurability(item)
             if v.slot <= lowestSlot then
                 debugPrint(v.slot, itemcheck[k].metadata.durability)
                 lowestSlot = v.slot
-                durability = v.metadata.durability
+                durability = v.metadata and v.metadata.durability or nil
             end
         end
     end
@@ -432,7 +428,7 @@ function getDurability(item)
         for _, v in pairs(itemcheck) do
             if v.name == item and v.slot <= lowestSlot then
                 lowestSlot = v.slot
-                durability = v.metadata.durability
+                durability = v.info and v.info.durability or nil
             end
         end
     end
@@ -442,7 +438,7 @@ function getDurability(item)
         for _, v in pairs(itemcheck) do
             if v.name == item and v.slot <= lowestSlot then
                 lowestSlot = v.slot
-                durability = v.metadata.durability
+                durability = v.metadata and v.metadata.durability or nil
             end
         end
     end
@@ -450,9 +446,9 @@ function getDurability(item)
     if isStarted(CodeMInv) then
         local itemcheck = exports[CodeMInv]:GetClientPlayerInventory()
         for _, v in pairs(itemcheck) do
-            if v.name == item and v.slot <= lowestSlot then
-                lowestSlot = v.slot
-                durability = v.metadata.durability
+            if v.name == item and tonumber(v.slot) <= lowestSlot then
+                lowestSlot = tonumber(v.slot)
+                durability = v.info and v.info.durability or nil
             end
         end
     end
@@ -462,7 +458,17 @@ function getDurability(item)
         for _, v in pairs(itemcheck) do
             if v.name == item and v.slot <= lowestSlot then
                 lowestSlot = v.slot
-                durability = v.metadata.durability
+                durability = v.metadata and v.metadata.durability or nil
+            end
+        end
+    end
+
+    if isStarted(TgiannInv) then
+        local itemcheck = exports[TgiannInv]:GetPlayerItems()
+        for _, v in pairs(itemcheck) do
+            if v.name == item and v.slot <= lowestSlot then
+                lowestSlot = v.slot
+                durability = v.metadata and v.metadata.durability or nil
             end
         end
     end
@@ -503,7 +509,7 @@ end
 --- ```
 RegisterNetEvent(getScript()..":server:setMetaData", function(data)
     local src = source
-    if isStarted(QBInv) or isStarted(PSInv) or isStarted(RSGInv) then
+    if isStarted(QBInv) or isStarted(PSInv) or isStarted(RSGInv) or isStarted(JPRInv) then
         debugPrint(src, data.item, 1, data.slot)
         local Player = Core.Functions.GetPlayer(src)
         Player.PlayerData.items[data.slot].info = data.metadata
@@ -524,6 +530,9 @@ RegisterNetEvent(getScript()..":server:setMetaData", function(data)
 
     elseif isStarted(OrigenInv) then
         exports[OrigenInv]:setMetadata(src, data.slot, data.metadata)
+
+    elseif isStarted(TgiannInv) then
+        exports[TgiannInv]:UpdateItemMetadata(src, data.item, data.slot, data.metadata)
     end
 end)
 
@@ -633,9 +642,47 @@ function canCarry(itemTable, src)
                 resultTable[k] = exports[OrigenInv]:canCarryItem(src, k, v)
             end
 
-        elseif isStarted(QBInv) then
+        elseif isStarted(TgiannInv) then
             for k, v in pairs(itemTable) do
-                resultTable[k] = exports[QBInv]:CanAddItem(src, k, v)
+                resultTable[k] = exports[TgiannInv]:CanCarryItem(source, k, v)
+            end
+
+        elseif isStarted(JPRInv) then
+            local items = getPlayerInv(src)
+            local totalWeight = 0
+            if not items then return false end
+            for _, item in pairs(items) do
+                totalWeight += (item.weight * item.amount)
+            end
+            for k, v in pairs(itemTable) do
+                local itemInfo = Items[k]
+                if not itemInfo then
+                    resultTable[k] = true
+                else
+                    resultTable[k] = (totalWeight + (itemInfo.weight * v)) <= InventoryWeight
+                end
+            end
+
+        elseif isStarted(QBInv) then
+            if QBInvNew then
+                for k, v in pairs(itemTable) do
+                    resultTable[k] = exports[QBInv]:CanAddItem(src, k, v)
+                end
+            else
+                local items = getPlayerInv(src)
+                local totalWeight = 0
+                if not items then return false end
+                for _, item in pairs(items) do
+                    totalWeight += (item.weight * item.amount)
+                end
+                for k, v in pairs(itemTable) do
+                    local itemInfo = Items[k]
+                    if not itemInfo then
+                        resultTable[k] = true
+                    else
+                        resultTable[k] = (totalWeight + (itemInfo.weight * v)) <= InventoryWeight
+                    end
+                end
             end
 
         elseif isStarted(PSInv) then
@@ -647,7 +694,7 @@ function canCarry(itemTable, src)
             end
             for k, v in pairs(itemTable) do
                 local itemInfo = Items[k]
-                if not itemInfo and not Player.Offline then
+                if not itemInfo then
                     resultTable[k] = true
                 else
                     resultTable[k] = (totalWeight + (itemInfo.weight * v)) <= InventoryWeight
@@ -669,13 +716,33 @@ if isServer() then
         return result
     end)
 
+    createCallback(getScript()..":server:getMaxCarryCraft", function(source, data)
+        local src = source
+        local item = data.item
+        local max = data.max or 100
+
+        local maxCanCarry = 0
+        for i = 1, max do
+            local checkTable = {
+                [item] = i
+            }
+            local result = canCarry(checkTable, src)
+            if result[item] == true then
+                maxCanCarry = i
+            else
+                break
+            end
+        end
+        return maxCanCarry
+    end)
+
     local AuthEvent = getScript()..":"..keyGen()..keyGen()..keyGen()..keyGen()..":"..keyGen()..keyGen()..keyGen()..keyGen()
     validTokens = validTokens or {}
 
     createCallback(AuthEvent, function(source)
         local src = source
         local token = keyGen()..keyGen()..keyGen()..keyGen()  -- Use a secure random generator here
-        debugPrint(GetInvokingResource())
+        --debugPrint(GetInvokingResource())
         if GetInvokingResource() and GetInvokingResource() ~= getScript() and GetInvokingResource() ~= "qb-core" then
             debugPrint("^1Error^7: ^1Possible exploit^7, ^1vital function was called from an external resource^7")
             return  ""
@@ -707,22 +774,83 @@ if isServer() then
     receivedEvent = {}
     createCallback(getScript()..":callback:GetAuthEvent", function(source)
         local src = source
-        debugPrint(GetInvokingResource())
+        --debugPrint(GetInvokingResource())
         if GetInvokingResource() and GetInvokingResource() ~= getScript() and GetInvokingResource() ~= "qb-core" then
             debugPrint("^1Error^7: ^1Possible exploit^7, ^1vital callback was called from an external resource^7")
             return ""
         end
         debugPrint("^1Auth^7: ^2Player Source^7: "..src.." ^2requested ^3AuthEvent^7", AuthEvent)
-        if not receivedEvent[src] then receivedEvent[src] = true
+        if not receivedEvent[src] then
+            receivedEvent[src] = true
             return AuthEvent
         else
             print("^1Auth^7: ^1Player ^7"..src.." ^1tried to request auth token more than once^7")
             return ""
         end
     end)
+
+    RegisterNetEvent(getScript()..":clearAuthEventRequest", function()
+        local src = source
+        debugPrint("^1Auth^7: ^2Manually clearing Auth Event for Player Source^7:", src, AuthEvent)
+        receivedEvent[src] = nil
+    end)
+
+    -- Multiuse function to check if the generated client token is valid
+    function checkToken(src, token, genType, name)
+        if token == nil then
+            debugPrint("^1Auth^7: ^1No token recieved^7")
+            if genType == "stash" then
+                dupeWarn(src, name, "^1Auth Error^7: ^3"..src.." ^1create a stash ^7"..name.." ^1without an auth token^7")
+            elseif genType == "item" then
+                dupeWarn(src, name, "^1Auth Error^7: ^3"..src.." ^1attempted to spawn an item ^7"..name.." ^1without an auth token^7")
+            end
+            return false
+        else
+            debugPrint("^1Auth^7: ^2Auth token received^7, ^2checking against server cache^7..")
+            if token ~= validTokens[src] then
+                debugPrint("^1Auth^7: ^1Tokens don't match! ^7", token, validTokens[src])
+                if genType == "stash" then
+                    dupeWarn(src, name, "^1Auth Error^7: ^3"..src.." ^1create a stash ^7"..name.." ^1with an incorrect auth token^7")
+                elseif genType == "item" then
+                    dupeWarn(src, name, "^1Auth Error^7: ^3"..src.." ^1attempted to spawn an item ^7"..name.." ^1with an incorrect auth token^7")
+                end
+                return false
+            else
+                debugPrint("^1Auth^7: ^2Client and Server Auth tokens match^7!", token, validTokens[src])
+                validTokens[src] = nil
+                return true
+            end
+        end
+    end
 else
     onPlayerLoaded(function()
         debugPrint("^1Auth^7: ^2Requesting ^3Auth Event^7")
         AuthEvent = triggerCallback(getScript()..":callback:GetAuthEvent")
     end, true)
+
+    onPlayerUnload(function()
+        debugPrint("^1Auth^7: ^2Clearing Auth Event^7")
+        TriggerServerEvent(getScript()..":clearAuthEventRequest")
+    end, true)
 end
+
+-------------------------------------------------------------
+-- Check Item Existance - return boolean(true,false)
+-------------------------------------------------------------
+
+--- checks whether an item exists in your item database
+---
+--- @param item string The item name.
+---
+--- @usage
+--- ```lua
+--- local item = "apple"
+--- if doesItemExist(item) then print("item exists") end
+--- ```
+function doesItemExist(item)
+    if not item or item == "" then return false end
+    if Items[item] ~= nil then
+        return true
+    end
+    return false
+end

shared/jobfunctions.lua

@@ -12,8 +12,16 @@
 -------------------------------------------------------------
 -- Global Duty Status
 -------------------------------------------------------------
+-- This attempts to sync up with the players framework onDuty variable
+-- This stops the script getting confused when one is false and one is true
 onDuty = false
 
+if not isServer() then
+    onPlayerLoaded(function()
+        onDuty = getPlayer().onDuty
+    end, true)
+end
+
 -------------------------------------------------------------
 -- Boss Role Detection
 -------------------------------------------------------------
@@ -38,7 +46,7 @@ function makeBossRoles(role)
     local data = (Jobs and Jobs[role]) or (Gangs and Gangs[role])
     if data then
         for grade, info in pairs(data.grades) do
-            if info.isboss or info.bankAuth then
+            if info.isboss or info.bankAuth or info.isBoss then
                 boss[role] = boss[role] and math.min(boss[role], tonumber(grade)) or tonumber(grade)
             end
         end
@@ -92,9 +100,14 @@ end
 --- toggleDuty()  -- Player receives a notification of their new duty status.
 --- ```
 function toggleDuty()
-    onDuty = not onDuty
     if isStarted(QBExport) or isStarted(QBXExport) then
         TriggerServerEvent("QBCore:ToggleDuty")
+        Wait(100)
+        onDuty = getPlayer().onDuty
+    elseif isStarted(RSGExport) then
+        TriggerServerEvent("RSGCore:ToggleDuty")
+        Wait(100)
+        onDuty = getPlayer().onDuty
     else
         if onDuty then
             triggerNotify(nil, "Now on duty", "success")
@@ -104,6 +117,15 @@ function toggleDuty()
     end
 end
 
+-- Framework specific functions to keep duty status synced
+RegisterNetEvent("QBCore:Client:OnJobUpdate", function(JobInfo) onDuty = JobInfo.onduty end)
+RegisterNetEvent("QBCore:Client:SetDuty", function(duty) onDuty = duty end)
+
+RegisterNetEvent("qbx_core:client:onJobUpdate", function(JobInfo) onDuty = JobInfo.onduty end)
+
+RegisterNetEvent("RSGCore:Client:OnJobUpdate", function(JobInfo) onDuty = JobInfo.onduty end)
+RegisterNetEvent("RSGCore:Client:SetDuty", function(duty) onDuty = duty end)
+
 -------------------------------------------------------------
 -- Interaction Functions
 -------------------------------------------------------------
@@ -209,3 +231,16 @@ function useDoor(data)
     DoScreenFadeIn(1000)
     Wait(100)
 end
+
+
+function openBossMenu(isGang, group)
+    if isStarted("qb-management") then
+        if isGang then
+            TriggerEvent("qb-gangmenu:client:OpenMenu")
+        else
+            TriggerEvent("qb-bossmenu:client:OpenMenu")
+        end
+    elseif isStarted("qbx_management") then
+        exports["qbx_management"]:OpenBossMenu(isGang and "gang" or "job")
+    end
+end

shared/make/makeBlip.lua

@@ -54,7 +54,7 @@ function makeBlip(data)
         AddTextComponentString(tostring(data.name))
         EndTextCommandSetBlipName(blip)
         -- Handle preview image if certain resources are running
-        if isStarted("fs_smallresources") or isStarted("blip_info") or isStarted("blipinfo") then
+        if isStarted("jim-blipcontroller") then
             if data.preview then
                 local txname = string.gsub(tostring(data.name..'preview'..string.gsub(data.coords.z, "%.", "")), "[ ()~]", "")
                 if data.preview:find("http") or data.preview:find("nui") then
@@ -62,8 +62,11 @@ function makeBlip(data)
                 else
                     CreateRuntimeTextureFromImage(scriptTxd, txname, data.preview)
                 end
-                exports["fs_smallresources"]:SetBlipInfoImage(blip, getScript()..'scriptTxd', txname)
-                exports["fs_smallresources"]:SetBlipInfoTitle(blip, data.name, false)
+                exports["jim-blipcontroller"]:ShowBlipInfo(blip, {
+                    title = data.name,
+                    dict = getScript()..'scriptTxd',
+                    tex = txname,
+                })
             end
         end
     end

shared/make/makeProp.lua

@@ -23,7 +23,7 @@ local Props = {}
 function makeProp(data, freeze, synced)
     loadModel(data.prop)
     local prop = CreateObject(data.prop, data.coords.x, data.coords.y, data.coords.z-1.03, synced and synced or false, synced and synced or false, false)
-    SetEntityHeading(prop, data.coords.w + 180.0)
+    SetEntityHeading(prop, (data.coords.w or 0) + 180.0)
     FreezeEntityPosition(prop, freeze or false)
 
     debugPrint("^6Bridge^7: ^1Prop ^2Created^7: '^6"..prop.."^7' | ^2Hash^7: ^7'^6"..data.prop.."^7' | ^2Coord^7: "..formatCoord(data.coords))

shared/make/progressBars.lua

@@ -43,9 +43,10 @@ function progressBar(data)
     local result = nil
     if data.cam then startTempCam(data.cam) end
     if Config.System.ProgressBar == "ox" then
-        if exports[OXLibExport]:progressBar({
+        local options = {
             duration = debugMode and 1000 or data.time,
             label = data.label,
+            position = data.position or "bottom",
             useWhileDead = data.dead or false,
 			canCancel = data.cancel and data.cancel or true,
             anim = {
@@ -55,12 +56,41 @@ function progressBar(data)
                 scenario = data.task
             },
             disable = {
-                combat = true
+                combat = data.combat or true,
+                move = data.movement or false,
+                car = data.carMovement or false,
+                mouse = data.mouse or false
             },
-        }) then
-            result = true
-        else
-            result = false
+        }
+        if data.prop and data.prop.model then
+            options.prop = {
+                model = data.prop.model,
+                pos = data.prop.pos or vec3(0, 0, 0),
+                rot = data.prop.rot or vec3(0, 0, 0),
+                bone = data.prop.bone or 0
+            }
+        end
+        if data.propTwo and data.propTwo.model then
+            options.propTwo = {
+                model = data.propTwo.model,
+                pos = data.propTwo.pos or vec3(0, 0, 0),
+                rot = data.propTwo.rot or vec3(0, 0, 0),
+                bone = data.propTwo.bone or 0
+            }
+        end
+        if data.progressType == "circle" then
+            if exports[OXLibExport]:progressCircle(options) then
+                result = true
+            else
+                result = false
+            end
+        end
+        if not data.progressType or data.progressType == "bar" then
+            if exports[OXLibExport]:progressBar(options) then
+                result = true
+            else
+                result = false
+            end
         end
 
     elseif Config.System.ProgressBar == "qb" then
@@ -179,7 +209,9 @@ function progressBar(data)
         inProgress = false
     end
 
-    while result == nil do Wait(10) end
+    while result == nil do
+        Wait(10)
+    end
 
     -- Cleanup
     FreezeEntityPosition(ped, false)
@@ -256,7 +288,7 @@ function stopProgressBar()
         exports[OXLibExport]:cancelProgress()
     elseif Config.System.ProgressBar == "qb" then
         TriggerEvent("progressbar:client:cancel")
-    elseif Config.System.ProgressBar == "gta" then
+    elseif Config.System.ProgressBar == "gta" or Config.System.ProgressBar == "red" then
         inProgress = false
     end
 end

shared/metaHandlers.lua

@@ -23,15 +23,23 @@ function GetPlayer(source)
     if isStarted(QBExport) then
         debugPrint("^6Bridge^7: ^3GetPlayer^7() QBExport")
         return exports[QBExport]:GetCoreObject().Functions.GetPlayer(source)
+
     elseif isStarted(QBXExport) then
         debugPrint("^6Bridge^7: ^3GetPlayer^7() QBOXExport")
         return exports[QBXExport]:GetCoreObject().Functions.GetPlayer(source)
+
     elseif isStarted(ESXExport) then
         debugPrint("^6Bridge^7: ^3GetPlayer^7() ESXExport")
         return ESX.GetPlayerFromId(source)
+
     elseif isStarted(OXCoreExport) then
         debugPrint("^6Bridge^7: ^3GetPlayer^7() OXCoreExport")
         return exports[OXCoreExport]:GetPlayer(source)
+
+    elseif isStarted(RSGExport) then
+        debugPrint("^6Bridge^7: ^3GetPlayer^7() RSGExport")
+        return exports[RSGExport]:GetCoreObject().Functions.GetPlayer(source)
+
     end
     return nil
 end
@@ -58,14 +66,21 @@ function GetMetadata(player, key)
         return triggerCallback(getScript()..":server:GetMetadata", key)
     else
         if isStarted(QBExport) or isStarted(QBXExport) then
-            debugPrint("^6Bridge^7: ^3GetMetadata^7() QBExport or QBXExport", key)
+            debugPrint("^6Bridge^7: ^3GetMetadata^7() QBExport/QBXExport", key)
             return player.PlayerData.metadata[key]
+
         elseif isStarted(ESXExport) then
             debugPrint("^6Bridge^7: ^3GetMetadata^7() ESXExport", key)
             return player.getMeta(key)
+
         elseif isStarted(OXCoreExport) then
             debugPrint("^6Bridge^7: ^3GetMetadata^7() OXCoreExport", key)
             return player.get(key)
+
+        elseif isStarted(RSGExport) then
+            debugPrint("^6Bridge^7: ^3GetMetadata^7() RSGExport", key)
+            return player.PlayerData.metadata[key]
+
         end
     end
     return nil
@@ -112,12 +127,19 @@ function SetMetadata(player, key, value)
     if isStarted(QBExport) or isStarted(QBXExport) then
         debugPrint("^6Bridge^7: ^3SetMetadata^7() using QBExport/QBXExport")
         player.Functions.SetMetaData(key, value)
+
     elseif isStarted(ESXExport) then
         debugPrint("^6Bridge^7: ^3SetMetadata^7() using ESXExport")
         player.setMeta(key, value)
+
     elseif isStarted(OXCoreExport) then
         debugPrint("^6Bridge^7: ^3SetMetadata^7() using OXCoreExport")
         player.set(key, value)
+
+    elseif isStarted(RSGExport) then
+        debugPrint("^6Bridge^7: ^3SetMetadata^7() using RSGExport")
+        player.Functions.SetMetaData(key, value)
+
     end
 end
 

shared/notify.lua

@@ -50,18 +50,10 @@ function triggerNotify(title, message, type, src)
             TriggerClientEvent('ox_lib:notify', src, { title = title, description = message, type = type or "success" })
         end
     elseif Config.System.Notify == "gta" then
-        if isStarted("jim-gtaui") then
-            if not src then
-                TriggerEvent("jim-gtaui:Notify", title, message, type)
-            else
-                TriggerClientEvent("jim-gtaui:Notify", src, title, message, type)
-            end
+        if not src then
+            exports.jim_bridge:Notify(title, message, type)
         else
-            if not src then
-                TriggerEvent(getScript()..":DisplayGTANotify", title, message)
-            else
-                TriggerClientEvent(getScript()..":DisplayGTANotify", src, title, message)
-            end
+            TriggerClientEvent("jim-bridge:Notify", src, title, message, type)
         end
     elseif Config.System.Notify == "esx" then
         if not src then
@@ -116,25 +108,25 @@ end)
 --- ```lua
 --- TriggerEvent(getScript()..":DisplayGTANotify", "taxiname", "Taxi service has arrived.")
 --- ```
-RegisterNetEvent(getScript()..":DisplayGTANotify", function(title, text)
-    local iconTable = {}
-    if getScript() == "jim-npcservice" then
-        iconTable = {
-            [Loc[Config.Lan].notify["taxiname"]] = "CHAR_TAXI",
-            [Loc[Config.Lan].notify["limoname"]] = "CHAR_CASINO",
-            [Loc[Config.Lan].notify["ambiname"]] = "CHAR_CALL911",
-            [Loc[Config.Lan].notify["pilotname"]] = "CHAR_DEFAULT",
-            [Loc[Config.Lan].notify["planename"]] = "CHAR_BOATSITE2",
-            [Loc[Config.Lan].notify["heliname"]] = "CHAR_BOATSITE2",
-        }
-    end
-
-    BeginTextCommandThefeedPost("STRING")
-    AddTextComponentSubstringKeyboardDisplay(text)
-    EndTextCommandThefeedPostMessagetext(
-        iconTable[title] or "CHAR_DEFAULT",
-        iconTable[title] or "CHAR_DEFAULT",
-        true, 1, title, nil, text
-    )
-    EndTextCommandThefeedPostTicker(true, false)
-end)
+--RegisterNetEvent(getScript()..":DisplayGTANotify", function(title, text)
+--    local iconTable = {}
+--    if getScript() == "jim-npcservice" then
+--        iconTable = {
+--            [Loc[Config.Lan].notify["taxiname"]] = "CHAR_TAXI",
+--            [Loc[Config.Lan].notify["limoname"]] = "CHAR_CASINO",
+--            [Loc[Config.Lan].notify["ambiname"]] = "CHAR_CALL911",
+--            [Loc[Config.Lan].notify["pilotname"]] = "CHAR_DEFAULT",
+--            [Loc[Config.Lan].notify["planename"]] = "CHAR_BOATSITE2",
+--            [Loc[Config.Lan].notify["heliname"]] = "CHAR_BOATSITE2",
+--        }
+--    end
+--
+--    BeginTextCommandThefeedPost("STRING")
+--    AddTextComponentSubstringKeyboardDisplay(text)
+--    EndTextCommandThefeedPostMessagetext(
+--        iconTable[title] or "CHAR_DEFAULT",
+--        iconTable[title] or "CHAR_DEFAULT",
+--        true, 1, title, nil, text
+--    )
+--    EndTextCommandThefeedPostTicker(true, false)
+--end)

shared/phones.lua

@@ -73,30 +73,142 @@ function sendPhoneMail(data)
                 TriggerServerEvent('qb-phone:server:sendNewMail', mailData)
             end,
         },
+        {   name = "npwd_qbx_mail",
+            send = function(mailData)
+                TriggerServerEvent('qb-phone:server:sendNewMail', mailData)
+            end,
+        },
         {   name = "jpr-phonesystem",
             send = function(mailData)
                 TriggerServerEvent(getScript()..":jpr:SendMail", mailData)
             end,
         },
+        {   name = "ef-phone",
+            send = function(mailData)
+                TriggerServerEvent('qb-phone:server:sendNewMail', mailData)
+            end,
+        },
     }
 
-    local activePhone = nil
     -- Check each phone system in order and use the first active one.
     for _, phone in ipairs(phoneSystems) do
         if isStarted(phone.name) then
-            activePhone = phone.name
+            debugPrint("^6Bridge^7[^3"..phone.name.."^7]: ^2Sending mail to player")
             phone.send(data)
-            break
+            return true
         end
     end
-
-    if activePhone then
-        debugPrint("^6Bridge^7[^3"..activePhone.."^7]: ^2Sending mail to player")
-    else
-        print("^6Bridge^7: ^1ERROR ^2Sending mail to player ^7- ^2No supported phone found")
-    end
+    print("^6Bridge^7: ^1ERROR ^2Sending mail to player ^7- ^2No supported phone found")
+    return false
 end
 
+function sendPhoneInvoice(data)
+    if not data.src then return end
+    -- Define each supported phone system and its corresponding mail-sending function.
+    local phoneSystems = {
+        {
+            name = "qb-phone",
+            send = function(mailData)
+                -- Defensive check for required fields
+                local required = { "billedCitizenid", "amount", "job", "name", "billerCitizenid", "src" }
+                for _, field in ipairs(required) do
+                    if mailData[field] == nil then
+                        print("^1[jim-payments] ERROR:^0 Missing field '" .. field .. "' in mailData")
+                        return
+                    end
+                end
+
+                -- Safe insert with all parameters present
+                MySQL.Async.insert(
+                    'INSERT INTO phone_invoices (citizenid, amount, society, sender, sendercitizenid) VALUES (?, ?, ?, ?, ?)',
+                    {
+                        mailData.billedCitizenid,
+                        mailData.amount,
+                        mailData.job,
+                        mailData.name,
+                        mailData.billerCitizenid
+                    },
+                    function(id)
+                        if id then
+                            TriggerClientEvent('qb-phone:client:AcceptorDenyInvoice', mailData.src, id, mailData.name, mailData.job, mailData.billerCitizenid, mailData.amount, GetInvokingResource())
+                        end
+                    end
+                )
+
+                TriggerClientEvent('qb-phone:RefreshPhone', mailData.src)
+            end
+        },
+        {
+            name = "codem-phone",
+            send = function(mailData)
+                -- Defensive check for required fields
+                local required = { "billedCitizenid", "amount", "job", "name", "billerCitizenid", "src" }
+                for _, field in ipairs(required) do
+                    if mailData[field] == nil then
+                        print("^1[jim-payments] ERROR:^0 Missing field '" .. field .. "' in mailData")
+                        return
+                    end
+                end
+
+                -- Safe insert with all parameters present
+                MySQL.Async.insert(
+                    'INSERT INTO phone_invoices (citizenid, amount, society, sender, sendercitizenid) VALUES (?, ?, ?, ?, ?)',
+                    {
+                        mailData.billedCitizenid,
+                        mailData.amount,
+                        mailData.job,
+                        mailData.name,
+                        mailData.billerCitizenid
+                    },
+                    function(id)
+                    --    if id then
+                    --        TriggerClientEvent('qb-phone:client:AcceptorDenyInvoice', mailData.src, id, mailData.name, mailData.job, mailData.billerCitizenid, mailData.amount, GetInvokingResource())
+                    --    end
+                    end
+                )
+
+
+            end
+        },
+        {
+            name = "gks-phone",
+            send = function(mailData)
+                -- Defensive check for required fields
+                local required = { "billedCitizenid", "amount", "job", "name", "billerCitizenid", "label" }
+                for _, field in ipairs(required) do
+                    if mailData[field] == nil then
+                        print("^1[jim-payments] ERROR:^0 Missing field '" .. field .. "' in mailData")
+                        return
+                    end
+                end
+
+                MySQL.Async.execute(
+                    'INSERT INTO gksphone_invoices (citizenid, amount, society, sender, sendercitizenid, label) VALUES (@citizenid, @amount, @society, @sender, @sendercitizenid, @label)',
+                    {
+                        ['@citizenid'] = mailData.billedCitizenid,
+                        ['@amount'] = mailData.amount,
+                        ['@society'] = mailData.job,
+                        ['@sender'] = mailData.name,
+                        ['@sendercitizenid'] = mailData.billerCitizenid,
+                        ['@label'] = mailData.label
+                    }
+                )
+            end
+        }
+    }
+
+
+    -- Check each phone system in order and use the first active one.
+    for _, phone in ipairs(phoneSystems) do
+        if isStarted(phone.name) then
+            debugPrint("^6Bridge^7[^3"..phone.name.."^7]: ^2Sending mail to player^7", data.src)
+            phone.send(data)
+            return true
+        end
+    end
+    print("^6Bridge^7: ^1ERROR ^2Sending mail to player ^7- ^2No supported phone found")
+    return false
+end
 -------------------------------------------------------------
 -- Phone System Event Handlers
 -------------------------------------------------------------

shared/playerfunctions.lua

@@ -109,13 +109,18 @@ end)
 --- setThirst(playerId, 80)
 --- ```
 function setThirst(src, thirst)
+
+    debugPrint("^4Debug^7: ^2Adding thirst^7: ^3"..thirst.." ^2to player^7: ^3"..src.."^7")
     if isStarted(ESXExport) then
         TriggerClientEvent('esx_status:add', src, 'thirst', thirst)
-    elseif isStarted(QBExport) or isStarted(QBXExport) then
+
+    elseif isStarted(QBExport) or isStarted(QBXExport) or isStarted(RSGExport) then
         local Player = Core.Functions.GetPlayer(src)
         Player.Functions.SetMetaData('thirst', thirst)
-        TriggerClientEvent("hud:client:UpdateNeeds", src, thirst, Player.PlayerData.metadata.thirst)
+        TriggerClientEvent("hud:client:UpdateNeeds", src, Player.PlayerData.metadata.hunger, thirst)
+
     end
+
 end
 
 --- Sets the player's hunger level.
@@ -128,12 +133,16 @@ end
 --- setHunger(playerId, 60)
 --- ```
 function setHunger(src, hunger)
+
+    debugPrint("^4Debug^7: ^2Adding hunger^7: ^3"..hunger.." ^2to player^7: ^3"..src.."^7")
     if isStarted(ESXExport) then
         TriggerClientEvent('esx_status:add', src, 'hunger', hunger)
-    elseif isStarted(QBExport) or isStarted(QBXExport) then
+
+    elseif isStarted(QBExport) or isStarted(QBXExport) or isStarted(RSGExport) then
         local Player = Core.Functions.GetPlayer(src)
         Player.Functions.SetMetaData('hunger', hunger)
-        TriggerClientEvent("hud:client:UpdateNeeds", src, hunger, Player.PlayerData.metadata.hunger)
+        TriggerClientEvent("hud:client:UpdateNeeds", src, hunger, Player.PlayerData.metadata.thirst)
+
     end
 end
 
@@ -141,6 +150,18 @@ end
 -- Economy Event Handlers
 -------------------------------------------------------------
 
+--- BillPlayer
+function billPlayer(data)
+    if not Config.System.Billing or Config.System.Billing == "jim" then
+        TriggerEvent("jim-payments:client:Charge", {
+            job = data.job,
+            gang = data.gang,
+            coords = data.coords.xyz,
+            img = data.img
+        })
+    end
+end
+
 --- Charges a player by removing money from their account.
 ---
 --- @param cost number The amount to charge.
@@ -161,20 +182,31 @@ function chargePlayer(cost, moneyType, newsrc)
     if moneyType == "cash" then
         if isStarted(OXInv) then fundResource = OXInv
             exports[OXInv]:RemoveItem(src, "money", cost)
+
         elseif isStarted(QBExport) or isStarted(QBXExport) then
             fundResource = QBExport
             Core.Functions.GetPlayer(src).Functions.RemoveMoney("cash", cost)
+
         elseif isStarted(RSGExport) then
-            fundResource = QBExport
+            fundResource = RSGExport
             Core.Functions.GetPlayer(src).Functions.RemoveMoney("cash", cost)
+
         elseif isStarted(ESXExport) then
             fundResource = ESXExport
             ESX.GetPlayerFromId(src).removeMoney(cost, "")
+
         end
     elseif moneyType == "bank" then
-        if isStarted(QBExport) or isStarted(QBXExport) then fundResource = QBExport
+        if isStarted(QBExport) or isStarted(QBXExport) then
+            fundResource = QBExport
             Core.Functions.GetPlayer(src).Functions.RemoveMoney("bank", cost)
-        elseif isStarted(ESXExport) then fundResource = ESXExport
+
+        elseif isStarted(RSGExport) then
+            fundResource = RSGExport
+            Core.Functions.GetPlayer(src).Functions.RemoveMoney("bank", cost)
+
+        elseif isStarted(ESXExport) then
+            fundResource = ESXExport
             ESX.GetPlayerFromId(src).removeMoney(cost, "")
         end
     end
@@ -212,17 +244,29 @@ function fundPlayer(fund, moneyType, newsrc)
         if isStarted(OXInv) then
             fundResource = OXInv
             exports[OXInv]:AddItem(src, "money", fund)
+
         elseif isStarted(QBExport) or isStarted(QBXExport) then
             fundResource = QBExport
             Core.Functions.GetPlayer(src).Functions.AddMoney("cash", fund)
+
+        elseif isStarted(RSGExport) then
+            fundResource = RSGExport
+            Core.Functions.GetPlayer(src).Functions.AddMoney("cash", fund)
+
         elseif isStarted(ESXExport) then
             fundResource = ESXExport
-            PlayESX.GetPlayerFromId(src).addMoney(fund, "")
+            ESX.GetPlayerFromId(src).addMoney(fund, "")
+
         end
     elseif moneyType == "bank" then
         if isStarted(QBExport) or isStarted(QBXExport) then
             fundResource = QBExport
             Core.Functions.GetPlayer(src).Functions.AddMoney("bank", fund)
+
+        elseif isStarted(RSGExport) then
+            fundResource = RSGExport
+            Core.Functions.GetPlayer(src).Functions.AddMoney("bank", fund)
+
         elseif isStarted(ESXExport) then
             fundResource = ESXExport
             ESX.GetPlayerFromId(src).addMoney(fund, "")
@@ -266,17 +310,17 @@ function ConsumeSuccess(itemName, type, data)
 
     if isStarted(ESXExport) then
         if hunger then
-            TriggerServerEvent(getScript()..":server:setNeed", "hunger", hunger * 10000)
+            TriggerServerEvent(getScript()..":server:setNeed", "hunger", tonumber(hunger) * 10000)
         end
         if thirst then
-            TriggerServerEvent(getScript()..":server:setNeed", "thirst", thirst * 10000)
+            TriggerServerEvent(getScript()..":server:setNeed", "thirst", tonumber(thirst) * 10000)
         end
     else
         if hunger then
-            TriggerServerEvent(getScript()..":server:setNeed", "hunger", Core.Functions.GetPlayerData().metadata["hunger"] + hunger)
+            TriggerServerEvent(getScript()..":server:setNeed", "hunger", Core.Functions.GetPlayerData().metadata["hunger"] + tonumber(hunger))
         end
         if thirst then
-            TriggerServerEvent(getScript()..":server:setNeed", "thirst", Core.Functions.GetPlayerData().metadata["thirst"] + thirst)
+            TriggerServerEvent(getScript()..":server:setNeed", "thirst", Core.Functions.GetPlayerData().metadata["thirst"] + tonumber(thirst))
         end
     end
 
@@ -290,7 +334,9 @@ function ConsumeSuccess(itemName, type, data)
         end
     end
 
-    getRandomReward(itemName)
+    if Config.Reward then
+        getRandomReward(itemName)
+    end
 end
 
 -------------------------------------------------------------
@@ -380,6 +426,35 @@ function hasJob(job, source, grade)
                     if grade and not (grade <= ganginfo.grade.level) then hasJobFlag = false end
                 end
             end
+
+        elseif isStarted(RSGExport) then
+            if Core.Functions.GetPlayer then
+                local player = Core.Functions.GetPlayer(src)
+                if not player then print("Player not found for src: "..src) end
+                local jobinfo = player.PlayerData.job
+                if jobinfo.name == job then
+                    hasJobFlag = true
+                    duty = player.PlayerData.job.onduty
+                    if grade and not (grade <= jobinfo.grade.level) then hasJobFlag = false end
+                end
+                local ganginfo = player.PlayerData.gang
+                if ganginfo.name == job then
+                    hasJobFlag = true
+                    if grade and not (grade <= ganginfo.grade.level) then hasJobFlag = false end
+                end
+            else
+                local jobinfo = exports[RSGExport]:GetPlayer(src).PlayerData.job
+                if jobinfo.name == job then
+                    hasJobFlag = true
+                    duty = exports[RSGExport]:GetPlayer(src).PlayerData.job.onduty
+                    if grade and not (grade <= jobinfo.grade.level) then hasJobFlag = false end
+                end
+                local ganginfo = exports[RSGExport]:GetPlayer(src).PlayerData.gang
+                if ganginfo.name == job then
+                    hasJobFlag = true
+                    if grade and not (grade <= ganginfo.grade.level) then hasJobFlag = false end
+                end
+            end
         else
             print("^4ERROR^7: ^2No Core detected for hasJob ^7- ^2Check ^3starter^1.^2lua^7")
         end
@@ -425,6 +500,22 @@ function hasJob(job, source, grade)
                 hasJobFlag = true
                 if grade and not (grade <= ganginfo.grade.level) then hasJobFlag = false end
             end
+
+        elseif isStarted(RSGExport) then
+            local info = nil
+            Core.Functions.GetPlayerData(function(PlayerData) info = PlayerData end)
+            local jobinfo = info.job
+            if jobinfo.name == job then
+                hasJobFlag = true
+                duty = jobinfo.onduty
+                if grade and not (grade <= jobinfo.grade.level) then hasJobFlag = false end
+            end
+            local ganginfo = info.gang
+            if ganginfo.name == job then
+                hasJobFlag = true
+                if grade and not (grade <= ganginfo.grade.level) then hasJobFlag = false end
+            end
+
         else
             print("^4ERROR^7: ^2No Core detected for hasJob() ^7- ^2Check ^3starter^1.^2lua^7")
         end
@@ -457,6 +548,7 @@ function getPlayer(source)
         local src = tonumber(source)
         if isStarted(ESXExport) then
             local info = ESX.GetPlayerFromId(src)
+            if not info then return {} end
             Player = {
                 name = info.getName(),
                 cash = info.getMoney(),
@@ -481,9 +573,10 @@ function getPlayer(source)
             local chunk = assert(load(import, ('@@ox_core/%s'):format(file)))
             chunk()
             local player = Ox.GetPlayer(src)
+            if not player then return {} end
             Player = {
                 firstname = player.firstName,
-                lastname = player.lastName  ,
+                lastname = player.lastName,
                 name = ('%s %s'):format(player.firstName, player.lastName),
                 cash = exports[OXInv]:Search(src, 'count', "money"),
                 bank = 0,
@@ -495,10 +588,11 @@ function getPlayer(source)
                 --onDuty = info.job.onduty,
                 --account = info.charinfo.account,
                 citizenId = player.stateId,
-
             }
+
         elseif isStarted(QBXExport) then
             local info = exports[QBXExport]:GetPlayer(src)
+            if not info then return {} end
             Player = {
                 firstname = info.PlayerData.charinfo.firstname,
                 lastname = info.PlayerData.charinfo.lastname,
@@ -519,9 +613,11 @@ function getPlayer(source)
                 isDown = info.PlayerData.metadata["inlaststand"],
                 charInfo = info.charinfo,
             }
+
         elseif isStarted(QBExport) and not isStarted(QBXExport) then
-            if Core.Functions.GetPlayer then
+            if Core.Functions.GetPlayer(src) then
                 local info = Core.Functions.GetPlayer(src).PlayerData
+                if not info then return {} end
                 Player = {
                     firstname = info.charinfo.firstname,
                     lastname = info.charinfo.lastname,
@@ -543,9 +639,11 @@ function getPlayer(source)
                     charInfo = info.charinfo,
                 }
             end
+
         elseif isStarted(RSGExport) then
-            if Core.Functions.GetPlayer then
+            if Core.Functions.GetPlayer(src) then
                 local info = Core.Functions.GetPlayer(src).PlayerData
+                if not info then return {} end
                 Player = {
                     firstname = info.charinfo.firstname,
                     lastname = info.charinfo.lastname,
@@ -566,6 +664,7 @@ function getPlayer(source)
                     isDown = info.metadata["inlaststand"],
                     charInfo = info.charinfo,
                 }
+
             end
         else
             print("^4ERROR^7: ^2No Core detected for getPlayer() - Check starter.lua")
@@ -574,6 +673,8 @@ function getPlayer(source)
         -- Client-side: Get current player info.
         if isStarted(ESXExport) and ESX ~= nil then
             local info = ESX.GetPlayerData()
+            if not info.firstName then return {} end
+
             local cash, bank = 0, 0
             for k, v in pairs(info.accounts) do
                 if v.name == "money" then cash = v.money end
@@ -596,7 +697,9 @@ function getPlayer(source)
                 isDead = IsEntityDead(PlayerPedId()),
                 isDown = IsPedDeadOrDying(PlayerPedId(), true)
             }
+
         elseif isStarted(OXCoreExport) then
+            if not OxPlayer.userId then return {} end
             Player = {
                 firstname = OxPlayer.get("firstName"),
                 lastname = OxPlayer.get("lastName"),
@@ -614,8 +717,10 @@ function getPlayer(source)
                 isDead = IsEntityDead(PlayerPedId()),
                 isDown = IsPedDeadOrDying(PlayerPedId(), true)
             }
+
         elseif isStarted(QBXExport) then
             local info = exports[QBXExport]:GetPlayerData()
+            if not info.charinfo then return {} end
             Player = {
                 firstname = info.charinfo.firstname,
                 lastname = info.charinfo.lastname,
@@ -636,9 +741,12 @@ function getPlayer(source)
                 isDown = info.metadata["inlaststand"],
                 charInfo = info.charinfo,
             }
+
         elseif isStarted(QBExport) and not isStarted(QBXExport) then
             local info = nil
             Core.Functions.GetPlayerData(function(PlayerData) info = PlayerData end)
+            if not info.charinfo then return {} end
+
             Player = {
                 firstname = info.charinfo.firstname,
                 lastname = info.charinfo.lastname,
@@ -659,9 +767,12 @@ function getPlayer(source)
                 isDown = info.metadata["inlaststand"],
                 charInfo = info.charinfo,
             }
+
         elseif isStarted(RSGExport) then
             local info = nil
             Core.Functions.GetPlayerData(function(PlayerData) info = PlayerData end)
+            if not info.charinfo then return {} end
+
             Player = {
                 firstname = info.charinfo.firstname,
                 lastname = info.charinfo.lastname,
@@ -682,6 +793,7 @@ function getPlayer(source)
                 isDown = info.metadata["inlaststand"],
                 charInfo = info.charinfo,
             }
+
         else
             print("^4ERROR^7: ^2No Core detected for hasJob ^7- ^2Check ^3starter^1.^2lua^7")
         end

shared/scaleforms/bigMessageInstance.lua

@@ -149,8 +149,8 @@ function BigMessage:ShowColoredShard(msg, desc, textColor, bgColor, duration, ma
     BeginScaleformMovieMethod(self.scaleform, "SHOW_SHARD_CENTERED_MP_MESSAGE")
     ScaleformMovieMethodAddParamPlayerNameString(msg)
     ScaleformMovieMethodAddParamPlayerNameString(desc)
-    ScaleformMovieMethodAddParamInt(bgColor)
     ScaleformMovieMethodAddParamInt(textColor)
+    ScaleformMovieMethodAddParamInt(bgColor)
     EndScaleformMovieMethod()
 
     self.duration = duration

shared/shops.lua

@@ -30,15 +30,18 @@ function sellMenu(data)
         for k, v in pairs(data.sellTable.Items) do itemList[k] = 1 end
         local _, hasTable = hasItem(itemList)
         for k, v in pairsByKeys(data.sellTable.Items) do
-            Menu[#Menu + 1] = {
-                isMenuHeader = not hasTable[k].hasItem,
-                icon = invImg(k),
-                header = Items[k].label..(hasTable[k].hasItem and "💰 (x"..hasTable[k].count..")" or ""),
-                txt = Loc[Config.Lan].info["sell_all"]..v.." "..Loc[Config.Lan].info["sell_each"],
-                onSelect = function()
-                    sellAnim({ item = k, price = v, ped = data.ped, onBack = function() sellMenu(data) end })
-                end,
-            }
+            if Items[k] then
+                Menu[#Menu + 1] = {
+                    isMenuHeader = not hasTable[k].hasItem,
+                    icon = invImg(k),
+                    header = Items[k].label..(hasTable[k].hasItem and "💰 (x"..hasTable[k].count..")" or ""),
+                    txt = (Loc and Loc[Config.Lan]) and Loc[Config.Lan].info["sell_all"]..v.." "..Loc[Config.Lan].info["sell_each"]
+                    or "Sell ALL at $"..v.." each",
+                    onSelect = function()
+                        sellAnim({ item = k, price = v, ped = data.ped, onBack = function() sellMenu(data) end })
+                    end,
+                }
+            end
         end
     else
         for k, v in pairsByKeys(data.sellTable) do
@@ -48,7 +51,9 @@ function sellMenu(data)
                     header = k,
                     txt = "Amount of items: "..countTable(v.Items),
                     onSelect = function()
-                        v.onBack = function() sellMenu(origData) end
+                        v.onBack = function()
+                            sellMenu(origData)
+                        end
                         v.sellTable = data.sellTable[k]
                         sellMenu(v)
                     end,
@@ -57,8 +62,8 @@ function sellMenu(data)
         end
     end
     openMenu(Menu, {
-        header = data.sellTable.Header or "Amount of items: "..countTable(data.sellTable.Items),
-        headertxt = data.sellTable.Header and "Amount of items: "..countTable(data.sellTable.Items) or "",
+        header = data.sellTable.Header or "Amount of items: "..countTable(data.sellTable.Items or data.sellTable),
+        headertxt = data.sellTable.Header and "Amount of items: "..countTable(data.sellTable.Items or data.sellTable),
         canClose = true,
         onBack = data.onBack,
     })
@@ -105,12 +110,14 @@ function sellAnim(data)
     TriggerServerEvent(getScript().."Sellitems", data)
     lookEnt(data.ped)
     local dict = "mp_common"
-    playAnim(dict, "givetake2_a", 0.3, 2)
-    playAnim(dict, "givetake2_b", 0.3, 2, data.ped)
+    playAnim(dict, "givetake2_a", 0.3, 48)
+    playAnim(dict, "givetake2_b", 0.3, 48, data.ped)
     Wait(2000)
     StopAnimTask(PlayerPedId(), dict, "givetake2_a", 0.5)
     StopAnimTask(data.ped, dict, "givetake2_b", 0.5)
-    if data.onBack then data.onBack() end
+    if data.onBack then
+        data.onBack()
+    end
 end
 
 --- Server event handler for processing item sales.
@@ -148,6 +155,7 @@ end)
 --- })
 --- ```
 function openShop(data)
+    jsonPrint(data)
     if (data.job or data.gang) and not jobCheck(data.job or data.gang) then return end
 
     if Config.General.JimShops then
@@ -156,25 +164,49 @@ function openShop(data)
     elseif isStarted(OXInv) then
         exports[OXInv]:openInventory('shop', { type = data.shop })
 
+    elseif isStarted(QSInv) then
+        TriggerServerEvent("inventory:server:OpenInventory", "shop", data.items.label, data.items)
+
+    elseif isStarted(TgiannInv) then
+        TriggerServerEvent(getScript()..':server:openServerShop', data.shop)
+
+    elseif isStarted(CodeMInv) then
+        --print(data.shop)
+        TriggerEvent("codem-inventory:openshop", data.shop)
+
     elseif isStarted(QBInv) then
         if QBInvNew then
-            TriggerServerEvent(getScript()..':server:OpenShopNewQB', data.shop)
+            TriggerServerEvent(getScript()..':server:openServerShop', data.shop)
         else
             TriggerServerEvent("inventory:server:OpenInventory", "shop", data.items.label, data.items)
         end
+
+    elseif isStarted(PSInv) then
+        if QBInvNew then
+            TriggerServerEvent(getScript()..':server:openServerShop', data.shop)
+        else
+            TriggerServerEvent("inventory:server:OpenInventory", "shop", data.items.label, data.items)
+        end
+
     elseif isStarted(RSGInv) then
-        TriggerServerEvent(getScript()..':server:OpenShopNewRSG', data.shop)
+        TriggerServerEvent(getScript()..':server:openServerShop', data.shop)
     end
     lookEnt(data.coords)
 end
 
---- Server event handler for opening a shop using the new QB inventory system.
-RegisterNetEvent(getScript()..':server:OpenShopNewQB', function(data)
-    exports[QBInv]:OpenShop(source, data)
-end)
-
-RegisterNetEvent(getScript()..':server:OpenShopNewRSG', function(data)
-    exports[RSGInv]:OpenShop(source, data)
+RegisterNetEvent(getScript()..':server:openServerShop', function(data)
+    if isStarted(QBInv) then
+        exports[QBInv]:OpenShop(source, data)
+    end
+    if isStarted(PSInv) then
+        exports[PSInv]:OpenShop(source, data)
+    end
+    if isStarted(TgiannInv) then
+        exports[TgiannInv]:OpenShop(source, data)
+    end
+    if isStarted(RSGInv) then
+        exports[RSGInv]:OpenShop(source, data)
+    end
 end)
 
 --- Registers a shop with the active inventory system.
@@ -196,6 +228,11 @@ function registerShop(name, label, items, society)
             inventory = items,
             society = society,
         })
+
+    elseif isStarted(TgiannInv) then
+        debugPrint("^6Bridge^7: ^2Registering ^3Tgiann ^2Store^7:", name, label)
+        exports[TgiannInv]:RegisterShop(name, items)
+
     elseif isStarted(QBInv) and QBInvNew then
         debugPrint("^6Bridge^7: ^2Registering ^3QB ^2Store^7:", name, label)
         exports[QBInv]:CreateShop({
@@ -206,6 +243,16 @@ function registerShop(name, label, items, society)
             society = society,
         })
 
+    elseif isStarted(PSInv) and QBInvNew then
+        debugPrint("^6Bridge^7: ^2Registering ^3PS ^2Store^7:", name, label)
+        exports[PSInv]:CreateShop({
+            name = name,
+            label = label,
+            slots = #items,
+            items = items,
+            society = society,
+        })
+
     elseif isStarted(RSGInv) then
         debugPrint("^6Bridge^7: ^2Registering ^3RSG ^2Store^7:", name, label)
         exports[RSGInv]:CreateShop({

shared/skillcheck.lua

@@ -30,127 +30,10 @@ function skillCheck(data)
             result = false
         end
     elseif Config.System.skillCheck == "gta" then
-        loadTextureDict("timerbars")
-        local successes = 0
-        local barsRequired = 3
+        exports.jim_bridge:skillCheck()
 
-        for bar = 1, barsRequired do
-            debugPrint("^6Bridge^7: ^2Starting Bar ^3"..bar.."^7/^3"..barsRequired.."^7")
-            activeSkillCheck = true
-            local width, height = 0.2, 0.01
-            local x, y = 0.5, 0.8
-
-            -- Random highlighted zone
-            local highlightSize = math.random(10, 20) / 100
-            local highlightStart = math.random(10, 50) / 100
-            local highlightEnd = highlightStart + highlightSize
-            local highlightAlpha = 0
-            local cursorPos = 0.0
-            local cursorSpeed = 0.025
-            local movingRight = true
-
-            while activeSkillCheck do
-                Wait(0)
-                makeInstructionalButtons({
-                    { keys = { 177 }, text = "Exit" },
-                    { keys = { 38 }, text = "Confirm" },
-                })
-
-                createScaleBars(x, y, width, height)
-
-                local pulse = (math.sin(GetGameTimer() / 250) + 1) / 2 -- Creates a pulsing effect
-                highlightAlpha = math.floor(150 + (pulse * 105)) -- Pulsing between 150 and 255 alpha
-
-                -- Draw highlighted zone (success area) with pulsing effect
-                DrawRect(x - width / 2 + (highlightStart + highlightSize / 2) * width, y, highlightSize * width, height+0.001, 93, 182, 229, highlightAlpha )
-                -- Draw moving cursor
-                DrawRect(x - width / 2 + cursorPos * width, y, 0.002, height + 0.01, 255, 255, 255, 255)
-
-                -- Move cursor
-                if movingRight then
-                    cursorPos += cursorSpeed
-                    if cursorPos >= 1.0 then movingRight = false end
-                else
-                    cursorPos -= cursorSpeed
-                    if cursorPos <= 0.0 then movingRight = true end
-                end
-
-                if IsControlJustPressed(0, 177) then        -- Backspace to cancel
-                    local displayTime = GetGameTimer() + 2000
-                    PlaySoundFrontend(-1, 'Highlight_Cancel', 'DLC_HEIST_PLANNING_BOARD_SOUNDS', 1)
-                    while GetGameTimer() < displayTime do
-                        Wait(0)
-
-                        createScaleBars(x, y, width, height)
-
-                        DrawRect(x - width / 2 + (highlightStart + highlightSize / 2) * width, y, highlightSize * width, height+0.001, 228, 52, 52, 255)
-                        DrawRect(x - width / 2 + cursorPos * width, y, 0.002, height + 0.01, 255, 255, 255, 255)
-
-                        drawSuccessText(x, y, "Failed", 228, 52, 52)
-                    end
-                    return false
-                end
-
-                -- Check for keypress (E)
-                if IsControlJustPressed(0, 38) then
-                    activeSkillCheck = false
-                    result = cursorPos >= highlightStart and cursorPos <= highlightEnd
-                    if result then
-                        PlaySoundFrontend(-1, "YES", "HUD_FRONTEND_DEFAULT_SOUNDSET", true)
-                    else
-                        PlaySoundFrontend(-1, 'Highlight_Cancel', 'DLC_HEIST_PLANNING_BOARD_SOUNDS', 1)
-                    end
-                    local displayTime = GetGameTimer() + 2000
-                    while GetGameTimer() < displayTime do
-                        Wait(0)
-
-                        createScaleBars(x, y, width, height)
-
-                        -- Draw highlighted zone
-                        DrawRect(x - width / 2 + (highlightStart + highlightSize / 2) * width, y, highlightSize * width, height+0.001, result and 93 or 228, result and 182 or 52, result and 229 or 52, 180)
-
-                        -- Draw stationary cursor at result position
-                        DrawRect(x - width / 2 + cursorPos * width, y, 0.002, height + 0.01, 255, 255, 255, 255)
-                        -- Display result text
-                        drawSuccessText(x, y, result and "Success" or "Failed", result and 114 or 228, result and 204 or 52, result and 144 or 52)
-                    end
-                    if result then
-                        successes += 1
-                    else
-                        return false
-                    end
-                end
-            end
-        end
-        activeSkillCheck = false
-        debugPrint("^6Bridge^7: ^2Skill Check Result^7: ^3" .. successes .. "^7/^3" .. barsRequired.."^7")
-        return successes == barsRequired
     else
         result = true
     end
     return result
-end
-
-function drawSuccessText(x, y, text, r, g, b)
-    SetTextFont(8)
-    SetTextScale(0.45, 0.45)
-    SetTextColour(r, g, b, 255)
-    SetTextDropshadow(0, 0, 0, 0, 255)
-    SetTextEdge(2, 0, 0, 0, 150)
-    SetTextDropShadow()
-    SetTextOutline()
-    SetTextCentre(true)
-    SetTextEntry("STRING")
-    SetTextCentre(true)
-    SetTextEntry("STRING")
-    AddTextComponentString(text)
-    DrawText(x, y + 0.03)
-end
-
-function createScaleBars(x, y, width, height)
-    -- Draw background box
-    DrawSprite("timerbars", "all_black_bg", x - (width / 4) - 0.006, y, (width / 2) + 0.08, height + 0.04, 0.0, 255, 255, 255, 255)
-    DrawSprite("timerbars", "all_black_bg", x + (width / 4) + 0.006, y, (width / 2) + 0.08, height + 0.04, 180.0, 255, 255, 255, 255)
-    -- Draw full bar (dark background)
-    DrawRect(x, y, width, height, 100, 100, 100, 255)
 end

shared/societybank.lua

@@ -8,6 +8,7 @@
       • Renewed-Banking
       • fd_banking
       • okokBanking
+      • Tgiann-bank
 ]]
 
 --- Retrieves the current balance of a society's bank account.
@@ -54,6 +55,14 @@ function getSocietyAccount(society)
     elseif isStarted("okokBanking") then
         bankScript = "okokBanking"
         amount = exports['okokBanking']:GetAccount(society)
+
+    elseif isStarted("tgiann-bank") then
+        bankScript = "tgiann-bank"
+        if Jobs[society] then
+            amount = exports["tgiann-bank"]:GetJobAccountBalance(society)
+        else
+            amount = exports["tgiann-bank"]:GetGangAccountBalance(society)
+        end
     end
 
     if bankScript == "" then
@@ -104,6 +113,13 @@ function chargeSociety(society, amount)
         bankScript = "okokBanking"
         exports['okokBanking']:RemoveMoney(society, amount)
 
+    elseif isStarted("tgiann-bank") then
+        bankScript = "tgiann-bank"
+        if Jobs[society] then
+            exports["tgiann-bank"]:RemoveJobMoney(society, amount)
+        else
+            exports["tgiann-bank"]:RemoveGangMoney(society, amount)
+        end
     end
 
     if bankScript == "" then
@@ -122,7 +138,7 @@ end
 --- fundSociety("police", 500)
 --- ```
 function fundSociety(society, amount)
-    local bankScript, newAmount = "", 0
+    local bankScript, newAmount, success = "", 0, false
 
 
     if isStarted("qb-banking") then
@@ -159,6 +175,13 @@ function fundSociety(society, amount)
         bankScript = "okokBanking"
         exports['okokBanking']:AddMoney(society, amount)
 
+    elseif isStarted("tgiann-bank") then
+        bankScript = "tgiann-bank"
+        if Jobs[society] then
+            exports["tgiann-bank"]:AddJobMoney(society, amount)
+        else
+            exports["tgiann-bank"]:AddGangMoney(society, amount)
+        end
     end
 
     if bankScript == "" then

shared/stashcontrol.lua

@@ -47,19 +47,19 @@ function GetStashTimeout(stashName, stop)
         stashCache[stashName] = { items = {}, timeout = 0 }
         stash = stashCache[stashName]
     else
-        debugPrint("^6Bridge^7: ^2Local Stash ^7'^3"..stashName.."^7'^2 cache found^7")
+        debugPrint("^6Bridge^7: ^2Local Stash for ^7'^3"..stashName.."^7'^2 cache found^7")
     end
 
     -- If there are already items in cache, skip recheck.
     if countTable(stashCache[stashName].items) > 0 then
-        debugPrint("^6Bridge^7: '^3"..stashName.." ^2Items found in cache, skipping recheck")
+        debugPrint("^6Bridge^7: '^3"..stashName.."^7' ^2Items found in local cache, skipping server recheck")
         return true
     end
 
     -- If timeout has expired, update the stash items from the server.
     if stashCache[stashName].timeout <= 0 then
         stashCache[stashName].items = triggerCallback(getScript()..':server:GetStashItems', stashName)
-        stashCache[stashName].timeout = 15000  -- Timeout in milliseconds.
+        stashCache[stashName].timeout = 10000  -- Timeout in milliseconds.
         CreateThread(function()
             while stashCache[stashName] and stashCache[stashName].timeout > 0 do
                 stashCache[stashName].timeout -= 1000
@@ -90,20 +90,12 @@ function checkStashItem(stashes, itemTable)
     end
 
     if type(stashes) == "table" then
-        local successes = 0
-        local itemCount = countTable(itemTable)
+        debugPrint("^6Bridge^7: ^2Checking multiple stashes for ingredients^7")
         -- Iterate over each provided stash name.
         for _, name in pairs(stashes) do
-            Wait(10)  -- Delay to avoid multiple callbacks issues.
             GetStashTimeout(name)
-            for item, amount in pairs(itemTable) do
-                debugPrint("^6Bridge^7: ^2Checking "..(name and " '^3"..name.."^7'" or "").." ingredients - ^6"..item.."^7")
-                if stashhasItem(stashCache[name].items, item, amount) then
-                    successes += 1
-                    if successes == itemCount then
-                        return true, name
-                    end
-                end
+            if stashhasItem(stashCache[name].items, itemTable, nil) then
+                return true, name
             end
         end
     else
@@ -151,9 +143,17 @@ function openStash(data)
     elseif isStarted(OrigenInv) then
         exports[OrigenInv]:openInventory('stash', data.stash, { label = data.label })
 
-    elseif isStarted(QBInv) then
+    elseif isStarted(TgiannInv) then
+        TriggerServerEvent(getScript()..':server:openServerStash', {
+            stashName = data.stash,
+            label = data.label,
+            maxweight = data.maxWeight or 600000,
+            slots = data.slots or 40
+        })
+
+    elseif isStarted(JPRInv) then
         if QBInvNew then
-            TriggerServerEvent(getScript()..':server:OpenStashQB', {
+            TriggerServerEvent(getScript()..':server:openServerStash', {
                 stashName = data.stash,
                 label = data.label,
                 maxweight = data.maxWeight or 600000,
@@ -161,11 +161,46 @@ function openStash(data)
             })
         else
             TriggerEvent("inventory:client:SetCurrentStash", data.stash)
-            TriggerServerEvent("inventory:server:OpenInventory", "stash", data.stash, data.stashOptions)
+            TriggerServerEvent("inventory:server:OpenInventory", "stash", data.stash, {
+                slots = data.slots or 50,
+                maxWeight = data.maxWeight or 600000
+            })
+        end
+
+    elseif isStarted(QBInv) then
+        if QBInvNew then
+            TriggerServerEvent(getScript()..':server:openServerStash', {
+                stashName = data.stash,
+                label = data.label,
+                maxweight = data.maxWeight or 600000,
+                slots = data.slots or 40
+            })
+        else
+            TriggerEvent("inventory:client:SetCurrentStash", data.stash)
+            TriggerServerEvent("inventory:server:OpenInventory", "stash", data.stash, {
+                slots = data.slots or 50,
+                maxWeight = data.maxWeight or 600000
+            })
+        end
+
+    elseif isStarted(PSInv) then
+        if QBInvNew then
+            TriggerServerEvent(getScript()..':server:openServerStash', {
+                stashName = data.stash,
+                label = data.label,
+                maxweight = data.maxWeight or 600000,
+                slots = data.slots or 40
+            })
+        else
+            TriggerEvent("inventory:client:SetCurrentStash", data.stash)
+            TriggerServerEvent("inventory:server:OpenInventory", "stash", data.stash, {
+                slots = data.slots or 50,
+                maxWeight = data.maxWeight or 600000
+            })
         end
 
     elseif isStarted(RSGInv) then
-        TriggerServerEvent(getScript()..':server:OpenStashRSG', {
+        TriggerServerEvent(getScript()..':server:openServerStash', {
             stashName = data.stash,
             label = data.label,
             maxweight = data.maxWeight or 600000,
@@ -175,20 +210,102 @@ function openStash(data)
     else
         --Fallback to these commands
         TriggerEvent("inventory:client:SetCurrentStash", data.stash)
-        TriggerServerEvent("inventory:server:OpenInventory", "stash", data.stash, data.stashOptions)
+        TriggerServerEvent("inventory:server:OpenInventory", "stash", data.stash, {
+            slots = data.slots or 50,
+            maxWeight = data.maxWeight or 600000
+        })
     end
 
     lookEnt(data.coords)
 end
 
--- Register an event for opening QB stashes.
-RegisterNetEvent(getScript()..':server:OpenStashQB', function(data)
-    exports[QBInv]:OpenInventory(source, data.stashName, data)
+
+-- Wrapper function for opening stash from the server.
+-- Messy but not much else I can do about it.
+RegisterNetEvent(getScript()..":server:openServerStash", function(data)
+    local src = source
+    if isStarted(TgiannInv) then
+        exports[TgiannInv]:OpenInventory(source, 'stash', data.stashName, data)
+    end
+    if isStarted(JPRInv) then
+        exports[JPRInv]:OpenInventory(source, data.stashName, data)
+    end
+    if isStarted(QBInv) then
+        exports[QBInv]:OpenInventory(source, data.stashName, data)
+    end
+    if isStarted(PSInv) then
+        exports[PSInv]:OpenInventory(source, data.stashName, data)
+    end
+    if isStarted(RSGInv) then
+        exports[RSGInv]:OpenInventory(source, data.stashName, data)
+    end
 end)
 
-RegisterNetEvent(getScript()..':server:OpenStashRSG', function(data)
-    exports[RSGInv]:OpenInventory(source, data.stashName, data)
-end)
+function clearStash(stashId)
+    if isStarted(JPRInv) then
+        debugPrint("^5Bridge^7: ^2Cleared ^3"..JPRInv.."^2 Stash^7", stashId)
+        if QBInvNew then
+            exports[JPRInv]:ClearStash(stashId)
+        else
+            MySQL.Async.insert('INSERT INTO stashitems (stash, items) VALUES (:stash, :items) ON DUPLICATE KEY UPDATE items = :items', {
+                ['stash'] = stashId,
+                ['items'] = json.encode({})
+            })
+        end
+
+    elseif isStarted(QBInv) then
+        debugPrint("^5Bridge^7: ^2Cleared ^3"..QBInv.."^2 Stash^7", stashId)
+        if QBInvNew then
+            exports[QBInv]:ClearStash(stashId)
+        else
+            MySQL.Async.insert('INSERT INTO stashitems (stash, items) VALUES (:stash, :items) ON DUPLICATE KEY UPDATE items = :items', {
+                ['stash'] = stashId,
+                ['items'] = json.encode({})
+            })
+        end
+
+    elseif isStarted(OXInv) then
+        debugPrint("^5Bridge^7: ^2Cleared ^3"..OXInv.."^2 Stash^7", stashId)
+        exports[OXInv]:ClearInventory(stashId)
+
+    elseif isStarted(PSInv) then
+        debugPrint("^5Bridge^7: ^2Cleared ^3"..PSInv.."^2 Stash^7", stashId)
+        if QBInvNew then
+            exports[PSInv]:ClearStash(stashId)
+        else
+            MySQL.Async.insert('INSERT INTO stashitems (stash, items) VALUES (:stash, :items) ON DUPLICATE KEY UPDATE items = :items', {
+                ['stash'] = stashId,
+                ['items'] = json.encode({})
+            })
+        end
+
+
+    elseif isStarted(QSInv) then
+        debugPrint("^5Bridge^7: ^2Cleared ^3"..QSInv.."^2 Stash^7", stashId)
+        exports[QSInv]:ClearOtherInventory('stash', stashId)
+
+    elseif isStarted(CoreInv) then
+        debugPrint("^5Bridge^7: ^2Cleared ^3"..CoreInv.."^2 Stash^7", stashId)
+        exports[CoreInv]:clearInventory("stash-"..stashId)
+
+    elseif isStarted(CodeMInv) then
+        debugPrint("^5Bridge^7: ^2Cleared ^3"..CodeMInv.."^2 Stash^7", stashId)
+        exports[CodeMInv]:ClearInventory(stashId)
+
+    elseif isStarted(OrigenInv) then
+        debugPrint("^5Bridge^7: ^2Cleared ^3"..OrigenInv.."^2 Stash^7", stashId)
+        exports[OrigenInv]:ClearInventory(stashId)
+
+    elseif isStarted(TgiannInv) then
+        debugPrint("^5Bridge^7: ^2Cleared ^3"..TgiannInv.."^2 Stash^7", stashId)
+        exports["tgiann-inventory"]:DeleteInventory("stash", stashId)
+
+    elseif isStarted(RSGInv) then
+        debugPrint("^5Bridge^7: ^2Cleared ^3"..RSGInv.."^2 Stash^7", stashId)
+        exports[RSGInv]:ClearStash(stashId)
+
+    end
+end
 
 
 -------------------------------------------------------------
@@ -216,7 +333,9 @@ function getStash(stashName)
     local stashItems, items = {}, {}
     if isStarted(OXInv) then
         stashResource = OXInv
-        stashItems = exports[OXInv]:Inventory(stashName).items
+        local stash = exports[OXInv]:Inventory(stashName)
+        -- Add fallback if ox can't find the stash and returns a boolean
+        stashItems = type(stash) == "table" and stash.items or {}
 
     elseif isStarted(QSInv) then
         stashResource = QSInv
@@ -234,15 +353,29 @@ function getStash(stashName)
         stashResource = OrigenInv
         stashItems = exports[OrigenInv]:getInventory(stashName)
 
+    elseif isStarted(TgiannInv) then
+        stashResource = TgiannInv
+        stashItems = exports[TgiannInv]:GetSecondaryInventoryItems("stash", stashName)
+
     elseif isStarted(PSInv) then
         stashResource = PSInv
         local result = MySQL.scalar.await('SELECT items FROM stashitems WHERE stash = ?', { stashName })
 		if result then stashItems = json.decode(result) end
 
+    elseif isStarted(JPRInv) then
+        stashResource = JPRInv
+        local result = MySQL.scalar.await('SELECT items FROM stashitems WHERE stash = ?', { stashName })
+		if result then stashItems = json.decode(result) end
+
     elseif isStarted(QBInv) then
         stashResource = QBInv
-        local result = MySQL.scalar.await("SELECT items FROM "..(QBInvNew and "inventories" or "stashitem").." WHERE identifier = ?", { stashName })
-        if result then stashItems = json.decode(result) end
+        if QBInvNew then
+            local result = exports[QBInv]:GetInventory(stashName) or {}
+            stashItems = result.items or {}
+        else
+            local result = MySQL.scalar.await("SELECT items FROM stashitems WHERE stash = ?", { stashName })
+            if result then stashItems = json.decode(result) end
+        end
 
     elseif isStarted(RSGInv) then
         stashResource = RSGInv
@@ -298,39 +431,27 @@ function stashRemoveItem(stashItems, stashName, items)
     if type(stashName) ~= "table" then
         stashName = { stashName }
     end
+
     if isStarted(OXInv) then
         for k, v in pairs(items) do
-            if type(stashName) == "table" then
-                for _, name in pairs(stashName) do
-                    local success = exports[OXInv]:RemoveItem(name, k, v)
-                    if success then
-                        debugPrint("^6Bridge^7: ^2Removing item from ^3Stash^2 with ^7"..OXInv, k, v)
-                        break
-                    end
+            for _, name in pairs(stashName) do
+                local success = exports[OXInv]:RemoveItem(name, k, v)
+                if success then
+                    debugPrint("^6Bridge^7: ^2Removing item from ^3Stash^2 with ^7"..OXInv, k, v)
+                    break
                 end
-            else
-                exports[OXInv]:RemoveItem(stashName, k, v)
             end
         end
 
     elseif isStarted(QSInv) then
         for k, v in pairs(items) do
-            for l in pairs(stashItems) do
-                if stashItems[l].name == k then
-                    if (stashItems[l].amount - v) <= 0 then
-                        debugPrint("^6Bridge^7: ^2None of this item left in stash ^3Stash^7", k, v)
-                        stashItems[l] = nil
-                    else
-                        debugPrint("^6Bridge^7: ^2Removing item from ^3Stash^2 with ^7"..QBInv, k, v)
-                        exports[QSInv]:RemoveItemIntoStash(stashName, k, v, l)
-                    end
-                end
-            end
+            exports[QSInv]:RemoveItemIntoStash(stashName[1], k, v)
+            debugPrint("^6Bridge^7: ^2Removing item from ^3Stash^2 with ^7"..QSInv, k, v)
         end
 
     elseif isStarted(CoreInv) then
         for k, v in pairs(items) do
-            exports[CoreInv]:removeItemExact(stashName, k, v)
+            exports[CoreInv]:removeItemExact(stashName[1], k, v)
             debugPrint("^6Bridge^7: ^2Removing item from ^3Stash^2 with ^7"..CoreInv, k, v)
         end
 
@@ -348,15 +469,26 @@ function stashRemoveItem(stashItems, stashName, items)
                 end
             end
         end
-        exports[CodeMInv]:UpdateStash(stashName, stashItems)
+        exports[CodeMInv]:UpdateStash(stashName[1], stashItems)
         debugPrint("^6Bridge^7: ^3saveStash^7: ^2Saving ^3CodeM^2 stash ^7'^6"..stashName.."^7'")
+
     elseif isStarted(OrigenInv) then
         for k, v in pairs(items) do
-            exports[OrigenInv]:RemoveFromStash(stashName, k, v)
+            exports[OrigenInv]:RemoveFromStash(stashName[1], k, v)
             debugPrint("^6Bridge^7: ^2Removing item from ^3Stash^2 with ^7"..OrigenInv, k, v)
         end
 
-    elseif isStarted(PSInv) then
+    elseif isStarted(TgiannInv) then
+        for k, v in pairs(items) do
+            local itemData = exports[TgiannInv]:GetItemByNameFromSecondaryInventory("stash", stashName[1], k)
+            exports[TgiannInv]:RemoveItemFromSecondaryInventory("stash", stashName[1], k, v, itemData.slot, nil)
+            debugPrint("^6Bridge^7: ^2Removing item from ^3Stash^2 with ^7"..TgiannInv, k, v)
+        end
+
+    elseif isStarted(JPRInv) then
+        if not stashItems or not next(stashItems) then
+            stashItems = getStash(stashName[1])
+        end
         for k, v in pairs(items) do
             for l in pairs(stashItems) do
                 if stashItems[l].name == k then
@@ -364,15 +496,15 @@ function stashRemoveItem(stashItems, stashName, items)
                         debugPrint("^6Bridge^7: ^2None of this item left in stash ^3Stash^7", k, v)
                         stashItems[l] = nil
                     else
-                        debugPrint("^6Bridge^7: ^2Removing item from ^3Stash^2 with ^7"..QBInv, k, v)
+                        debugPrint("^6Bridge^7: ^2Removing item from ^3Stash^2 with "..JPRInv, k, v)
                         stashItems[l].amount -= v
                     end
                 end
             end
         end
-        debugPrint("^6Bridge^7: ^3saveStash^7: ^2Saving ^3QB^2 stash ^7'^6"..stashName.."^7'")
+        debugPrint("^6Bridge^7: ^3saveStash^7: ^2Saving ^3JPR^2 stash '^6"..stashName[1].."^7'")
         MySQL.Async.insert('INSERT INTO stashitems (stash, items) VALUES (:stash, :items) ON DUPLICATE KEY UPDATE items = :items', {
-            ['stash'] = stashName,
+            ['stash'] = stashName[1],
             ['items'] = json.encode(stashItems)
         })
 
@@ -382,12 +514,10 @@ function stashRemoveItem(stashItems, stashName, items)
                 exports[QBInv]:RemoveItem(stashName[1], k, v, false, 'crafting')
                 debugPrint("^6Bridge^7: ^2Removing item from ^3Stash^2 with ^7"..QBInv, k, v)
             end
-            debugPrint("^6Bridge^7: ^3saveStash^7: ^2Saving ^3QB^2 stash ^7'^6"..stashName[1].."^7'")
-            MySQL.Async.insert('INSERT INTO inventories (identifier, items) VALUES (:stash, :items) ON DUPLICATE KEY UPDATE items = :items', {
-                ['stash'] = stashName[1],
-                ['items'] = json.encode(stashItems)
-            })
         else
+            if not stashItems or not next(stashItems) then
+                stashItems = getStash(stashName[1])
+            end
             for k, v in pairs(items) do
                 for l in pairs(stashItems) do
                     if stashItems[l].name == k then
@@ -401,13 +531,41 @@ function stashRemoveItem(stashItems, stashName, items)
                     end
                 end
             end
-            debugPrint("^6Bridge^7: ^3saveStash^7: ^2Saving ^3QB^2 stash '^6"..stashName.."^7'")
+            debugPrint("^6Bridge^7: ^3saveStash^7: ^2Saving ^3QB^2 stash '^6"..stashName[1].."^7'")
             MySQL.Async.insert('INSERT INTO stashitems (stash, items) VALUES (:stash, :items) ON DUPLICATE KEY UPDATE items = :items', {
-                ['stash'] = stashName,
+                ['stash'] = stashName[1],
                 ['items'] = json.encode(stashItems)
             })
         end
 
+    elseif isStarted(PSInv) then
+        if not stashItems or not next(stashItems) then
+            stashItems = getStash(stashName[1])
+        end
+        for k, v in pairs(items) do
+            for l in pairs(stashItems) do
+                if stashItems[l].name == k then
+                    if (stashItems[l].amount - v) <= 0 then
+                        debugPrint("^6Bridge^7: ^2None of this item left in stash ^3Stash^7", k, v)
+                        stashItems[l] = nil
+                    else
+                        debugPrint("^6Bridge^7: ^2Removing item from ^3Stash^2 with ^7"..PSInv, k, v)
+                        stashItems[l].amount -= v
+                    end
+                end
+            end
+        end
+        debugPrint("^6Bridge^7: ^3saveStash^7: ^2Saving ^3PS^2 stash ^7'^6"..stashName[1].."^7'")
+        MySQL.Async.insert('INSERT INTO stashitems (stash, items) VALUES (:stash, :items) ON DUPLICATE KEY UPDATE items = :items', {
+            ['stash'] = stashName[1],
+            ['items'] = json.encode(stashItems)
+        })
+
+    elseif isStarted(RSGInv) then
+        for k, v in pairs(items) do
+            exports[RSGInv]:RemoveItem(stashName[1], k, v, false, 'crafting')
+            debugPrint("^6Bridge^7: ^2Removing item from ^3Stash^2 with ^7"..RSGInv, k, v)
+        end
     else
         print("^4ERROR^7: ^2No Inventory detected ^7- ^2Check ^3starter^1.^2lua^7")
     end
@@ -432,7 +590,7 @@ RegisterNetEvent(getScript()..":server:stashRemoveItem", stashRemoveItem)
 --- local hasAll, details = stashhasItem(currentStashItems, { iron = 2, wood = 5 })
 --- ```
 function stashhasItem(stashItems, items, amount)
-    local invs = { OXInv, QSInv, CoreInv, CodeMInv, OrigenInv, QBInv, PSInv }
+    local invs = { OXInv, QSInv, CoreInv, CodeMInv, OrigenInv, TgiannInv, JPRInv, QBInv, PSInv, RSGInv }
     local foundInv = ""
     for _, inv in ipairs(invs) do
         if isStarted(inv) then
@@ -463,3 +621,90 @@ function stashhasItem(stashItems, items, amount)
 
     return true, hasTable
 end
+
+
+--- Registers a stash with the active inventory system.
+--- Supports either OXInv or QSInv.
+---
+--- @param name string Unique stash identifier.
+--- @param label string Display name for the stash.
+--- @param slots number|nil (Optional) Number of slots (default 50).
+--- @param weight number|nil (Optional) Maximum weight (default 4000000).
+--- @param owner string|nil (Optional) Owner identifier for personal stashes.
+--- @param coords table|nil (Optional) Coordinates for the stash location.
+--- @usage
+--- ```lua
+--- registerStash(
+---     "playerStash",
+---     "Player Stash",
+---     100,
+---     8000000,
+---     "player123",
+---     { x = 100.0, y = 200.0, z = 30.0 }
+--- )
+--- ```
+function registerStash(name, label, slots, weight, owner, coords)
+    if isStarted(OXInv) then
+        debugPrint("^6Bridge^7: ^2Registering ^3OX ^2Stash^7:", name, label, owner or nil)
+        exports[OXInv]:RegisterStash(name, label, slots or 50, weight or 4000000, owner or nil)
+
+    --elseif isStarted(QSInv) then
+    --    debugPrint("^6Bridge^7: ^2Registering ^3QS ^2Stash^7:", name, label)
+    --    exports[QSInv]:RegisterStash(name, label, slots or 50, weight or 4000000)
+
+    --elseif isStarted(CoreInv) then
+    --    debugPrint("^6Bridge^7: ^2Registering ^3CoreInv ^2Stash^7:", name, label)
+    --    exports[CoreInv]:openHolder(nil, name, 'stash', nil, nil, false, nil)
+
+    elseif isStarted(OrigenInv) then
+        debugPrint("^6Bridge^7: ^2Registering ^3OrigenInv ^2Stash^7:", name, label)
+        exports["origen_inventory"]:registerStash(name, label, slots or 50, weight or 4000000)
+
+    elseif isStarted(TgiannInv) then
+        debugPrint("^6Bridge^7: ^2Registering ^3TgiannInv ^2Stash^7:", name, label)
+        exports[TgiannInv]:RegisterStash(name, label, slots or 50, weight or 4000000)
+
+    end
+end
+
+if isServer() then
+    --- Registers an event to create an OX stash from the server.
+    --- When triggered, it calls registerStash with the provided parameters.
+    ---
+    --- @event server:makeOXStash
+    --- @param name string Unique stash identifier.
+    --- @param label string Display name for the stash.
+    --- @param slots number|nil (Optional) Number of slots.
+    --- @param weight number|nil (Optional) Maximum weight.
+    --- @param owner string|nil (Optional) Owner identifier.
+    --- @param coords table|nil (Optional) Stash coordinates.
+    --- @usage
+    --- ```lua
+    --- TriggerEvent(getScript()..":server:makeOXStash", name, label, slots, weight, owner, coords, token)
+    --- ```
+    RegisterNetEvent(getScript()..":server:makeOXStash", function(name, label, slots, weight, owner, coords, token)
+        local src = source or nil
+        if src then
+            if not checkToken(src, token, "stash", name) then
+                return
+            end
+        end
+
+        registerStash(name, label, slots, weight, owner, coords)
+    end)
+end
+
+RegisterNetEvent(getScript()..":openGrabBox", function(data)
+	if isStarted(OXInv) then
+		return
+	end
+	local id = ""
+	if data.metadata then
+		id = data.metadata.id
+	elseif data.info then
+		id = data.info.id
+	end
+	openStash({
+		stash = id,
+	})
+end)

shared/targets.lua

@@ -20,24 +20,7 @@
 -------------------------------------------------------------
 -- Utility Data & Tables
 -------------------------------------------------------------
----
-local KEY_TABLE = { 38, 29, 47, 23, 45, }
 
--- Mapping of key codes to human-readable key names.
-local Keys = {
-    [322] = "ESC", [288] = "F1", [289] = "F2", [170] = "F3", [166] = "F5",
-    [167] = "F6", [168] = "F7", [169] = "F8", [56] = "F9", [57] = "F10",
-    [243] = "~", [157] = "1", [158] = "2", [160] = "3", [164] = "4", [165] = "5",
-    [159] = "6", [161] = "7", [162] = "8", [163] = "9", [84] = "-", [83] = "=",
-    [177] = "BACKSPACE", [37] = "TAB",
-    [44] = "Q", [32] = "W", [38] = "E", [45] = "R", [245] = "T", [246] = "Y",
-    [303] = "U", [199] = "P",
-    [39] = "[",  [40] = "]", [18] = "ENTER", [137] = "CAPS",
-    [34] = "A", [8] = "S", [9] = "D", [23] = "F", [47] = "G",
-    [74] = "H", [311] = "K", [182] = "L", [21] = "LEFTSHIFT",
-    [20] = "Z", [73] = "X", [26] = "C", [0] = "V",  [29] = "B", [249] = "N",
-    [244] = "M", [82] = ",", [81] = "."
-}
 
 -- Tables for storing created targets for the fallback system and zone management.
 local TextTargets    = {}   -- For fallback DrawText3D targets.
@@ -82,38 +65,9 @@ function createEntityTarget(entity, opts, dist)
 
     -- Fallback: Use DrawText3D if targeting systems are disabled or unavailable.
     if Config.System.DontUseTarget or (not isStarted(OXTargetExport) and not isStarted(QBTargetExport)) then
-        local entityCoords = GetEntityCoords(entity)
-        debugPrint("^6Bridge^7: ^2Creating new ^3Entity^2 target with DrawText for entity ^7"..entity)
-        local existingTarget = nil
-        for _, target in pairs(TextTargets) do
-            if #(target.coords - entityCoords) < 0.01 then
-                existingTarget = target
-                break
-            end
-        end
+        debugPrint("^6Bridge^7: ^2Creating new ^3Entity ^2target with ^6"..OXTargetExport.." ^2for entity ^7"..entity)
+        exports.jim_bridge:createEntityTarget(entity, opts, dist)
 
-        if existingTarget then
-            for i = 1, #opts do
-                local key = KEY_TABLE[#existingTarget.options + i]
-                opts[i].key = key
-                existingTarget.buttontext[#existingTarget.buttontext + 1] = " ~b~[~w~" .. Keys[key] .. "~b~] ~w~" .. opts[i].label
-                existingTarget.options[#existingTarget.options + 1] = opts[i]
-            end
-            updateCachedText(existingTarget)
-        else
-            local tempText = {}
-            for i = 1, #opts do
-                opts[i].key = KEY_TABLE[i]
-                tempText[#tempText + 1] = " ~b~[~w~" .. Keys[opts[i].key] .. "~b~] ~w~" .. opts[i].label
-            end
-            TextTargets[entity] = {
-                coords = vec3(entityCoords.x, entityCoords.y, entityCoords.z),
-                buttontext = tempText,
-                options = opts,
-                dist = dist,
-                text = table.concat(tempText, "\n")
-            }
-        end
     elseif isStarted(OXTargetExport) then
         debugPrint("^6Bridge^7: ^2Creating new ^3Entity ^2target with ^6"..OXTargetExport.." ^2for entity ^7"..entity)
         local options = {}
@@ -121,7 +75,7 @@ function createEntityTarget(entity, opts, dist)
             options[i] = {
                 icon = opts[i].icon,
                 label = opts[i].label,
-                item = opts[i].item or nil,
+                items = opts[i].item or nil,
                 groups = opts[i].job or opts[i].gang,
                 onSelect = opts[i].action,
                 distance = dist,
@@ -129,10 +83,12 @@ function createEntityTarget(entity, opts, dist)
             }
         end
         exports[OXTargetExport]:addLocalEntity(entity, options)
+
     elseif isStarted(QBTargetExport) then
         debugPrint("^6Bridge^7: ^2Creating new ^3Entity ^2target with ^6"..QBTargetExport.." ^2for entity ^7"..entity)
         local options = { options = opts, distance = dist }
         exports[QBTargetExport]:AddTargetEntity(entity, options)
+
     end
 end
 
@@ -192,37 +148,8 @@ end
 function createBoxTarget(data, opts, dist)
     if Config.System.DontUseTarget or (not isStarted(OXTargetExport) and not isStarted(QBTargetExport)) then
         debugPrint("^6Bridge^7: ^2Creating new ^3Box^2 target with ^6DrawText ^2 for zone ^7"..data[1])
-        local existingTarget = nil
-        for _, target in pairs(TextTargets) do
-            if #(target.coords - data[2]) < 0.01 then
-                existingTarget = target
-                break
-            end
-        end
+        return exports.jim_bridge:createZoneTarget(data, opts, dist)
 
-        if existingTarget then
-            for i = 1, #opts do
-                local key = KEY_TABLE[#existingTarget.options + i]
-                opts[i].key = key
-                existingTarget.buttontext[#existingTarget.buttontext + 1] = " ~b~[~w~" .. Keys[key] .. "~b~] ~w~" .. opts[i].label
-                existingTarget.options[#existingTarget.options + 1] = opts[i]
-            end
-            updateCachedText(existingTarget)
-        else
-            local tempText = {}
-            for i = 1, #opts do
-                opts[i].key = KEY_TABLE[i]
-                tempText[#tempText + 1] = " ~b~[~w~" .. Keys[opts[i].key] .. "~b~] ~w~" .. opts[i].label
-            end
-            TextTargets[data[1]] = {
-                coords = data[2],
-                buttontext = tempText,
-                options = opts,
-                dist = dist,
-                text = table.concat(tempText, "\n")
-            }
-        end
-        return data[1]
     elseif isStarted(OXTargetExport) then
         debugPrint("^6Bridge^7: ^2Creating new ^3Box^2 target with ^6"..OXTargetExport.." ^2for zone ^7"..data[1])
         local options = {}
@@ -230,7 +157,7 @@ function createBoxTarget(data, opts, dist)
             options[i] = {
                 icon = opts[i].icon,
                 label = opts[i].label,
-                item = opts[i].item or nil,
+                items = opts[i].item or nil,
                 groups = opts[i].job or opts[i].gang,
                 onSelect = opts[i].onSelect or opts[i].action,
                 distance = dist,
@@ -250,12 +177,14 @@ function createBoxTarget(data, opts, dist)
         })
         boxTargets[#boxTargets + 1] = target
         return target
+
     elseif isStarted(QBTargetExport) then
         debugPrint("^6Bridge^7: ^2Creating new ^3Box^2 target with ^6"..QBTargetExport.." ^2for zone ^7"..data[1])
         local options = { options = opts, distance = dist }
         local target = exports[QBTargetExport]:AddBoxZone(data[1], data[2], data[3], data[4], data[5], options)
         boxTargets[#boxTargets + 1] = target
         return data[1]
+
     end
 end
 
@@ -298,37 +227,8 @@ end
 function createCircleTarget(data, opts, dist)
     if Config.System.DontUseTarget then
         debugPrint("^6Bridge^7: ^2Creating new ^3Circle ^2target with ^6DrawText ^2for zone ^7"..data[1])
-    local existingTarget = nil
-    for _, target in pairs(TextTargets) do
-        if #(target.coords - data[2]) < 0.01 then
-            existingTarget = target
-            break
-        end
-    end
+        return exports.jim_bridge:createZoneTarget(data, opts, dist)
 
-    if existingTarget then
-        for i = 1, #opts do
-            local key = KEY_TABLE[#existingTarget.options + i]
-            opts[i].key = key
-            existingTarget.buttontext[#existingTarget.buttontext + 1] = " ~b~[~w~" .. Keys[key] .. "~b~] ~w~" .. opts[i].label
-            existingTarget.options[#existingTarget.options + 1] = opts[i]
-        end
-        updateCachedText(existingTarget)
-    else
-        local tempText = {}
-        for i = 1, #opts do
-            opts[i].key = KEY_TABLE[i]
-            tempText[#tempText + 1] = " ~b~[~w~" .. Keys[opts[i].key] .. "~b~] ~w~" .. opts[i].label
-        end
-        TextTargets[data[1]] = {
-            coords = data[2],
-            buttontext = tempText,
-            options = opts,
-            dist = dist,
-            text = table.concat(tempText, "\n")
-        }
-    end
-    return data[1]
     elseif isStarted(OXTargetExport) then
         debugPrint("^6Bridge^7: ^2Creating new ^3Circle ^2target with ^6"..OXTargetExport.." ^2for zone ^7"..data[1])
         local options = {}
@@ -336,7 +236,7 @@ function createCircleTarget(data, opts, dist)
             options[i] = {
                 icon = opts[i].icon,
                 label = opts[i].label,
-                item = opts[i].item or nil,
+                items = opts[i].item or nil,
                 groups = opts[i].job or opts[i].gang,
                 onSelect = opts[i].onSelect or opts[i].action,
                 distance = dist,
@@ -387,30 +287,8 @@ end
 ---```
 function createModelTarget(models, opts, dist)
     if Config.System.DontUseTarget or (not isStarted(OXTargetExport) and not isStarted(QBTargetExport)) then
-        if type(models) ~= "table" then
-            models = { models }
-        end
+        return exports.jim_bridge:createModelTarget(models, opts, dist)
 
-        local tempText = {}
-        for i = 1, #opts do
-            opts[i].key = KEY_TABLE[i]
-            tempText[#tempText + 1] = " ~b~[~w~" .. Keys[opts[i].key] .. "~b~] ~w~" .. opts[i].label
-        end
-
-        local keyStr = ""
-        for i, m in ipairs(models) do
-            keyStr = keyStr .. tostring(m) .. (i < #models and "_" or "")
-        end
-        local targetKey = "model_" .. keyStr
-
-        TextTargets[targetKey] = {
-            models = models,
-            buttontext = tempText,
-            options = opts,
-            dist = dist,
-            coords = vec3(0, 0, 0),
-            text = table.concat(tempText, "\n")
-        }
     elseif isStarted(OXTargetExport) then
         debugPrint("^6Bridge^7: ^2Creating new ^3Model^2 target with ^6"..OXTargetExport)
         local options = {}
@@ -418,7 +296,7 @@ function createModelTarget(models, opts, dist)
             options[i] = {
                 icon = opts[i].icon,
                 label = opts[i].label,
-                item = opts[i].item or nil,
+                items = opts[i].item or nil,
                 groups = opts[i].job or opts[i].gang,
                 onSelect = opts[i].action,
                 distance = dist,
@@ -453,7 +331,7 @@ function removeEntityTarget(entity)
         exports[OXTargetExport]:removeLocalEntity(entity, nil)
     end
     if Config.System.DontUseTarget or (not isStarted(OXTargetExport) and not isStarted(QBTargetExport)) then
-        TextTargets[entity] = nil
+        exports.jim_bridge:removeEntityTarget(entity)
     end
 end
 
@@ -474,7 +352,7 @@ function removeZoneTarget(target)
         exports[OXTargetExport]:removeZone(target, true)
     end
     if Config.System.DontUseTarget or (not isStarted(OXTargetExport) and not isStarted(QBTargetExport)) then
-        TextTargets[target] = nil
+        exports.jim_bridge:removeZoneTarget(target)
     end
 end
 
@@ -494,7 +372,7 @@ function removeModelTarget(model)
         exports[OXTargetExport]:removeModel(model, nil)
     end
     if Config.System.DontUseTarget or (not isStarted(OXTargetExport) and not isStarted(QBTargetExport)) then
-        TextTargets[entity] = nil
+        exports.jim_bridge:removeZoneTarget(target)
     end
 end
 -------------------------------------------------------------
@@ -504,69 +382,105 @@ end
 -- If no targeting system is detected and this is a client script, use DrawText3D for targets.
 if (Config.System.DontUseTarget or (not isStarted(OXTargetExport) and not isStarted(QBTargetExport))) and not isServer() then
     CreateThread(function()
-        local wait = 1000
         while true do
-            local pedCoords = GetEntityCoords(PlayerPedId())
+            local ped = PlayerPedId()
+            local pedCoords = GetEntityCoords(ped)
             local camCoords = GetGameplayCamCoord()
             local camRot = GetGameplayCamRot(2)
             local camForward = RotationToDirection(camRot)
-            local closestTarget, closestDist = nil, math.huge
-            local notificationShown = false
+
+            local closestTarget = nil
+            local closestDist = math.huge
             local targetEntity = nil
-            -- Update model targets and determine the closest target.
-            for _, target in pairs(TextTargets) do
+
+            -- Shallow copy for safety
+            local targetsCopy = {}
+            for k, v in pairs(TextTargets) do
+                targetsCopy[k] = v
+            end
+
+            -- Detect models and update coords
+            for _, target in pairs(targetsCopy) do
                 if target.models then
-                    for _, model in ipairs(target.models) do
-                        local entity = GetClosestObjectOfType(pedCoords.x, pedCoords.y, pedCoords.z, target.dist, model, false, false, false)
-                        if entity and entity ~= 0 then
-                            target.coords = GetEntityCoords(entity)
-                            targetEntity = entity
-                            break
+                    if not target.entity or not DoesEntityExist(target.entity) then
+                        for _, model in ipairs(target.models) do
+                            local entity = GetClosestObjectOfType(pedCoords.x, pedCoords.y, pedCoords.z, target.dist, model, false, false, false)
+                            if entity and entity ~= 0 then
+                                target.entity = entity
+                                target.coords = GetEntityCoords(entity)
+                                break
+                            end
                         end
+                    else
+                        target.coords = GetEntityCoords(target.entity)
                     end
                 end
+            end
 
-                local dist = #(pedCoords - target.coords)
-                if dist <= target.dist then
+            -- Identify closest visible target
+            for _, target in pairs(targetsCopy) do
+                if target.coords then
+                    local dist = #(pedCoords - target.coords)
                     local vecToTarget = target.coords - camCoords
                     local normVec = normalizeVector(vecToTarget)
                     local dot = camForward.x * normVec.x + camForward.y * normVec.y + camForward.z * normVec.z
-                    if dot > 0.5 and dist < closestDist then
-                        closestDist = dist
-                        closestTarget = target
+                    local isFacing = dot > 0.5
+
+                    if dist <= target.dist and isFacing then
+                        if dist < closestDist then
+                            closestDist = dist
+                            closestTarget = target
+                            targetEntity = target.entity
+                        end
                     end
                 end
             end
 
-            -- Render targets, listen for key presses and display the help notification.
-            for key, target in pairs(TextTargets) do
-                if #(pedCoords - target.coords) <= target.dist then
+            -- Render + handle input
+            for _, target in pairs(targetsCopy) do
+                if target.coords and #(pedCoords - target.coords) <= target.dist then
                     local isClosest = (target == closestTarget)
-                    for i, opt in ipairs(target.options) do
+
+                    for _, opt in ipairs(target.options) do
                         if IsControlJustPressed(0, opt.key) and isClosest then
-                            if opt.onSelect then opt.onSelect(targetEntity) end
-                            if opt.action then opt.action(targetEntity) end
+                            local canInteract = (not target.canInteract or target.canInteract())
+                            local hasItem = (not opt.item or hasItem(opt.item))
+                            local hasJob = (not opt.job or hasJob(opt.job, nil))
+
+                            if canInteract and hasItem and hasJob then
+                                if opt.onSelect then opt.onSelect(targetEntity) end
+                                if opt.action then opt.action(targetEntity) end
+                            end
                         end
                     end
 
-                    notificationShown = true
-                    ShowFloatingHelpNotification(vec3(target.coords.x, target.coords.y, target.coords.z + 0.7), target.text)
+                    -- Draw each eligible text line
+                    local baseZ = target.coords.z + 1.0
+                    local lineHeight = -0.16
+                    local lineOffset = 0
+
+                    for i, opt in ipairs(target.options) do
+                        local canInteract = (not target.canInteract or target.canInteract())
+                        local hasItem = (not opt.item or hasItem(opt.item))
+                        local hasJob = (not opt.job or hasJob(opt.job, nil))
+
+                        if canInteract and hasItem and hasJob then
+                            local text = target.buttontext[i]
+                            local zOffset = lineOffset * lineHeight
+                            DrawText3D(vec3(target.coords.x, target.coords.y, baseZ + zOffset), text, isClosest)
+                            lineOffset += 1
+                        end
+                    end
                 end
             end
 
-            -- If no notification was drawn this frame, clear help messages.
-            if notificationShown then
-                wait = 0
-            else
-                ClearAllHelpMessages()
-                wait = 1000
-            end
 
-            Wait(wait)
+            Wait(0)
         end
     end)
 end
 
+
 function ShowFloatingHelpNotification(coord, text, highlight)
     AddTextEntry("FloatingText", text)
     SetFloatingHelpTextWorldPosition(1, coord.x, coord.y, coord.z)

shared/vehicles.lua

@@ -108,6 +108,7 @@ function getVehicleProperties(vehicle)
     if isStarted(QBExport) and not isStarted(QBXExport) then
         properties = Core.Functions.GetVehicleProperties(vehicle)
         debugPrint("^6Bridge^7: ^2Getting Vehicle Properties ^7[^6"..QBExport.."^7] - [^3"..vehicle.."^7] - [^3"..GetEntityModel(vehicle).."^7/^3"..properties.model.."^7] - [^3"..properties.plate.."^7]")
+
     elseif isStarted(OXLibExport) then
         properties = lib.getVehicleProperties(vehicle)
         debugPrint("^6Bridge^7: ^2Getting Vehicle Properties ^7[^6"..OXLibExport.."^7] - [^3"..vehicle.."^7] - [^3"..GetEntityModel(vehicle).."^7/^3"..properties.model.."^7] - [^3"..properties.plate.."^7]")
@@ -134,6 +135,7 @@ function setVehicleProperties(vehicle, props)
         if isStarted(QBExport) and not isStarted(QBXExport) then
             Core.Functions.SetVehicleProperties(vehicle, props)
             debugPrint("^6Bridge^7: ^2Setting Vehicle Properties ^7[^6"..QBExport.."^7] - [^3"..vehicle.."^7] - [^3"..GetEntityModel(vehicle).."^7/^3"..props.model.."^7] - [^3"..props.plate.."^7]")
+
         elseif isStarted(OXLibExport) then
             lib.setVehicleProperties(vehicle, props, false)
             debugPrint("^6Bridge^7: ^2Setting Vehicle Properties ^7[^6"..OXLibExport.."^7] - [^3"..vehicle.."^7] - [^3"..GetEntityModel(vehicle).."^7/^3"..props.model.."^7] - [^3"..props.plate.."^7]")

shared/warmenu.lua

@@ -0,0 +1,694 @@
+WarMenu = { }
+WarMenu.__index = WarMenu
+
+if not isServer() then
+
+-- Deprecated
+WarMenu.debug = false
+function WarMenu.SetDebugEnabled(enabled)
+end
+function WarMenu.IsDebugEnabled()
+	return false
+end
+---
+
+local menus = { }
+local keys = { down = 187, scrollDown = 242, up = 188, scrollUp = 241, left = 189, right = 190, select = 191, accept = 237, back = 194, cancel = 238 }
+
+local skipInputNextFrame = true
+local optionCount = 0
+
+local currentKey = nil
+local currentMenu = nil
+
+local toolTipWidth = 0.153
+
+local spriteWidth = 0.027
+local spriteHeight = spriteWidth * GetAspectRatio()
+
+local titleHeight = 0.101
+local titleYOffset = 0.021
+local titleFont = 1
+local titleScale = 1.0
+
+local buttonHeight = 0.038
+local buttonFont = 0
+local buttonScale = 0.365
+local buttonTextXOffset = 0.005
+local buttonTextYOffset = 0.005
+local buttonSpriteXOffset = 0.002
+local buttonSpriteYOffset = 0.005
+
+local defaultStyle = {
+	x = 0.0175,
+	y = 0.025,
+	width = 0.23,
+	maxOptionCountOnScreen = 10,
+	titleVisible = true,
+	titleColor = { 0, 0, 0, 255 },
+	titleBackgroundColor = { 245, 127, 23, 255 },
+	titleBackgroundSprite = nil,
+	subTitleColor = { 245, 127, 23, 255 },
+	textColor = { 254, 254, 254, 255 },
+	subTextColor = { 189, 189, 189, 255 },
+	focusTextColor = { 0, 0, 0, 255 },
+	focusColor = { 245, 245, 245, 255 },
+	backgroundColor = { 0, 0, 0, 160 },
+	subTitleBackgroundColor = { 0, 0, 0, 255 },
+	buttonPressedSound = { name = 'SELECT', set = 'HUD_FRONTEND_DEFAULT_SOUNDSET' }, --https://pastebin.com/0neZdsZ5
+}
+
+local function IsNavigatedDown()
+	return IsControlJustReleased(2, keys.down) or IsControlJustReleased(2, keys.scrollDown)
+end
+
+local function IsNavigatedUp()
+	return IsControlJustReleased(2, keys.up) or IsControlJustReleased(2, keys.scrollUp)
+end
+
+local function IsSelectedPressed()
+	return IsControlJustReleased(2, keys.select) or IsControlJustReleased(2, keys.accept)
+end
+
+local function IsBackPressed()
+	return IsControlJustReleased(2, keys.back) or IsControlJustReleased(2, keys.cancel)
+end
+
+local function setMenuProperty(id, property, value)
+	if not id then
+		return
+	end
+
+	local menu = menus[id]
+	if menu then
+		menu[property] = value
+	end
+end
+
+local function setStyleProperty(id, property, value)
+	if not id then
+		return
+	end
+
+	local menu = menus[id]
+
+	if menu then
+		if not menu.overrideStyle then
+			menu.overrideStyle = { }
+		end
+
+		menu.overrideStyle[property] = value
+	end
+end
+
+local function getStyleProperty(property, menu)
+	menu = menu or currentMenu
+
+	if menu.overrideStyle then
+		local value = menu.overrideStyle[property]
+		if value ~= nil then
+			return value
+		end
+	end
+
+	return menu.style and menu.style[property] or defaultStyle[property]
+end
+
+local function getTitleHeight()
+	return getStyleProperty('titleVisible') and titleHeight or 0
+end
+
+local function copyTable(t)
+	if type(t) ~= 'table' then
+		return t
+	end
+
+	local result = { }
+	for k, v in pairs(t) do
+		result[k] = copyTable(v)
+	end
+
+	return result
+end
+
+local function setMenuVisible(id, visible, holdCurrentOption)
+	if currentMenu then
+		if visible then
+			if currentMenu.id == id then
+				return
+			end
+		else
+			if currentMenu.id ~= id then
+				return
+			end
+		end
+	end
+
+	if visible then
+		local menu = menus[id]
+
+		if not currentMenu then
+			menu.currentOption = 1
+		else
+			if not holdCurrentOption then
+				menus[currentMenu.id].currentOption = 1
+			end
+		end
+
+		currentMenu = menu
+		skipInputNextFrame = true
+
+		SetUserRadioControlEnabled(false)
+		HudWeaponWheelIgnoreControlInput(true)
+	else
+		HudWeaponWheelIgnoreControlInput(false)
+		SetUserRadioControlEnabled(true)
+
+		currentMenu = nil
+	end
+end
+
+local function setTextParams(font, color, scale, center, shadow, alignRight, wrapFrom, wrapTo)
+	SetTextFont(font)
+	SetTextColour(color[1], color[2], color[3], color[4] or 255)
+	SetTextScale(scale, scale)
+
+	if shadow then
+		SetTextDropShadow()
+	end
+
+	if center then
+		SetTextCentre(true)
+	elseif alignRight then
+		SetTextRightJustify(true)
+	end
+
+	if not wrapFrom or not wrapTo then
+		wrapFrom = wrapFrom or getStyleProperty('x')
+		wrapTo = wrapTo or getStyleProperty('x') + getStyleProperty('width') - buttonTextXOffset
+	end
+
+	SetTextWrap(wrapFrom, wrapTo)
+end
+
+local function getLinesCount(text, x, y)
+	BeginTextCommandLineCount('TWOSTRINGS')
+	AddTextComponentString(tostring(text))
+	return EndTextCommandGetLineCount(x, y)
+end
+
+local function drawText(text, x, y)
+	BeginTextCommandDisplayText('TWOSTRINGS')
+	AddTextComponentString(tostring(text))
+	EndTextCommandDisplayText(x, y)
+end
+
+local function drawRect(x, y, width, height, color)
+	DrawRect(x, y, width, height, color[1], color[2], color[3], color[4] or 255)
+end
+
+local function getCurrentIndex()
+	if currentMenu.currentOption <= getStyleProperty('maxOptionCountOnScreen') and optionCount <= getStyleProperty('maxOptionCountOnScreen') then
+		return optionCount
+	elseif optionCount > currentMenu.currentOption - getStyleProperty('maxOptionCountOnScreen') and optionCount <= currentMenu.currentOption then
+		return optionCount - (currentMenu.currentOption - getStyleProperty('maxOptionCountOnScreen'))
+	end
+
+	return nil
+end
+
+local function drawTitle()
+	if not getStyleProperty('titleVisible') then
+		return
+	end
+
+	local x = getStyleProperty('x') + getStyleProperty('width') / 2
+	local y = getStyleProperty('y') + titleHeight / 2
+
+	if getStyleProperty('titleBackgroundSprite') then
+		DrawSprite(getStyleProperty('titleBackgroundSprite').dict, getStyleProperty('titleBackgroundSprite').name, x, y, getStyleProperty('width'), titleHeight, 0., 255, 255, 255, 255)
+	else
+		drawRect(x, y, getStyleProperty('width'), titleHeight, getStyleProperty('titleBackgroundColor'))
+	end
+
+	if currentMenu.title then
+		setTextParams(titleFont, getStyleProperty('titleColor'), titleScale, true)
+		drawText(currentMenu.title, x, y - titleHeight / 2 + titleYOffset)
+	end
+end
+
+local function drawSubTitle()
+	local x = getStyleProperty('x') + getStyleProperty('width') / 2
+	local y = getStyleProperty('y') + getTitleHeight() + buttonHeight / 2
+
+	drawRect(x, y, getStyleProperty('width'), buttonHeight, getStyleProperty('subTitleBackgroundColor'))
+
+	setTextParams(buttonFont, getStyleProperty('subTitleColor'), buttonScale, false)
+	drawText(currentMenu.subTitle, getStyleProperty('x') + buttonTextXOffset, y - buttonHeight / 2 + buttonTextYOffset)
+
+	if optionCount > getStyleProperty('maxOptionCountOnScreen') then
+		setTextParams(buttonFont, getStyleProperty('subTitleColor'), buttonScale, false, false, true)
+		drawText(tostring(currentMenu.currentOption)..' / '..tostring(optionCount), getStyleProperty('x') + getStyleProperty('width'), y - buttonHeight / 2 + buttonTextYOffset)
+	end
+end
+
+local function drawButton(text, subText)
+	local currentIndex = getCurrentIndex()
+	if not currentIndex then
+		return
+	end
+
+	local backgroundColor = nil
+	local textColor = nil
+	local subTextColor = nil
+	local shadow = false
+
+	if currentMenu.currentOption == optionCount then
+		backgroundColor = getStyleProperty('focusColor')
+		textColor = getStyleProperty('focusTextColor')
+		subTextColor = getStyleProperty('focusTextColor')
+	else
+		backgroundColor = getStyleProperty('backgroundColor')
+		textColor = getStyleProperty('textColor')
+		subTextColor = getStyleProperty('subTextColor')
+		shadow = true
+	end
+
+	local x = getStyleProperty('x') + getStyleProperty('width') / 2
+	local y = getStyleProperty('y') + getTitleHeight() + buttonHeight + (buttonHeight * currentIndex) - buttonHeight / 2
+
+	drawRect(x, y, getStyleProperty('width'), buttonHeight, backgroundColor)
+
+	setTextParams(buttonFont, textColor, buttonScale, false, shadow)
+	drawText(text, getStyleProperty('x') + buttonTextXOffset, y - (buttonHeight / 2) + buttonTextYOffset)
+
+	if subText then
+		setTextParams(buttonFont, subTextColor, buttonScale, false, shadow, true)
+		drawText(subText, getStyleProperty('x') + buttonTextXOffset, y - buttonHeight / 2 + buttonTextYOffset)
+	end
+end
+
+function WarMenu.CreateMenu(id, title, subTitle, style)
+	-- Default settings
+	local menu = { }
+
+	-- Members
+	menu.id = id
+	menu.previousMenu = nil
+	menu.currentOption = 1
+	menu.title = title
+	menu.subTitle = subTitle and string.upper(subTitle) or 'INTERACTION MENU'
+
+	-- Style
+	if style then
+		menu.style = style
+	end
+
+	menus[id] = menu
+end
+
+function WarMenu.CreateSubMenu(id, parent, subTitle, style)
+	local parentMenu = menus[parent]
+	if not parentMenu then
+		return
+	end
+
+	WarMenu.CreateMenu(id, parentMenu.title, subTitle and string.upper(subTitle) or parentMenu.subTitle)
+
+	local menu = menus[id]
+
+	menu.previousMenu = parent
+
+	if parentMenu.overrideStyle then
+		menu.overrideStyle = copyTable(parentMenu.overrideStyle)
+	end
+
+	if style then
+		menu.style = style
+	elseif parentMenu.style then
+		menu.style = copyTable(parentMenu.style)
+	end
+end
+
+function WarMenu.CurrentMenu()
+	return currentMenu and currentMenu.id or nil
+end
+
+function WarMenu.OpenMenu(id)
+	if id and menus[id] then
+		PlaySoundFrontend(-1, 'SELECT', 'HUD_FRONTEND_DEFAULT_SOUNDSET', true)
+		setMenuVisible(id, true, true)
+	end
+end
+
+function WarMenu.IsMenuOpened(id)
+	return currentMenu and currentMenu.id == id
+end
+WarMenu.Begin = WarMenu.IsMenuOpened
+
+function WarMenu.IsAnyMenuOpened()
+	return currentMenu ~= nil
+end
+
+function WarMenu.IsMenuAboutToBeClosed()
+	return false
+end
+
+function WarMenu.CloseMenu()
+	if currentMenu then
+		setMenuVisible(currentMenu.id, false)
+		optionCount = 0
+		currentKey = nil
+		PlaySoundFrontend(-1, 'QUIT', 'HUD_FRONTEND_DEFAULT_SOUNDSET', true)
+	end
+end
+
+function WarMenu.ToolTip(text, width, flipHorizontal)
+	if not currentMenu then
+		return
+	end
+
+	local currentIndex = getCurrentIndex()
+	if not currentIndex then
+		return
+	end
+
+	width = width or toolTipWidth
+
+	local x = nil
+	if not flipHorizontal then
+		x = getStyleProperty('x') + getStyleProperty('width') + width / 2 + buttonTextXOffset
+	else
+		x = getStyleProperty('x') - width / 2 - buttonTextXOffset
+	end
+
+	local textX = x - (width / 2) + buttonTextXOffset
+	setTextParams(buttonFont, getStyleProperty('textColor'), buttonScale, false, true, false, textX, textX + width - (buttonTextYOffset * 2))
+	local linesCount = getLinesCount(text, textX, getStyleProperty('y'))
+
+	local height = GetTextScaleHeight(buttonScale, buttonFont) * (linesCount + 1) + buttonTextYOffset
+	local y = getStyleProperty('y') + getTitleHeight() + (buttonHeight * currentIndex) + height / 2
+
+	drawRect(x, y, width, height, getStyleProperty('backgroundColor'))
+
+	y = y - (height / 2) + buttonTextYOffset
+	drawText(text, textX, y)
+end
+
+function WarMenu.Button(text, subText)
+	if not currentMenu then
+		return
+	end
+
+	optionCount = optionCount + 1
+
+	drawButton(text, subText)
+
+	local pressed = false
+
+	if currentMenu.currentOption == optionCount then
+		if currentKey == keys.select then
+			pressed = true
+			PlaySoundFrontend(-1, getStyleProperty('buttonPressedSound').name, getStyleProperty('buttonPressedSound').set, true)
+		elseif currentKey == keys.left or currentKey == keys.right then
+			PlaySoundFrontend(-1, 'NAV_UP_DOWN', 'HUD_FRONTEND_DEFAULT_SOUNDSET', true)
+		end
+	end
+
+	return pressed
+end
+
+function WarMenu.SpriteButton(text, dict, name, r, g, b, a)
+	if not currentMenu then
+		return
+	end
+
+	local pressed = WarMenu.Button(text)
+
+	local currentIndex = getCurrentIndex()
+	if not currentIndex then
+		return
+	end
+
+	if not HasStreamedTextureDictLoaded(dict) then
+		RequestStreamedTextureDict(dict)
+	end
+	DrawSprite(dict, name, getStyleProperty('x') + getStyleProperty('width') - spriteWidth / 2 - buttonSpriteXOffset, getStyleProperty('y') + getTitleHeight() + buttonHeight + (buttonHeight * currentIndex) - spriteHeight / 2 + buttonSpriteYOffset, spriteWidth, spriteHeight, 0., r or 255, g or 255, b or 255, a or 255)
+
+	return pressed
+end
+
+function WarMenu.InputButton(text, windowTitleEntry, defaultText, maxLength, subText)
+	if not currentMenu then
+		return
+	end
+
+	local pressed = WarMenu.Button(text, subText)
+	local inputText = nil
+
+	if pressed then
+		DisplayOnscreenKeyboard(1, windowTitleEntry or 'FMMC_MPM_NA', '', defaultText or '', '', '', '', maxLength or 255)
+
+		while true do
+			DisableAllControlActions(0)
+
+			local status = UpdateOnscreenKeyboard()
+			if status == 2 then
+				break
+			elseif status == 1 then
+				inputText = GetOnscreenKeyboardResult()
+				break
+			end
+
+			Citizen.Wait(0)
+		end
+	end
+
+	return pressed, inputText
+end
+
+function WarMenu.MenuButton(text, id, subText)
+	if not currentMenu then
+		return
+	end
+
+	local pressed = WarMenu.Button(text, subText)
+
+	if pressed then
+		currentMenu.currentOption = optionCount
+		setMenuVisible(currentMenu.id, false)
+		setMenuVisible(id, true, true)
+	end
+
+	return pressed
+end
+
+function WarMenu.CheckBox(text, checked, callback)
+	if not currentMenu then
+		return
+	end
+
+	local name = nil
+	if currentMenu.currentOption == optionCount + 1 then
+		name = checked and 'shop_box_tickb' or 'shop_box_blankb'
+	else
+		name = checked and 'shop_box_tick' or 'shop_box_blank'
+	end
+
+	local pressed = WarMenu.SpriteButton(text, 'commonmenu', name)
+
+	if pressed then
+		checked = not checked
+		if callback then callback(checked) end
+	end
+
+	return pressed
+end
+
+function WarMenu.ComboBox(text, items, currentIndex, selectedIndex, callback)
+	if not currentMenu then
+		return
+	end
+
+	local itemsCount = #items
+	local selectedItem = items[currentIndex]
+	local isCurrent = currentMenu.currentOption == optionCount + 1
+	selectedIndex = selectedIndex or currentIndex
+
+	if itemsCount > 1 and isCurrent then
+		selectedItem = '← '..tostring(selectedItem)..' →'
+	end
+
+	local pressed = WarMenu.Button(text, selectedItem)
+
+	if pressed then
+		selectedIndex = currentIndex
+	elseif isCurrent then
+		if currentKey == keys.left then
+			if currentIndex > 1 then currentIndex = currentIndex - 1 else currentIndex = itemsCount end
+		elseif currentKey == keys.right then
+			if currentIndex < itemsCount then currentIndex = currentIndex + 1 else currentIndex = 1 end
+		end
+	end
+
+	if callback then callback(currentIndex, selectedIndex) end
+	return pressed, currentIndex
+end
+
+function WarMenu.Display()
+	if currentMenu then
+		if not IsPauseMenuActive() then
+			ClearAllHelpMessages()
+			HudWeaponWheelIgnoreSelection()
+			DisablePlayerFiring(PlayerId(), true)
+			DisableControlAction(0, 25, true)
+
+			drawTitle()
+			drawSubTitle()
+
+			currentKey = nil
+
+			if skipInputNextFrame then
+				skipInputNextFrame = false
+			else
+				if IsNavigatedDown() then
+					PlaySoundFrontend(-1, 'NAV_UP_DOWN', 'HUD_FRONTEND_DEFAULT_SOUNDSET', true)
+
+					if currentMenu.currentOption < optionCount then
+						currentMenu.currentOption = currentMenu.currentOption + 1
+					else
+						currentMenu.currentOption = 1
+					end
+				elseif IsNavigatedUp() then
+					PlaySoundFrontend(-1, 'NAV_UP_DOWN', 'HUD_FRONTEND_DEFAULT_SOUNDSET', true)
+
+					if currentMenu.currentOption > 1 then
+						currentMenu.currentOption = currentMenu.currentOption - 1
+					else
+						currentMenu.currentOption = optionCount
+					end
+				elseif IsControlJustReleased(2, keys.left) then
+					currentKey = keys.left
+				elseif IsControlJustReleased(2, keys.right) then
+					currentKey = keys.right
+				elseif IsSelectedPressed() then
+					currentKey = keys.select
+				elseif IsBackPressed() then
+					if menus[currentMenu.previousMenu] then
+						setMenuVisible(currentMenu.previousMenu, true)
+						PlaySoundFrontend(-1, 'BACK', 'HUD_FRONTEND_DEFAULT_SOUNDSET', true)
+					else
+						WarMenu.CloseMenu()
+					end
+				end
+			end
+		end
+
+		optionCount = 0
+	end
+end
+WarMenu.End = WarMenu.Display
+
+function WarMenu.CurrentOption()
+	if currentMenu and optionCount ~= 0 then
+		return currentMenu.currentOption
+	end
+
+	return nil
+end
+
+function WarMenu.IsItemHovered()
+	if not currentMenu or optionCount == 0 then
+		return false
+	end
+
+	return currentMenu.currentOption == optionCount
+end
+
+function WarMenu.IsItemSelected()
+	return currentKey == keys.select and WarMenu.IsItemHovered()
+end
+
+function WarMenu.SetTitle(id, title)
+	setMenuProperty(id, 'title', title)
+end
+WarMenu.SetMenuTitle = WarMenu.SetTitle
+
+function WarMenu.SetSubTitle(id, text)
+	setMenuProperty(id, 'subTitle', string.upper(text))
+end
+WarMenu.SetMenuSubTitle = WarMenu.SetSubTitle
+
+function WarMenu.SetMenuStyle(id, style)
+	setMenuProperty(id, 'style', style)
+end
+
+function WarMenu.SetMenuTitleVisible(id, visible)
+	setStyleProperty(id, 'titleVisible', visible)
+end
+
+function WarMenu.SetMenuX(id, x)
+	setStyleProperty(id, 'x', x)
+end
+
+function WarMenu.SetMenuY(id, y)
+	setStyleProperty(id, 'y', y)
+end
+
+function WarMenu.SetMenuWidth(id, width)
+	setStyleProperty(id, 'width', width)
+end
+
+function WarMenu.SetMenuMaxOptionCountOnScreen(id, count)
+	setStyleProperty(id, 'maxOptionCountOnScreen', count)
+end
+
+function WarMenu.SetTitleColor(id, r, g, b, a)
+	setStyleProperty(id, 'titleColor', { r, g, b, a })
+end
+WarMenu.SetMenuTitleColor = WarMenu.SetTitleColor
+
+function WarMenu.SetMenuSubTitleColor(id, r, g, b, a)
+	setStyleProperty(id, 'subTitleColor', { r, g, b, a })
+end
+
+function WarMenu.SetMenuSubTitleBackgroundColor(id, r, g, b, a)
+	setStyleProperty(id, 'subTitleBackgroundColor', { r, g, b, a })
+end
+
+function WarMenu.SetTitleBackgroundColor(id, r, g, b, a)
+	setStyleProperty(id, 'titleBackgroundColor', { r, g, b, a })
+end
+WarMenu.SetMenuTitleBackgroundColor = WarMenu.SetTitleBackgroundColor
+
+function WarMenu.SetTitleBackgroundSprite(id, dict, name)
+	RequestStreamedTextureDict(dict)
+	setStyleProperty(id, 'titleBackgroundSprite', { dict = dict, name = name })
+end
+WarMenu.SetMenuTitleBackgroundSprite = WarMenu.SetTitleBackgroundSprite
+
+function WarMenu.SetMenuBackgroundColor(id, r, g, b, a)
+	setStyleProperty(id, 'backgroundColor', { r, g, b, a })
+end
+
+function WarMenu.SetMenuTextColor(id, r, g, b, a)
+	setStyleProperty(id, 'textColor', { r, g, b, a })
+end
+
+function WarMenu.SetMenuSubTextColor(id, r, g, b, a)
+	setStyleProperty(id, 'subTextColor', { r, g, b, a })
+end
+
+function WarMenu.SetMenuFocusColor(id, r, g, b, a)
+	setStyleProperty(id, 'focusColor', { r, g, b, a })
+end
+
+function WarMenu.SetMenuFocusTextColor(id, r, g, b, a)
+	setStyleProperty(id, 'focusTextColor', { r, g, b, a })
+end
+
+function WarMenu.SetMenuButtonPressedSound(id, name, set)
+	setStyleProperty(id, 'buttonPressedSound', { name = name, set = set })
+end
+
+end

shared/wrapperfunctions.lua

@@ -21,85 +21,24 @@
 --- })
 --- ```
 function registerCommand(command, options)
+
     if isStarted(OXLibExport) then
         debugPrint("^6Bridge^7: ^2Registering ^3Command^2 with ^7"..OXLibExport, command)
         lib.addCommand(command, { help = options[1], restricted = options[5] and "group."..options[5] or nil }, options[4])
+
     elseif isStarted(QBExport) and not isStarted(QBXExport) then
         debugPrint("^6Bridge^7: ^2Registering ^3Command^2 with ^7"..QBExport, command)
         Core.Commands.Add(command, options[1], options[2], options[3], options[4], options[5] or nil)
+
+    elseif isStarted(RSGExport) then
+        debugPrint("^6Bridge^7: ^2Registering ^3Command^2 with ^7"..RSGExport, command)
+        Core.Commands.Add(command, options[1], options[2], options[3], options[4], options[5] or nil)
+
     elseif isStarted(ESXExport) then
         debugPrint("^6Bridge^7: ^2Registering ^3Command^2 with ^7ESX Legacy", command)
         ESX.RegisterCommand(command, options[5] or 'admin', function(xPlayer, args, showError)
             options[4](xPlayer.source, args, showError)
         end, false, { help = options[1] })
+
     end
-end
-
---- Registers a stash with the active inventory system.
---- Supports either OXInv or QSInv.
----
---- @param name string Unique stash identifier.
---- @param label string Display name for the stash.
---- @param slots number|nil (Optional) Number of slots (default 50).
---- @param weight number|nil (Optional) Maximum weight (default 4000000).
---- @param owner string|nil (Optional) Owner identifier for personal stashes.
---- @param coords table|nil (Optional) Coordinates for the stash location.
---- @usage
---- ```lua
---- registerStash(
----     "playerStash",
----     "Player Stash",
----     100,
----     8000000,
----     "player123",
----     { x = 100.0, y = 200.0, z = 30.0 }
---- )
---- ```
-function registerStash(name, label, slots, weight, owner, coords)
-    if isStarted(OXInv) then
-        debugPrint("^6Bridge^7: ^2Registering ^3OX ^2Stash^7:", name, label, owner or nil)
-        exports[OXInv]:RegisterStash(name, label, slots or 50, weight or 4000000, owner or nil)
-    elseif isStarted(QSInv) then
-        debugPrint("^6Bridge^7: ^2Registering ^3QS ^2Stash^7:", name, label)
-        exports[QSInv]:RegisterStash(nil, name, slots or 50, weight or 4000000)
-
-    --elseif isStarted(CoreInv) then
-    --    debugPrint("^6Bridge^7: ^2Registering ^3CoreInv ^2Stash^7:", name, label)
-    --    exports[CoreInv]:openHolder(nil, name, 'stash', nil, nil, false, nil)
-
-    elseif isStarted(OrigenInv) then
-        debugPrint("^6Bridge^7: ^2Registering ^3OrigenInv ^2Stash^7:", name, label)
-        exports["origen_inventory"]:registerStash(name, label, slots or 50, weight or 4000000)
-    end
-end
-
-if isServer() then
-    --- Registers an event to create an OX stash from the server.
-    --- When triggered, it calls registerStash with the provided parameters.
-    ---
-    --- @event server:makeOXStash
-    --- @param name string Unique stash identifier.
-    --- @param label string Display name for the stash.
-    --- @param slots number|nil (Optional) Number of slots.
-    --- @param weight number|nil (Optional) Maximum weight.
-    --- @param owner string|nil (Optional) Owner identifier.
-    --- @param coords table|nil (Optional) Stash coordinates.
-    --- @usage
-    --- ```lua
-    --- TriggerEvent(getScript()..":server:makeOXStash", name, label, slots, weight, owner, coords)
-    --- ```
-    RegisterNetEvent(getScript()..":server:makeOXStash", function(name, label, slots, weight, owner, coords, token)
-        local src = source or nil
-        if src then
-            debugPrint("^1Auth^7: ^2Auth token received^7, ^2checking against server cache^7..")
-            if token ~= validTokens[src] then
-                debugPrint("^1Auth^7: ^1Tokens don't match! ^7", token, validTokens[src])
-            else
-                debugPrint("^1Auth^7: ^2Client and Server Auth tokens match^7!", token, validTokens[src])
-                validTokens[src] = nil
-            end
-        end
-
-        registerStash(name, label, slots, weight, owner, coords)
-    end)
-end
+end

starter.lua

@@ -13,6 +13,8 @@ Exports = {
     CoreInv = "core_inventory",
     CodeMInv = "codem-inventory",
     OrigenInv = "origen_inventory",
+    TgiannInv = "tgiann-inventory",
+    JPRInv = "jpr-inventory",
 
     OXLibExport = "ox_lib",
 
@@ -29,7 +31,12 @@ Exports = {
 -- Required variables
 debugMode = Config.System.Debug
 
--- Check server convars for hard set defaults
+QBInvNew = true
+
+InventoryWeight = 120000
+
+-- [[ Server.Cfg Convar Check ]]--
+-- Check server convars for hard set defaults, otherwise it uses per script configurations
 if Config and Config.System then
     if Config.System.Debug then
         if GetConvar("jim_DisableDebug", "false") == "true" then
@@ -41,38 +48,75 @@ if Config and Config.System then
     end
 
     Config.System.Menu = GetConvar("jim_menuScript", Config.System.Menu)
-    Config.System.Notify = GetConvar("jim_notifyScript", Config.System.Notify)
-    Config.System.ProgressBar = GetConvar("jim_progressBarScript", Config.System.ProgressBar)
-    Config.System.drawText = GetConvar("jim_drawTextScript", Config.System.drawText)
-    Config.System.skillCheck = GetConvar("jim_skillCheckScript", Config.System.skillCheck)
+    Config.System.Notify = GetConvar("jim_notifyScript", Config.System.Notify or "gta")
+    Config.System.ProgressBar = GetConvar("jim_progressBarScript", Config.System.ProgressBar or "gta")
+    Config.System.drawText = GetConvar("jim_drawTextScript", Config.System.drawText or "gta")
+    Config.System.skillCheck = GetConvar("jim_skillCheckScript", Config.System.skillCheck or "gta")
 
     if GetConvar("jim_dontUseTarget", "false") == "true" then
         Config.System.DontUseTarget = true
     end
 end
 
-QBInvNew = true
+-- Load the core files here instead of in fxmanifests
+-- Forcefully loads the files and quietly, compared to fxmanifest complaining if they don't exist when you don't need them all
+local filesToLoad = {
+    Shared = {
+        [Exports.OXLibExport] = { "init.lua" },
+        [Exports.OXCoreExport] = { "lib/init.lua" },
+        [Exports.ESXExport] = { "imports.lua" },
+        [Exports.QBXExport] = { "modules/playerdata.lua" },
+    },
+    Client = {
+        ["PolyZone"] = { "client.lua", "BoxZone.lua", "EntityZone.lua", "CircleZone.lua", "ComboZone.lua" },
+        ["warmenu"] = { "warmenu.lua", },
+    },
+}
 
-InventoryWeight = 120000
+-- Shared framework file loader
+for Type, ScriptTable in pairs(filesToLoad) do
+    if Type == "Client" and IsDuplicityVersion() then
+        goto continue
+    else
+        for scriptName, files in pairs(ScriptTable) do
+            local state = GetResourceState(scriptName)
+            -- if the resource is started, load the file
+            if state == "started" then
+                if scriptName == Exports.OXLibExport and GetResourceState(Exports.OXCoreExport):find("start") then
+                    if debugMode then print("OX_Core found, skipping OX_Lib loading") end
+                    goto skip
+                end
+                -- Force items into a table if they are not
+                if type(files) == "string" then
+                    files = { files }
+                end
+                for _, file in pairs(files) do
+                    --print("^5CoreLoader^7: '"..scriptName.."/"..file.."' ^2into ^7'"..GetCurrentResourceName().."' ...")
+                    local fileLoader = assert(load(LoadResourceFile(scriptName, (file)), ('@@'..scriptName..'/'..file)))
+                    fileLoader()
+                    if debugMode then
+                        print("^5CoreLoader^7: ^2loaded ^1Core ^2file^7: ^3"..scriptName.."^7/^3"..(file):gsub("/", "^7/^3"):gsub("%.lua", "^7.lua").." ^2into ^7'"..GetCurrentResourceName().."'")
+                    end
+                end
+                ::skip::
+            end
 
--- Testing loading the core files here instead of in fxmanifests
---for k, v in pairs({ -- This is a specific load order
---    [Exports.OXLibExport] = "init.lua",
---    [Exports.OXCoreExport] = "lib/init.lua",
---    [Exports.ESXExport] = "imports.lua",
---    [Exports.QBXExport] = "modules/playerdata.lua",
---}) do
---    if GetResourceState(k) == "started" then
---        print("^5Loading^7: '"..k.."/"..v.."' ^2into ^7'"..GetCurrentResourceName().."' ...")
---        local fileLoader = assert(load(LoadResourceFile(k, (v)), ('@@'..k..'/'..v)))
---        fileLoader()
---        print("^2Success^7: ^2loaded ^1Core ^2file^7: ^3"..k.."^7/^3"..(v):gsub("/", "^7/^3"):gsub("%.lua", "^7.lua").."^7")
---    else
---        if debugMode then
---            print("^3Warning^7: ^3"..k.." ^2not found^7, ^2skipping")
---        end
---    end
---end
+            -- if script is in server, but not started warn the user
+            if state == "uninitialized" or state == "stopped" then
+                print("^5CoreLoader^7: ^3"..scriptName.." ^1 found but it wasn't started^7.")
+                print("^1Check your ^3server^7.^3cfg ^1load order^7")
+            end
+
+            -- debugging only, if the script is missing, warn the user
+            if state == "missing" then
+                if debugMode then
+                    print("^5CoreLoader^7: ^3"..scriptName.." ^2not found^7, ^2skipping")
+                end
+            end
+        end
+    end
+    ::continue::
+end
 
 -- Load files here into the invoking script
 for _, v in pairs({ -- This is a specific load order
@@ -82,7 +126,7 @@ for _, v in pairs({ -- This is a specific load order
 
     '_eventDebug.lua',
     'callback.lua',
-    'coreloader.lua',   -- needs to be second to load all core related stuff before everything else
+    'coreloader.lua',
 
     'duifunctions.lua',
 
@@ -132,6 +176,8 @@ for _, v in pairs({ -- This is a specific load order
     'vehicles.lua',
     'effects.lua',
 
+    --'warmenu.lua',
+
     -- Do version check last
     '_scriptversioncheck.lua'
 }) do
@@ -141,6 +187,20 @@ for _, v in pairs({ -- This is a specific load order
     local fileLoader = assert(load(LoadResourceFile('jim_bridge', ('shared/'..v)), ('@@jim_bridge/shared/'..v)))
     fileLoader()
     if debugMode then
-        print("^5Success^7: ^2loaded file^7: ^3"..(v):gsub("/", "^7/^3"):gsub("%.lua", "^7.lua").."^7")
+        print("^5CoreLoader^7: ^2loaded file^7: ^3"..(v):gsub("/", "^7/^3"):gsub("%.lua", "^7.lua").."^7")
+    end
+end
+
+if isStarted(QBInv) then
+    if not checkExportExists(QBInv, "HasItem") then
+        print("^6Bridge^7: ^2Can^7'^2t ^2find new QBInv export^7, ^2forcing ^1QBInvNew ^2to ^1false^7")
+        QBInvNew = false
+    end
+end
+
+if isStarted(PSInv) then
+    if not checkExportExists(PSInv, "HasItem") then
+        print("^6Bridge^7: ^2Can^7't ^2find new PSInv export^7, ^2forcing ^1QBInvNew ^2to ^1false^7")
+        QBInvNew = false
     end
 end

ui_modules/notifications.lua

@@ -0,0 +1,120 @@
+local notifications = {}
+local spacing = 60  -- vertical spacing between notifications
+local activeDrawing = false -- flag for drawing loop state
+
+if not HasStreamedTextureDictLoaded("timerbars") then
+    while not HasStreamedTextureDictLoaded("timerbars") do
+        RequestStreamedTextureDict("timerbars")
+        Wait(5)
+    end
+end
+
+local notifTypes = {
+    success = "✔️",
+    error = "❌",
+    warning = "⚠️",
+    police = "🚓",
+    ambulance = "🚑",
+}
+
+function gtaNotify(title, message, emoji, src)
+    local notif = {
+        title = title,
+        message = message,
+        emoji = notifTypes[emoji] or "❔",
+        state = "enter",
+        startTime = GetGameTimer(),
+        progress = 0,
+        holdTime = 8000,
+        slideDuration = 100,
+        currentOffset = 0,
+    }
+    table.insert(notifications, notif)
+
+    -- Activate drawing loop if not already running
+    -- This allows it to be silent until the first notifcation is called, then the loop starts
+    if not activeDrawing then
+        activeDrawing = true
+        StartDrawingLoop()
+    end
+end
+
+-- Drawing loop as a separate controlled thread
+function StartDrawingLoop()
+    CreateThread(function()
+        while #notifications > 0 do
+            local currentTime = GetGameTimer()
+
+            -- Update notifications vertical offset
+            for i, notif in ipairs(notifications) do
+                local target = (#notifications - i) * spacing
+                notif.currentOffset += (target - notif.currentOffset) * 0.1
+            end
+
+            for i = #notifications, 1, -1 do
+                local notif = notifications[i]
+
+                if notif.state == "enter" then
+                    local elapsed = currentTime - notif.startTime
+                    notif.progress = math.min(elapsed / notif.slideDuration, 1.0)
+                    if notif.progress >= 1.0 then
+                        notif.state = "hold"
+                        notif.holdStart = currentTime
+                    end
+                elseif notif.state == "hold" then
+                    if currentTime - notif.holdStart >= notif.holdTime then
+                        notif.state = "exit"
+                        notif.exitStart = currentTime
+                    end
+                elseif notif.state == "exit" then
+                    local elapsed = currentTime - notif.exitStart
+                    notif.progress = 1.0 - math.min(elapsed / notif.slideDuration, 1.0)
+                    if notif.progress <= 0 then
+                        table.remove(notifications, i)
+                        goto continue
+                    end
+                end
+
+                local startX, targetX = 1.0, 0.8
+                local posX = startX - (startX - targetX) * notif.progress
+                local posY = 0.05 + (notif.currentOffset / 1080)
+
+                -- Background sprite
+                DrawSprite("timerbars", "all_black_bg", posX + 0.11, posY + 0.025, 0.2, 0.053, 0.0, 255, 255, 255, 255)
+
+                -- Title text
+                local moveMessage = false
+                if not notif.title or notif.title == "" then
+                    moveMessage = true
+                else
+                    drawNotiText(8, 0.4, vec2(0.75, 0.975), notif.title, vec2(posX, posY))
+                end
+
+                -- Message text
+                drawNotiText(4, 0.3, vec2(0.75, 0.975), notif.message, vec2(posX, posY + (moveMessage and 0.015 or 0.03)))
+
+                -- Emoji
+                drawNotiText(0, 0.3, vec2(0.75, 0.995), notif.emoji, vec2(posX, posY + 0.015))
+
+                ::continue::
+            end
+            Wait(0)
+        end
+        activeDrawing = false -- No notifications left, pause drawing
+    end)
+end
+
+function drawNotiText(font, scale, wrap, string, pos)
+    SetTextFont(font)
+    SetTextScale(scale, scale)
+    SetTextWrap(wrap.x, wrap.y)
+    SetTextJustification(2)
+    SetTextColour(255, 255, 255, 255)
+    SetTextOutline()
+    SetTextEntry("STRING")
+    AddTextComponentString(string)
+    DrawText(pos.x, pos.y)
+end
+
+RegisterNetEvent("jim-bridge:Notify", gtaNotify)
+exports("Notify", gtaNotify)

ui_modules/skillcheck.lua

@@ -0,0 +1,121 @@
+local activeSkillCheck = false
+
+function gtaSkillCheck()
+    if activeSkillCheck then return end
+    local result = false
+    local successes = 0
+    local barsRequired = 3
+
+    for bar = 1, barsRequired do
+        activeSkillCheck = true
+        local width, height = 0.2, 0.01
+        local x, y = 0.5, 0.8
+
+        -- Random highlighted zone
+        local highlightSize = math.random(10, 20) / 100
+        local highlightStart = math.random(10, 50) / 100
+        local highlightEnd = highlightStart + highlightSize
+        local highlightAlpha = 0
+        local cursorPos = 0.0
+        local cursorSpeed = 0.025
+        local movingRight = true
+
+        while activeSkillCheck do
+            Wait(0)
+
+            createScaleBars(x, y, width, height)
+
+            local pulse = (math.sin(GetGameTimer() / 250) + 1) / 2 -- Creates a pulsing effect
+            highlightAlpha = math.floor(150 + (pulse * 105)) -- Pulsing between 150 and 255 alpha
+
+            -- Draw highlighted zone (success area) with pulsing effect
+            DrawRect(x - width / 2 + (highlightStart + highlightSize / 2) * width, y, highlightSize * width, height+0.001, 93, 182, 229, highlightAlpha )
+            -- Draw moving cursor
+            DrawRect(x - width / 2 + cursorPos * width, y, 0.002, height + 0.01, 255, 255, 255, 255)
+
+            -- Move cursor
+            if movingRight then
+                cursorPos += cursorSpeed
+                if cursorPos >= 1.0 then movingRight = false end
+            else
+                cursorPos -= cursorSpeed
+                if cursorPos <= 0.0 then movingRight = true end
+            end
+
+            if IsControlJustPressed(0, 177) then        -- Backspace to cancel
+                local displayTime = GetGameTimer() + 2000
+                PlaySoundFrontend(-1, 'Highlight_Cancel', 'DLC_HEIST_PLANNING_BOARD_SOUNDS', 1)
+                while GetGameTimer() < displayTime do
+                    Wait(0)
+
+                    createScaleBars(x, y, width, height)
+
+                    DrawRect(x - width / 2 + (highlightStart + highlightSize / 2) * width, y, highlightSize * width, height+0.001, 228, 52, 52, 255)
+                    DrawRect(x - width / 2 + cursorPos * width, y, 0.002, height + 0.01, 255, 255, 255, 255)
+
+                    drawSuccessText(x, y, "Failed", 228, 52, 52)
+                end
+                return false
+            end
+
+            -- Check for keypress (E)
+            if IsControlJustPressed(0, 38) then
+                activeSkillCheck = false
+                result = cursorPos >= highlightStart and cursorPos <= highlightEnd
+                if result then
+                    PlaySoundFrontend(-1, "YES", "HUD_FRONTEND_DEFAULT_SOUNDSET", true)
+                else
+                    PlaySoundFrontend(-1, 'Highlight_Cancel', 'DLC_HEIST_PLANNING_BOARD_SOUNDS', 1)
+                end
+                local displayTime = GetGameTimer() + 2000
+                while GetGameTimer() < displayTime do
+                    Wait(0)
+
+                    createScaleBars(x, y, width, height)
+
+                    -- Draw highlighted zone
+                    DrawRect(x - width / 2 + (highlightStart + highlightSize / 2) * width, y, highlightSize * width, height+0.001, result and 93 or 228, result and 182 or 52, result and 229 or 52, 180)
+
+                    -- Draw stationary cursor at result position
+                    DrawRect(x - width / 2 + cursorPos * width, y, 0.002, height + 0.01, 255, 255, 255, 255)
+                    -- Display result text
+                    drawSuccessText(x, y, result and "Success" or "Failed", result and 114 or 228, result and 204 or 52, result and 144 or 52)
+                end
+                if result then
+                    successes += 1
+                else
+                    return false
+                end
+            end
+        end
+    end
+    activeSkillCheck = false
+    print("^5GTAUI^7: ^2Skill Check Result^7: ^3" .. successes .. "^7/^3" .. barsRequired.."^7")
+    return successes == barsRequired
+end
+
+function drawSuccessText(x, y, text, r, g, b)
+    SetTextFont(8)
+    SetTextScale(0.45, 0.45)
+    SetTextColour(r, g, b, 255)
+    SetTextDropshadow(0, 0, 0, 0, 255)
+    SetTextEdge(2, 0, 0, 0, 150)
+    SetTextDropShadow()
+    SetTextOutline()
+    SetTextCentre(true)
+    SetTextEntry("STRING")
+    SetTextCentre(true)
+    SetTextEntry("STRING")
+    AddTextComponentString(text)
+    DrawText(x, y + 0.03)
+end
+
+function createScaleBars(x, y, width, height)
+    -- Draw background box
+    DrawSprite("timerbars", "all_black_bg", x - (width / 4) - 0.006, y, (width / 2) + 0.08, height + 0.04, 0.0, 255, 255, 255, 255)
+    DrawSprite("timerbars", "all_black_bg", x + (width / 4) + 0.006, y, (width / 2) + 0.08, height + 0.04, 180.0, 255, 255, 255, 255)
+    -- Draw full bar (dark background)
+    DrawRect(x, y, width, height, 100, 100, 100, 255)
+end
+
+exports("skillCheck", gtaSkillCheck)

ui_modules/target.lua

@@ -0,0 +1,318 @@
+-- Global Key Table, defined once.
+---
+local KEY_TABLE = { 38, 29, 47, 23, 45, 159, 162, 163 }
+
+-- Mapping of key codes to human-readable key names.
+local Keys = {
+    [322] = "ESC", [288] = "F1", [289] = "F2", [170] = "F3", [166] = "F5",
+    [167] = "F6", [168] = "F7", [169] = "F8", [56] = "F9", [57] = "F10",
+    [243] = "~", [157] = "1", [158] = "2", [160] = "3", [164] = "4", [165] = "5",
+    [159] = "6", [161] = "7", [162] = "8", [163] = "9", [84] = "-", [83] = "=",
+    [177] = "BACKSPACE", [37] = "TAB",
+    [44] = "Q", [32] = "W", [38] = "E", [45] = "R", [245] = "T", [246] = "Y",
+    [303] = "U", [199] = "P",
+    [39] = "[",  [40] = "]", [18] = "ENTER", [137] = "CAPS",
+    [34] = "A", [8] = "S", [9] = "D", [23] = "F", [47] = "G",
+    [74] = "H", [311] = "K", [182] = "L", [21] = "LEFTSHIFT",
+    [20] = "Z", [73] = "X", [26] = "C", [0] = "V",  [29] = "B", [249] = "N",
+    [244] = "M", [82] = ",", [81] = "."
+}
+-- Tables for storing created targets.
+local TextTargets    = {}   -- For fallback DrawText3D targets.
+local targetEntities = {}   -- For entity targets.
+
+function createEntityTarget(entity, opts, dist)
+    startTargetLoop()
+    targetEntities[#targetEntities + 1] = entity
+    local entityCoords = GetEntityCoords(entity)
+
+    local existingTarget = nil
+    for _, target in pairs(TextTargets) do
+        if #(target.coords - entityCoords) < 0.01 then
+            existingTarget = target
+            break
+        end
+    end
+
+    if existingTarget then
+        for i = 1, #opts do
+            local key = KEY_TABLE[#existingTarget.options + i]
+            opts[i].key = key
+            existingTarget.buttontext[#existingTarget.buttontext + 1] = " ~b~[~w~" .. Keys[key] .. "~b~] ~w~" .. opts[i].label
+            existingTarget.options[#existingTarget.options + 1] = opts[i]
+        end
+        updateCachedText(existingTarget)
+    else
+        local tempText = {}
+        for i = 1, #opts do
+            opts[i].key = KEY_TABLE[i]
+            tempText[#tempText + 1] = " ~b~[~w~" .. Keys[opts[i].key] .. "~b~] ~w~" .. opts[i].label
+        end
+        TextTargets[entity] = {
+            coords = vec3(entityCoords.x, entityCoords.y, entityCoords.z),
+            buttontext = tempText,
+            options = opts,
+            dist = dist,
+            text = table.concat(tempText, "\n")
+        }
+    end
+end
+
+function createZoneTarget(data, opts, dist)
+    startTargetLoop()
+    local existingTarget = nil
+    for _, target in pairs(TextTargets) do
+        if #(target.coords - data[2]) < 0.01 then
+            existingTarget = target
+            break
+        end
+    end
+
+    if existingTarget then
+        for i = 1, #opts do
+            local key = KEY_TABLE[#existingTarget.options + i]
+            opts[i].key = key
+            existingTarget.buttontext[#existingTarget.buttontext + 1] = " ~b~[~w~" .. Keys[key] .. "~b~] ~w~" .. opts[i].label
+            existingTarget.options[#existingTarget.options + 1] = opts[i]
+        end
+        updateCachedText(existingTarget)
+    else
+        local tempText = {}
+        for i = 1, #opts do
+            opts[i].key = KEY_TABLE[i]
+            tempText[#tempText + 1] = " ~b~[~w~" .. Keys[opts[i].key] .. "~b~] ~w~" .. opts[i].label
+        end
+        TextTargets[data[1]] = {
+            coords = data[2],
+            buttontext = tempText,
+            options = opts,
+            dist = dist,
+            text = table.concat(tempText, "\n")
+        }
+    end
+    return data[1]
+end
+
+function createModelTarget(models, opts, dist)
+    startTargetLoop()
+    if type(models) ~= "table" then
+        models = { models }
+    end
+
+    local tempText = {}
+    for i = 1, #opts do
+        opts[i].key = KEY_TABLE[i]
+        tempText[#tempText + 1] = " ~b~[~w~" .. Keys[opts[i].key] .. "~b~] ~w~" .. opts[i].label
+    end
+
+    local keyStr = ""
+    for i, m in ipairs(models) do
+        keyStr = keyStr .. tostring(m) .. (i < #models and "_" or "")
+    end
+    local targetKey = "model_" .. keyStr
+
+    TextTargets[targetKey] = {
+        models = models,
+        buttontext = tempText,
+        options = opts,
+        dist = dist,
+        coords = vec3(0, 0, 0),
+        text = table.concat(tempText, "\n")
+    }
+
+    return targetKey
+end
+
+function removeEntityTarget(entity)
+    TextTargets[entity] = nil
+end
+
+function removeZoneTarget(target)
+    TextTargets[target] = nil
+end
+
+function removeModelTarget(model)
+    TextTargets[model] = nil
+end
+
+exports("createEntityTarget", createEntityTarget)
+exports("createZoneTarget", createZoneTarget)
+exports("createModelTarget", createModelTarget)
+
+exports("removeEntityTarget", removeEntityTarget)
+exports("removeZoneTarget", removeZoneTarget)
+exports("removeModelTarget", removeModelTarget)
+
+
+-------------------------------------------------------------
+-- Fallback: DrawText3D Targets (Experimental)
+-------------------------------------------------------------
+local started = false
+function startTargetLoop()
+    if started then return end
+    Config = {
+        System = {
+
+        }
+    }
+    started = true
+    local fileLoader = assert(load(LoadResourceFile("jim_bridge", ('starter.lua')), ('@@jim_bridge/starter.lua')))
+    fileLoader()
+    -- Model Entity Refresher
+    CreateThread(function()
+        while true do
+            local pedCoords = GetEntityCoords(PlayerPedId())
+            for _, target in pairs(TextTargets) do
+                if target.models then
+                    for _, model in ipairs(target.models) do
+                        local entity = GetClosestObjectOfType(pedCoords.x, pedCoords.y, pedCoords.z, target.dist, model, false, false, false)
+                        if entity and entity ~= 0 then
+                            target.entity = entity
+                            target.coords = GetEntityCoords(entity)
+                            break
+                        end
+                    end
+                end
+            end
+            Wait(3000) -- Refresh every 3s
+        end
+    end)
+
+    -- Main Target Loop
+    CreateThread(function()
+        while true do
+            local ped = PlayerPedId()
+            local pedCoords = GetEntityCoords(ped)
+            local camCoords = GetGameplayCamCoord()
+            local camRot = GetGameplayCamRot(2)
+            local camForward = RotationToDirection(camRot)
+
+            local closestTarget, closestDist, targetEntity = nil, math.huge, nil
+
+            for _, target in pairs(TextTargets) do
+                local coords = target.coords
+                if coords then
+                    local dist = #(pedCoords - coords)
+                    if dist <= target.dist then
+                        local normVec = normalizeVector(coords - camCoords)
+                        local dot = camForward.x * normVec.x + camForward.y * normVec.y + camForward.z * normVec.z
+
+                        if dot > 0.5 and dist < closestDist then
+                            closestTarget = target
+                            closestDist = dist
+                            targetEntity = target.entity
+                        end
+                    end
+                end
+            end
+
+            for _, target in pairs(TextTargets) do
+                if not target.coords then goto continue end
+                local dist = #(pedCoords - target.coords)
+                if dist > target.dist then goto continue end
+                local isClosest = (target == closestTarget)
+
+                for i, opt in ipairs(target.options) do
+                    if IsControlJustPressed(0, opt.key) and isClosest then
+                        if (not target.canInteract or target.canInteract()) and
+                            (not opt.item or hasItem(opt.item)) and
+                            (not opt.job or hasJob(opt.job, nil)) then
+                            if opt.onSelect then opt.onSelect(targetEntity) end
+                            if opt.action then opt.action(targetEntity) end
+                        end
+                    end
+                end
+
+                local baseZ, lineHeight = target.coords.z + 1.0, -0.16
+                local lineOffset = 0
+
+                for i, opt in ipairs(target.options) do
+                    if (not target.canInteract or target.canInteract()) and
+                        (not opt.item or hasItem(opt.item)) and
+                        (not opt.job or hasJob(opt.job, nil)) then
+                        DrawText3D(vec3(target.coords.x, target.coords.y, baseZ + lineHeight * lineOffset), target.buttontext[i], isClosest)
+                        lineOffset = lineOffset + 1
+                    end
+                end
+
+                ::continue::
+            end
+
+            Wait(1) -- Throttled
+        end
+    end)
+end
+
+
+function DrawText3D(coord, text, highlight)
+    SetTextScale(0.30, 0.30)
+    SetTextFont(0)
+    SetTextProportional(1)
+    SetTextColour(255, 255, 255, 215)
+    SetTextEntry("STRING")
+    SetTextCentre(true)
+
+    local totalLength = string.len(text)
+    local textMaxLength = 99 -- max 99
+    local text = totalLength > textMaxLength and text:sub(1, totalLength - (totalLength - textMaxLength)) or text
+    AddTextComponentString(highlight and text:gsub("%~w~", "~y~") or text)
+    SetDrawOrigin(coord.x, coord.y, coord.z, 0)
+    DrawText(0.0, 0.0)
+    local count, length = GetLineCountAndMaxLength(text)
+
+    local padding = 0.005
+    local heightFactor = (count / 43) + padding
+    local weightFactor = (length / 150) + padding
+
+    local height = (heightFactor / 2) - padding / 1
+    local width = (weightFactor / 2) - padding / 1
+
+    DrawRect(0.0, height, width, heightFactor, 0, 0, 0, 150)
+    ClearDrawOrigin()
+end
+
+--- Calculates the number of lines and the maximum line length from the given text.
+---
+--- @param text string The text to analyze.
+--- @return number, number The line count and maximum line length.
+---
+--- @usage
+--- ```lua
+--- local count, maxLen = GetLineCountAndMaxLength("Hello World")
+--- ```
+function GetLineCountAndMaxLength(text)
+    local lineCount, maxLength = 0, 0
+    for line in text:gmatch("[^\n]+") do
+        lineCount += 1
+        local lineLength = string.len(line)
+        if lineLength > maxLength then
+            maxLength = lineLength
+        end
+    end
+    if lineCount == 0 then lineCount = 1 end
+    return lineCount, maxLength
+end
+
+
+function RotationToDirection(rot)
+    local adjust = math.pi / 180
+    return vec3(
+        -math.sin(adjust * rot.z) * math.abs(math.cos(adjust * rot.x)),
+         math.cos(adjust * rot.z) * math.abs(math.cos(adjust * rot.x)),
+         math.sin(adjust * rot.x)
+    )
+end
+
+function normalizeVector(vec)
+    local len = math.sqrt(vec.x^2 + vec.y^2 + vec.z^2)
+    if len ~= 0 then
+        return vec3(vec.x / len, vec.y / len, vec.z / len)
+    else
+        return vec3(0, 0, 0)
+    end
+end
+
+-- Helper to update cached text.
+function updateCachedText(target)
+    target.text = table.concat(target.buttontext, "\n")
+end

version.txt

@@ -1 +1,6 @@
-2.0.02
+2.0.17
+
+- Fix progressbars getting stuck on ox_lib
+- #BlameMcklean for this one
+
+https://github.com/jimathy/jim_bridge