diff --git a/documentation/main_functions/pedTasks.md b/documentation/main_functions/pedTasks.md new file mode 100644 index 0000000..40294cc --- /dev/null +++ b/documentation/main_functions/pedTasks.md @@ -0,0 +1,372 @@ +### pedTasks.lua + +This module wraps the GTA V `Task*` natives so scripted peds can be given orders without having to remember each native's argument list. + +Every task is registered against its ped, so it can be queried and cancelled later. Finite tasks accept an `onComplete` callback and an optional `timeout`, and every function returns `false, "reason"` when it cannot run. + +Coordinates can be passed as a `vector3`, a `vector4`, a plain `{x=,y=,z=}` table, or an entity handle, and are normalised automatically. + +> ⚠️ **The ped must not be frozen.** GTA ignores movement and animation tasks on a frozen +> ped, so create peds with `makePed(..., freeze = false, ...)` or call +> `FreezeEntityPosition(ped, false)` before giving them tasks. + +> ⚠️ **Peds need a weapon and `canShoot`** before `pedTaskShootAt` will make them fire. +> Use `GiveWeaponToPed(ped, `WEAPON_PISTOL`, 50, false, true)` and +> `pedCombatAttributes(ped, { canShoot = true, canAim = true })`. +> GTA also refuses to let a ped fire unless it is already aiming, so pass `aim = true` +> or call `pedTaskAimAt` first. + +#### Movement + +- **pedTaskGoTo(ped, coords, opts)** + + - Sends a ped to walk or run to a set of coordinates. The task completes once the ped is within `opts.radius` of the destination. + - **Options:** `run`, `speed`, `radius`, `heading`, `slide`, `nativeTimeout`, `timeout`, `onComplete`, `onTimeout` + - **Example:** + ```lua + pedTaskGoTo(ped, vec3(455.0, -975.0, 30.0), { + run = true, + onComplete = function(p) print("arrived") end, + }) + ``` + +- **pedTaskGoToEntity(ped, target, opts)** + + - Sends a ped towards an entity for a set time or until it is within range. + - **Options:** `duration`, `distance`, `speed`, `run` + - **Example:** + ```lua + pedTaskGoToEntity(ped, vehicle, { run = true }) + ``` + +- **pedTaskFollow(ped, target, opts)** + + - Makes a ped follow another entity at a set offset. Completes when the ped catches up. + - **Options:** `offset`, `run`, `speed`, `radius`, `nativeTimeout`, `timeout`, `onComplete`, `onTimeout` + - **Example:** + ```lua + pedTaskFollow(ped, targetPed, { offset = vec3(2.0, 0.0, 0.0), run = true }) + ``` + +- **pedTaskWander(ped, coords, opts)** + + - Sends a ped wandering randomly inside a radius. Continuous task, no completion callback. + - **Options:** `radius`, `length`, `betweenWalks` + - **Example:** + ```lua + pedTaskWander(ped, vec3(455.0, -975.0, 30.0), { radius = 10.0 }) + ``` + +- **pedTaskFlee(ped, threat, opts)** + + - Makes a ped run away from a threat, which can be an entity or a set of coordinates. + - **Options:** `distance`, `time`, `timeout`, `onComplete`, `onTimeout` + - **Example:** + ```lua + pedTaskFlee(ped, threatPed, { distance = 60.0 }) + ``` + +- **pedTaskFace(ped, target, opts)** + + - Makes a ped turn to face an entity, or to reach a heading in degrees. + - **Options:** `duration` + - **Example:** + ```lua + pedTaskFace(ped, targetPed) + ``` + +#### Vehicles + +- **pedTaskEnterVehicle(ped, vehicle, opts)** + + - Tells a ped to get into a vehicle. Completes once the ped is seated. + - **Options:** `seat` ("any", "driver", "passenger", "rearLeft", "rearRight"), `speed`, `flag` ("normal", "teleportToVehicle", "carjackFromSeat", "teleportDirectly"), `nativeTimeout`, `timeout`, `onComplete`, `onTimeout` + - **Example:** + ```lua + pedTaskEnterVehicle(ped, vehicle, { seat = "driver" }) + ``` + +- **pedTaskLeaveVehicle(ped, opts)** + + - Tells a ped to get out of a vehicle. Completes once the ped is out. + - **Options:** `vehicle`, `flag` ("normal", "normalSlow", "keepDoorOpen", "teleportOutside", "throwOutOfVehicle", "moveToPassengerFirst"), `timeout`, `onComplete`, `onTimeout` + - **Example:** + ```lua + pedTaskLeaveVehicle(ped) + ``` + +- **pedTaskOpenDoor(ped, vehicle, door, opts)** + + - Tells a ped to open a vehicle door. GTA opens the door nearest to the given seat, so use seat names rather than door names. Asking for "driver" may still open the passenger door if that one is closer. + - **Options:** `speed`, `nativeTimeout`, `timeout`, `onComplete` + - **Example:** + ```lua + pedTaskOpenDoor(ped, vehicle, "passenger") + ``` + +- **pedCloseDoor(vehicle, door, opts)** + + - Closes a vehicle door. GTA has no "close door" task, so this uses the door native directly. + - **Options:** `instant` (snap it shut), `ped` (a ped whose tasks should be cancelled first, so they stop fighting the close) + - **Example:** + ```lua + pedCloseDoor(vehicle, "passenger", { ped = ped }) + ``` + +- **pedTaskDriveTo(ped, vehicle, coords, opts)** + + - Makes a ped drive a vehicle to a set of coordinates. + - **Options:** `speed`, `drivingMode`, `model`, `stopRange`, `timeout`, `onComplete`, `onTimeout` + - **Example:** + ```lua + pedTaskDriveTo(ped, vehicle, vec3(100.0, 200.0, 30.0)) + ``` + +- **pedTaskPark(ped, vehicle, coords, opts)** + + - Makes a ped park a vehicle at a set of coordinates. + - **Options:** `heading`, `mode` ("ignoreHeading", "forward", "reverse"), `radius`, `keepEngineOn`, `timeout`, `onComplete`, `onTimeout` + - **Example:** + ```lua + pedTaskPark(ped, vehicle, vec3(100.0, 200.0, 30.0), { heading = 90.0 }) + ``` + +- **pedTaskChase(ped, target)** + + - Makes a ped in a vehicle chase another entity. Continuous task. + - **Example:** + ```lua + pedTaskChase(ped, targetVehicle) + ``` + +#### Combat + +- **pedTaskCombat(ped, target, opts)** + + - Sends a ped to attack a target. Continuous task. + - **Options:** `style` ("melee" or "ranged") + - **Example:** + ```lua + pedTaskCombat(ped, targetPed, { style = "melee" }) + ``` + +- **pedTaskShootAt(ped, target, opts)** + + - Makes a ped shoot at an entity or a set of coordinates. Continuous task. + - **Options:** `duration`, `pattern` (e.g. "FIRING_PATTERN_FULL_AUTO"), `aim` (aim at the target first, required for the ped to actually fire) + - **Example:** + ```lua + pedTaskShootAt(ped, targetPed, { pattern = "FIRING_PATTERN_BURST_FIRE", aim = true }) + ``` + +- **pedTaskAimAt(ped, target, opts)** + + - Makes a ped aim a weapon at an entity or a set of coordinates. Continuous task. + - **Options:** `duration`, `instant`, `intro` + - **Example:** + ```lua + pedTaskAimAt(ped, vec3(100.0, 200.0, 30.0)) + ``` + +- **pedTaskAccuracy(ped, level)** + + - Sets how accurate a ped is when shooting, `0` is poor and `100` is perfect. + - **Example:** + ```lua + pedTaskAccuracy(ped, 80) + ``` + +- **pedTaskFiringPattern(ped, pattern)** + + - Sets the firing pattern a ped uses, by name or hash. + - **Example:** + ```lua + pedTaskFiringPattern(ped, "FIRING_PATTERN_BURST_FIRE") + ``` + +#### Animation + +- **pedTaskPlayAnim(ped, dict, anim, opts)** + + - Plays an animation on a ped. Completes once the animation has finished, unless `opts.loop` is set. + - **Options:** `blendIn`, `blendOut`, `duration`, `flag` ("looping", "holdLastFrame", "repositionWhenFinished", "notInterruptable", "upperBody"), `playbackRate`, `lock`, `loop`, `timeout`, `onComplete`, `onTimeout` + - **Example:** + ```lua + pedTaskPlayAnim(ped, "amb@world_human_clipboard@male@idle_a", "idle_c") + ``` + +- **pedTaskScenario(ped, scenario, opts)** + + - Starts a scenario on a ped, such as a sitting or leaning animation. Continuous task. + - **Options:** `duration`, `intro` + - **Example:** + ```lua + pedTaskScenario(ped, "WORLD_HUMAN_STAND_IMPATIENT") + ``` + +- **pedTaskLookAt(ped, target, opts)** + + - Makes a ped look at an entity or a set of coordinates. + - **Options:** `duration` + - **Example:** + ```lua + pedTaskLookAt(ped, targetPed, { duration = 3000 }) + ``` + +- **pedTaskRagdoll(ped, duration, opts)** + + - Makes a ped ragdoll for a set duration. + - **Options:** `type` + - **Example:** + ```lua + pedTaskRagdoll(ped, 3000) + ``` + +- **pedTaskStandStill(ped, duration)** + + - Makes a ped stand still for a set duration. + - **Example:** + ```lua + pedTaskStandStill(ped, 3000) + ``` + +#### Behaviour + +- **pedCombatAttributes(ped, opts)** + + - Sets what a ped is allowed to do in combat. The native takes one attribute at a time, so every option provided is applied individually and anything left out is not changed. + - **Options:** any of `alwaysFight`, `canShoot`, `canAim`, `canUseCover`, `aggressive`, `perfectAccuracy`, `disableFleeFromCombat`, `canFlank`, `canCharge` and the rest of the game's combat attributes. + - **Example:** + ```lua + pedCombatAttributes(ped, { alwaysFight = true, canShoot = true, canUseCover = true }) + ``` + +- **pedFleeAttributes(ped, opts)** + + - Sets what a ped is allowed to do when it is fleeing. The native takes a bitmask, so each attribute is applied as `1 << bit`. + - FiveM only documents bit `15` as "force cower", the rest follow the game's flee attribute ordering. Use `pedSetFleeAttribute` if you need a specific bit. + - **Example:** + ```lua + pedFleeAttributes(ped, { [15] = true }) + ``` + +- **pedSetFleeAttribute(ped, bit, enabled)** + + - Sets a single flee attribute on a ped by its bit position. + - **Example:** + ```lua + pedSetFleeAttribute(ped, 15, true) + ``` + +- **pedCombatRange(ped, range)** + + - Sets how far a ped will engage in combat. Accepts "melee", "preferred", "far" or a raw value 0-2. + - **Example:** + ```lua + pedCombatRange(ped, "melee") + ``` + +- **pedCombatAbility(ped, level)** + + - Sets how well a ped fights, from `0` (poor) to `4` (very good). + - **Example:** + ```lua + pedCombatAbility(ped, 3) + ``` + +- **pedCombatMovement(ped, mode)** + + - Sets how a ped moves while fighting. Accepts "hold", "strafe", "advance" or a raw value 0-2. + - **Example:** + ```lua + pedCombatMovement(ped, "strafe") + ``` + +- **pedSetConfigFlag(ped, flag, value)** / **pedGetConfigFlag(ped, flag)** + + - Reads and writes raw ped config flags, for anything the helpers above do not cover. + - **Example:** + ```lua + pedSetConfigFlag(ped, 17, true) -- block non temporary events + ``` + +- **pedState(ped, opts)** + + - Sets a group of general states on a ped. Only the options provided are applied. + - **Options:** `invincible`, `canRagdoll`, `dropsWeapons`, `criticalHits`, `canSwitchWeapon`, `drunk`, `armour`, `health`, `canBeDamaged`, `blocksEvents`, `moveRate`, `density` + - **Example:** + ```lua + pedState(ped, { invincible = true, canRagdoll = false, armour = 100 }) + ``` + +#### Tracking + +- **pedTaskStatus(ped)** + + - Returns the name of the task currently assigned to a ped, or nil. + - **Example:** + ```lua + if pedTaskStatus(ped) == "goTo" then print("on the move") end + ``` + +- **pedTaskIsRunning(ped, name)** + + - Checks if a named task is currently assigned to a ped. + - **Example:** + ```lua + if pedTaskIsRunning(ped, "combat") then print("fighting") end + ``` + +- **pedTaskActive(ped, index)** + + - Checks if a native task is active on a ped by its task index. + - **Example:** + ```lua + if pedTaskActive(ped, pedTaskWanderIndex()) then print("wandering") end + ``` + +- **pedTaskWanderIndex()** + + - Returns the native task index used by the wander task, for use with `pedTaskActive`. + +- **pedTaskCancel(ped, name)** + + - Cancels a task on a ped. GTA has no per task cancellation, so the ped's whole task queue is cleared. The name confirms the task is still the one running first. + - **Example:** + ```lua + pedTaskCancel(ped, "goTo") + ``` + +- **pedTaskClear(ped)** + + - Clears every task on a ped and resets its tracking. + - **Example:** + ```lua + pedTaskClear(ped) + ``` + +- **pedTaskWait(ped, condition, opts)** + + - Waits for a condition to become true for a ped. Useful for chaining tasks together without a separate script thread. + - **Options:** `timeout`, `interval`, `onComplete`, `onTimeout` + - **Example:** + ```lua + pedTaskWait(ped, function(p) return #(GetEntityCoords(p) - target) < 3.0 end, { + onComplete = function(p) pedTaskPlayAnim(p, "dict", "anim") end, + }) + ``` + +#### Chaining tasks together + +```lua +pedTaskGoTo(ped, coords, { + run = true, + onComplete = function(p) + pedTaskPlayAnim(p, "amb@world_human_clipboard@male@idle_a", "idle_c", { + onComplete = function(p2) + pedTaskGoTo(p2, coords2) + end, + }) + end, +}) +``` diff --git a/shared/clientItemAllowlist.lua b/shared/clientItemAllowlist.lua new file mode 100644 index 0000000..8abf7b7 --- /dev/null +++ b/shared/clientItemAllowlist.lua @@ -0,0 +1,105 @@ +-- Client Item Registry +-- --------------------------------------------------------------------------- +-- Dynamically derived list of items a client is allowed to request through the +-- ":server:toggleItem" net event. +-- +-- There is no hardcoded item list. The registry is built once, on first use, +-- from the host resource's own tables: +-- +-- * Crafting - recipe results and ingredients +-- * Stores - shop item definitions ({ name = "item" }) +-- * MaterialRecieve - material returns +-- * createUseableItem() registrations +-- * allowClientItem() calls +-- +-- Because it reads the script's existing definitions, adding a new recipe or +-- shop item automatically makes it grantable. Servers do not need to maintain +-- a second list. +-- +-- Items that are not found in any of the above are refused. +-- --------------------------------------------------------------------------- + +ClientItemAllowlist = ClientItemAllowlist or {} +ClientItemUseable = ClientItemUseable or {} + +local built = false + +--- Default maximum a client may request of a dynamically discovered item. +ClientItemDefaultMax = ClientItemDefaultMax or 10 + +local function add(item, max) + if type(item) ~= "string" or item == "" then return end + if ClientItemAllowlist[item] == nil then + ClientItemAllowlist[item] = tonumber(max) or ClientItemDefaultMax + end +end + +-- Walks a table and treats every string key and string value as a candidate +-- item name. Non-item strings are harmless because the caller still runs +-- doesItemExist() before granting anything. +local function scan(tbl, seen, depth) + if type(tbl) ~= "table" or seen[tbl] then return end + if depth and depth > 12 then return end + seen[tbl] = true + + for k, v in pairs(tbl) do + if type(k) == "string" then add(k) end + if type(v) == "table" then + scan(v, seen, (depth or 0) + 1) + elseif type(v) == "string" then + add(v) + end + end +end + +--- Builds the registry from whatever item tables the host resource exposes. +local function build() + if built then return end + built = true + + local seen = {} + if type(Crafting) == "table" then scan(Crafting, seen, 0) end + if type(Stores) == "table" then scan(Stores, seen, 0) end + if type(MaterialRecieve) == "table" then scan(MaterialRecieve, seen, 0) end + -- Scripts keep item names in Config too (shops, sell tables, processing). + -- This is what makes the registry follow each server's own configuration. + if type(Config) == "table" then scan(Config, seen, 0) end + + for item in pairs(ClientItemUseable) do add(item) end + + local count = 0 + for _ in pairs(ClientItemAllowlist) do count = count + 1 end + debugPrint("^6Bridge^7: ^2Client item registry built for ^3"..tostring(getScript()).."^7 - ^6"..count.."^7 entries") + + if count == 0 then + print("^6Bridge^7: ^3"..tostring(getScript()).." ^1has no item definitions to build a client registry from^7.") + print("^6Bridge^7: ^1Client-side addItem/removeItem grants are disabled for this resource^7.") + print("^6Bridge^7: ^2Call ^3allowClientItem(\"item_name\", maxAmount)^2 if this resource needs them^7.") + end +end + +--- Registers an item as client-grantable. Use this for items that are not +--- covered by the host resource's Crafting/Stores/MaterialRecieve tables. +--- @param item string +--- @param maxAmount number|nil +function allowClientItem(item, maxAmount) + if type(item) ~= "string" or item == "" then return end + ClientItemAllowlist[item] = tonumber(maxAmount) or ClientItemDefaultMax +end + +--- Records an item registered through createUseableItem(). +--- @param item string +function registerClientUseableItem(item) + if type(item) == "string" and item ~= "" then + ClientItemUseable[item] = true + end +end + +--- Returns the maximum amount a client may request, or nil if not allowed. +--- Triggers the one-time build on first call. +--- @param item string +--- @return number|nil +function isClientItemAllowed(item) + if not built then build() end + return ClientItemAllowlist[item] +end diff --git a/shared/itemcontrol.lua b/shared/itemcontrol.lua index 9635f4e..4bb1911 100644 --- a/shared/itemcontrol.lua +++ b/shared/itemcontrol.lua @@ -1489,6 +1489,10 @@ end --- ``` function createUseableItem(item, funct) if doesItemExist(item) then + -- Record it in the client item registry. Items a script makes usable are + -- part of its own item definitions, so this keeps the registry dynamic. + if registerClientUseableItem then registerClientUseableItem(item) end + local useableFunc = { { framework = ESXExport, func = function(item, funct) @@ -1621,78 +1625,78 @@ end --- ``` +local MAX_ITEM_REQUEST = 1000 + RegisterNetEvent(getScript()..":server:toggleItem", function(give, item, amount, newsrc, info, slot, token) local excludeRes = { [QBExport] = true, [ESXExport] = true, [VorpExport] = true, } - local invokingRes = GetInvokingResource() - --debugPrint(GetInvokingResource()) - if invokingRes and invokingRes ~= getScript() and not excludeRes[invokingRes] then + -- A client-triggered net event has no invoking resource. + local invokingRes = GetInvokingResource() + local isClient = (invokingRes == nil or invokingRes == "") + + -- Server-side callers must be this resource or an allowed core. + if not isClient and invokingRes ~= getScript() and not excludeRes[invokingRes] then debugPrint("^1Error^7: ^1Possible exploit^7, ^1vital function was called from an external resource^7") return end - if not doesItemExist(item) then - print("^1Error^7 - ^2Tried to "..(tostring(give) == "true" and "add" or "remove").." '^3"..item.."^7' but it doesn't exist") + if type(item) ~= "string" or not doesItemExist(item) then + print("^1Error^7 - ^2Tried to "..(give and "add" or "remove").." '^3"..tostring(item).."^7' but it doesn't exist") return end - local src = (newsrc and tonumber(newsrc)) or source + local giveItem = (give == true or give == 1) - if (give == true or give == 1) then - if newsrc == nil then -- this must be coming from client this would be blank + -- Resolve the target. Clients may only ever affect themselves. + local src + if isClient then + src = source + if not src or src <= 0 then return end + if newsrc ~= nil then + print("^1Exploit^7: ^3"..tostring(src).." ^1tried to target another player through toggleItem^7") + return + end + else + src = (newsrc and tonumber(newsrc)) or source + end + if not src or src <= 0 then return end + + -- Bound and validate the amount. + local reqAmount = tonumber(amount) or 1 + if reqAmount ~= math.floor(reqAmount) or reqAmount <= 0 or reqAmount > MAX_ITEM_REQUEST then + print("^1Exploit^7: ^3"..tostring(src).." ^1sent an invalid amount to toggleItem^7: "..tostring(amount).." ("..(giveItem and "add" or "remove").." "..item..")") + return + end + + if type(info) ~= "table" then info = nil end + if type(slot) ~= "number" then slot = nil end + + local action = giveItem and "addItem" or "removeItem" + local invName = "" + + if giveItem then + if isClient then + -- Single-use token (10 second expiry). if not checkToken(src, token, "item", item) then return end - end - end - - local action = (tostring(give) == "true" and "addItem" or "removeItem") - local remamount = amount or 1 - if item == nil then return end - - local invName = "" - if give == 0 or give == false then - if remamount < 0 then - print("^1Error^7: ^7src - ^1Client tried to remove a minus number of item ^7- "..item) - return - end - if not hasItem(item, amount or 1, src) then - dupeWarn(src, item, amount) - - else - for i = 1, #InvFunc do - local inv = InvFunc[i] - if isStarted(inv.invName) then - invName = inv.invName - inv.removeItem(src, item, remamount) - break - end + -- Only items this resource actually defines may be granted. + local allowedMax = isClientItemAllowed(item) + if not allowedMax then + print("^1Exploit^7: ^3"..tostring(src).." ^1requested ^3"..item.." ^1via toggleItem but it is not in this resource's item registry^7") + return end - - ----- - -- Fallback for if no inventory found: - ----- - if invName == "" then - print("^4ERROR^7: No Supported Inventory detected - ^2Falling back to core functions") - if isStarted(QBExport) or isStarted(QBXExport) then -- if qbcore or qbxcore, just use core functions - invName = isStarted(QBXExport) and QBXExport or isStarted(QBExport) and QBExport - Core.Functions.GetPlayer(src).Functions.RemoveItem(item, remamount, slot) - - elseif ESX and isStarted(ESXExport) then -- if esx then use core functions - invName = ESX - ESX.GetPlayerFromId(src).removeInventoryItem(item, remamount) - - end - else - debugPrint("^6Bridge^7: ^3"..action.."^7[^6"..invName.."^7] Player(^3"..src.."^7) "..getItemLabel(item).."("..item..") x"..(amount or 1)) + if reqAmount > allowedMax then + print("^1Exploit^7: ^3"..tostring(src).." ^1requested x"..reqAmount.." of ^3"..item.." ^1(max ^3"..allowedMax.."^7)") + return end end - else - local amountToAdd = amount or 1 + + local amountToAdd = reqAmount for i = 1, #InvFunc do local inv = InvFunc[i] if isStarted(inv.invName) then @@ -1713,7 +1717,39 @@ RegisterNetEvent(getScript()..":server:toggleItem", function(give, item, amount, ESX.GetPlayerFromId(src).addInventoryItem(item, amountToAdd) end else - debugPrint("^6Bridge^7: ^3"..action.."^7[^6"..invName.."^7] Player(^3"..src.."^7) "..getItemLabel(item).."("..item..") x"..(amount or 1)) + debugPrint("^6Bridge^7: ^3"..action.."^7[^6"..invName.."^7] Player(^3"..src.."^7) "..getItemLabel(item).."("..item..") x"..amountToAdd) + end + else + if not hasItem(item, reqAmount, src) then + dupeWarn(src, item, amount) + + else + for i = 1, #InvFunc do + local inv = InvFunc[i] + if isStarted(inv.invName) then + invName = inv.invName + inv.removeItem(src, item, reqAmount) + break + end + end + + ----- + -- Fallback for if no inventory found: + ----- + if invName == "" then + print("^4ERROR^7: No Supported Inventory detected - ^2Falling back to core functions") + if isStarted(QBExport) or isStarted(QBXExport) then -- if qbcore or qbxcore, just use core functions + invName = isStarted(QBXExport) and QBXExport or isStarted(QBExport) and QBExport + Core.Functions.GetPlayer(src).Functions.RemoveItem(item, reqAmount, slot) + + elseif ESX and isStarted(ESXExport) then -- if esx then use core functions + invName = ESX + ESX.GetPlayerFromId(src).removeInventoryItem(item, reqAmount) + + end + else + debugPrint("^6Bridge^7: ^3"..action.."^7[^6"..invName.."^7] Player(^3"..src.."^7) "..getItemLabel(item).."("..item..") x"..reqAmount) + end end end end) @@ -1732,8 +1768,11 @@ end) --- dupeWarn(playerId, "health_potion") --- ``` function dupeWarn(src, item, message) - local name = getPlayer(src).name - print(message or "^5DupeWarn^7: "..name.." (^1"..tostring(src).."^7) ^2Tried to remove item '^3"..item.."^7'^2 but it wasn't there^7") + src = tonumber(src) + if not src or src <= 0 then return end + local player = getPlayer(src) + local name = (player and player.name) or ("Unknown("..tostring(src)..")") + print(message or "^5DupeWarn^7: "..name.." (^1"..tostring(src).."^7) ^2Tried to remove item '^3"..tostring(item).."^7'^2 but it wasn't there^7") if not debugMode then DropPlayer(src, name.."("..tostring(src)..") kicked by exploit protection") end diff --git a/starter.lua b/starter.lua index 930ff9d..0361687 100644 --- a/starter.lua +++ b/starter.lua @@ -33,7 +33,7 @@ Exports = { } -- Required variables -debugMode = false +debugMode = true QBInvNew = true @@ -181,6 +181,7 @@ for _, v in pairs({ -- This is a specific load order 'make/loaders.lua', 'make/makeBlip.lua', 'make/makePed.lua', + 'make/pedTasks.lua', 'make/makeProp.lua', 'make/makeVeh.lua', 'make/cameras.lua', @@ -188,6 +189,7 @@ for _, v in pairs({ -- This is a specific load order 'wrapperfunctions.lua', 'polyZone.lua', + 'clientItemAllowlist.lua', 'itemcontrol.lua', 'playerfunctions.lua', 'metaHandlers.lua',