FiveM AI Script Generator

Browser NUI render with simulated messages. In-game behavior has not been verified.

local function openRules()
    if isOpen then return end
    isOpen = true
    SetNuiFocus(true, true)
    SendNUIMessage({
        action = 'open',
        title = Locale.title,
        close = Locale.close,
        hint = Locale.hint,
        rules = Config.Rules,
        layout = Config.Layout.panel,
        theme = Config.Theme.name
    })
end

local function takeFromImpound(player, cid, plate)
    local row = MySQL.single.await('SELECT state FROM player_vehicles WHERE plate = ? AND citizenid = ?', { plate, cid })
    if not row or row.state == GARAGED or inWorld(plate) then return false, 'vehicle_out' end

    local fee = Config.Impound.fee
    local account = Config.PayFrom
    if player.PlayerData.money[account] < fee then account = account == 'bank' and 'cash' or 'bank' end
    if not player.Functions.RemoveMoney(account, fee, 'garage-impound-fee') then return false, 'no_money' end

    -- An impounded vehicle is claimed atomically; a lost "out" one stays out (the busy lock guards it).
    if row.state == IMPOUNDED then
        local changed = MySQL.update.await(
            'UPDATE player_vehicles SET state = ? WHERE plate = ? AND citizenid = ? AND state = ?',
            { OUT, plate, cid, IMPOUNDED }
        )
        if changed ~= 1 then
            player.Functions.AddMoney(account, fee, 'garage-impound-refund')
            return false, 'vehicle_out'
        end
    end
    return true, nil, { fee = fee, account = account }
end

ESX.RegisterServerCallback('rpc_delivery:deliver', function(src, cb)
    local shift = shifts[src]
    local xPlayer = ESX.GetPlayerFromId(src)
    if not shift or not shift.van or not xPlayer then return cb(false) end

    local drop = Config.DropOffs[shift.route[shift.step]]
    if not drop then return cb(false) end

    local ped = GetPlayerPed(src)
    if #(GetEntityCoords(ped) - drop) > Config.DropRadius then return cb(false) end
    if not DoesEntityExist(shift.van) or #(GetEntityCoords(shift.van) - drop) > 40.0 then return cb(false, 'need_van') end
    if os.time() - shift.lastDrop < Config.MinSecondsBetweenDrops then return cb(false, 'too_fast') end

    local pay = Config.PayPerDelivery + math.random(Config.Bonus.min, Config.Bonus.max)
    xPlayer.addAccountMoney(Config.PayAccount, pay, 'Delivery job')

    shift.delivered = shift.delivered + 1
    shift.step = shift.step + 1
    shift.lastDrop = os.time()
    cb(true, pay, Config.DropOffs[shift.route[shift.step]])
end)

-- Only names and counts come from the client; prices are always looked up here.
local catalog, lines, total = prices[shop.catalog], {}, 0
for name, count in pairs(cart) do
    count = math.floor(tonumber(count) or 0)
    local price = type(name) == 'string' and catalog[name]
    if price and count > 0 then
        count = math.min(count, Config.MaxPerItem)
        lines[#lines + 1] = { name = name, count = count }
        total = total + price * count
    end
end
if #lines == 0 then return { ok = false, reason = 'empty_cart' } end

RegisterNetEvent('rpc_admin:server:action', function(action, targetId, reason)
    local src = source
    -- Everything is re-checked here: the NUI and the client are not trusted.
    if not isStaff(src) or not allowedActions[action] or not handlers[action] then return end

    local target = tonumber(targetId)
    if not target or GetPlayerPing(target) == 0 then
        return TriggerClientEvent('rpc_admin:client:notify', src, Locale.player_gone)
    end
    if action == 'kick' then
        reason = type(reason) == 'string' and reason:sub(1, 120) or ''
        if reason == '' then reason = Locale.default_reason end
    end

    local detail = handlers[action](src, target, reason)
    log(src, action, target, detail)
    TriggerClientEvent('rpc_admin:client:notify', src, Locale.done:format(action, GetPlayerName(target) or target))
    TriggerClientEvent('rpc_admin:client:players', src, playerList())
end)

lib.callback.register('rpc_fuel:server:pay', function(src, netId, requested)
    local player = QBCore.Functions.GetPlayer(src)
    local veh, reason = validVehicle(src, netId)
    if not player or not veh then return { ok = false, reason = reason or 'no_vehicle' } end

    local liters = math.floor(tonumber(requested) or 0)
    if liters < 1 then return { ok = false, reason = 'full' } end
    liters = math.min(liters, Config.TankSize)
    local price = liters * Config.PricePerLiter

    for _, account in ipairs(Config.PayFrom) do
        if player.PlayerData.money[account] >= price and player.Functions.RemoveMoney(account, price, 'fuel') then
            return { ok = true, liters = liters, price = price }
        end
    end
    return { ok = false, reason = 'no_money', price = price }
end)

local function update()
    local changed, any = {}, false
    local function put(key, value)
        if last[key] ~= value then changed[key], last[key], any = value, value, true end
    end
    for key, value in pairs(readState()) do put(key, value) end
    -- Hidden in the pause menu and wherever the game hides its own HUD (cutscenes, DisplayHud(false)).
    put('show', enabled and not IsPauseMenuActive() and not IsHudHidden())
    if not ready then
        SendNUIMessage({ action = 'init', settings = SETTINGS, data = last })
    elseif any then
        SendNUIMessage({ action = 'update', data = changed })
    end
end

RegisterNUICallback('saveNote', function(data, cb)
    local text = type(data) == 'table' and type(data.text) == 'string' and data.text or ''
    if not utf8.len(text) or not text:find('%S') then return cb({ ok = false, notes = notes }) end
    local cut = utf8.offset(text, Config.Notes.maxLength + 1)
    if cut then text = text:sub(1, cut - 1) end

    local index = type(data.id) == 'number' and findNote(data.id)
    local note
    if index then
        note = table.remove(notes, index)
    elseif #notes >= Config.Notes.max then
        return cb({ ok = false, error = 'full', notes = notes })
    else
        local id = 0
        for _, other in ipairs(notes) do id = math.max(id, other.id) end
        note = { id = id + 1 }
    end
    note.text = text
    table.insert(notes, 1, note) -- the latest edit first
    save('notes', notes)
    cb({ ok = true, id = note.id, notes = notes })