Como Escrever FiveM Scripts Usando IA

Escrever scripts FiveM tradicionalmente exigia conhecimento profundo de Lua, JavaScript e da API FiveM. Hoje, ferramentas de IA como Claude Code, GitHub Copilot e ChatGPT estão mudando a forma como desenvolvedores criam tudo, desde Scripts ESX para complexo sistemas autônomos. Este guia abrangente mostra exatamente como aproveitar a IA para o desenvolvimento FiveM, com exemplos concretos e fluxos de trabalho comprovados.

Por que o desenvolvimento FiveM assistido por IA muda tudo

O desenvolvimento tradicional de scripts FiveM requer o domínio de várias tecnologias simultaneamente: Lua para lógica do lado do servidor, JavaScript para interfaces NUI, SQL para operações de banco de dados e a extensa Biblioteca de funções nativas FiveM. As ferramentas de IA podem acelerar a redação e depuração rotineiras, mas não substituem o aprendizado do tempo de execução FiveM, APIs de frameworks ou limites de segurança.

Impacto real para proprietários de servidores:

• Redija boilerplate rotineiro mais rápido quando os requisitos e dependências forem explícitos
• Gere código clichê instantaneamente para padrões comuns
• Depurar problemas complexos de sincronização entre cliente e servidor
• Converta ideias diretamente em protótipos funcionais

Ferramentas essenciais de IA para desenvolvimento FiveM

Claude Code (Antrópico)

O Claude Code pode revisar o contexto em vários arquivos. Os métodos de instalação mudam, então siga a documentação oficial atual do Claude Code vinculada acima em vez de copiar um comando de pacote de terceiros não verificado.

Vantagens específicas do FiveM:

• Gera configurações completas de fxmanifest.lua
• Compreende as estruturas ESX, QBCore e VRP
• Cria manipuladores de eventos cliente/servidor correspondentes automaticamente

Copiloto GitHub

Integra-se diretamente ao VS Code, fornecendo sugestões em tempo real enquanto você digita. Particularmente eficaz para:

• Concluindo chamadas de função nativa
• Gerando padrões de manipuladores de eventos
• Consultas de banco de dados de preenchimento automático

ChatGPT com instruções personalizadas

Configure o ChatGPT especificamente para o FiveM definindo instruções personalizadas:

Você é um desenvolvedor de scripts FiveM. Sempre use: - Sintaxe Lua 5.4 para scripts de servidor - JavaScript moderno para scripts de cliente - Nativos FiveM da versão mais recente do jogo - Segurança de eventos adequada com validação do lado do servidor

Passo a passo: criando seu primeiro script gerado por IA

Vamos criar um script completo para oficina de veículos usando o Claude Code, demonstrando todo o fluxo de trabalho, do conceito à implantação.

Etapa 1: Definir requisitos claros

Criar um requisitos.md arquivo:

Requisitos do Script de Loja de Veículos ##
- Framework: ESX Legacy 1.9.0+
- Banco de Dados: MySQL com oxmysql
- Funcionalidades:
 - Navegar por veículos por categoria
 - Sistema de test drive com limite de tempo
 - Opções de financiamento com pagamentos semanais
 - Comandos de administrador para adicionar veículos
- UI: NUI moderno com React

Etapa 2: Gerar a Estrutura de Recursos

Comando para Claude Code:

claude-code generate "Criar um recurso completo de oficina de veículos FiveM com base em requirements.md"

Isso gera:

vehicle_shop/
├── fxmanifest.lua
├── config.lua
├── server/
│ ├── main.lua
│ ├── database.lua
│ └── commands.lua
├── client/
│ ├── main.lua
│ ├── showroom.lua
│ └── testdrive.lua
├── ui/
│ ├── index.html
│ ├── style.css
│ └── script.js
└── sql/
 └── vehicle_shop.sql

Etapa 3: fxmanifest.lua gerado por IA

fx_version 'cerulean'
game 'gta5'

author 'YourName'
description 'Loja de Veículos Gerada por IA'
version '1.0.0'

shared_scripts {
 '@es_extended/imports.lua',
 '@ox_lib/init.lua',
 'config.lua'
}

client_scripts {
 'client/*.lua'
}

server_scripts {
 '@oxmysql/lib/MySQL.lua',
 'server/*.lua'
}

ui_page 'ui/index.html'

files {
 'ui/index.html',
 'ui/style.css',
 'ui/script.js'
}

dependencies {
 'es_extended',
 'oxmysql',
 'ox_lib'
}

Etapa 4: Implementar a funcionalidade principal com IA

Prompt para carregamento de veículo do lado do servidor:

-- AI-Generated: server/database.lua
local vehicles = {}

CreateThread(function()
 local result = MySQL.query.await('SELECT * FROM vehicle_shop WHERE stock > 0')
 
 for i = 1, #result do
 local vehicle = result[i]
 vehicles[vehicle.model] = {
 model = vehicle.model,
 name = vehicle.name,
 price = vehicle.price,
 category = vehicle.category,
 stock = vehicle.stock
 }
 end
 
 print(('[^2INFO^7] Loaded %d vehicles from database'):format(#result))
end)

-- Secure server event for purchasing
RegisterNetEvent('vehicle_shop:server:purchaseVehicle', function(vehicleModel, paymentMethod)
 local src = source
 local xPlayer = ESX.GetPlayerFromId(src)
 
 -- Security check
 if not vehicles[vehicleModel] then
 return TriggerClientEvent('ox_lib:notify', src, {
 title = 'Error',
 description = 'Invalid vehicle model',
 type = 'error'
 })
 end
 
 local vehicleData = vehicles[vehicleModel]
 
 -- Payment processing
 if paymentMethod == 'cash' then
 if xPlayer.getMoney() >= vehicleData.price then
 xPlayer.removeMoney(vehicleData.price)
 -- Generate plate and spawn vehicle
 local plate = GeneratePlate()
 
 MySQL.insert('INSERT INTO owned_vehicles (owner, plate, vehicle) VALUES (?, ?, ?)', {
 xPlayer.identifier,
 plate,
 json.encode({model = vehicleModel, plate = plate})
 })
 
 TriggerClientEvent('vehicle_shop:client:spawnVehicle', src, vehicleModel, plate)
 else
 TriggerClientEvent('ox_lib:notify', src, {
 title = 'Insufficient Funds',
 description = ('You need $%d'):format(vehicleData.price),
 type = 'error'
 })
 end
 end
end)

Etapa 5: Implementação do lado do cliente

Prompt de IA: “Crie um showroom do lado do cliente com controles de câmera e pré-visualização do veículo”

-- Gerado por IA: client/showroom.lua
local currentVehicle = nil
local cam = nil
local inShowroom = false

local showroomCoords = vector3(-42.34, -1097.35, 26.42)
local vehicleSpawnCoords = vector4(-47.52, -1097.29, 26.42, 340.0)

function OpenShowroom(category)
 inShowroom = true
 DoScreenFadeOut(500)
 Wait(500)
 
 -- Configurar câmera
 cam = CreateCam('DEFAULT_SCRIPTED_CAMERA', true)
 SetCamCoord(cam, -54.31, -1097.29, 28.42)
 PointCamAtCoord(cam, vehicleSpawnCoords.x, vehicleSpawnCoords.y, vehicleSpawnCoords.z)
 SetCamActive(cam, true)
 RenderScriptCams(true, false, 0, true, false)
 
 -- Solicitar veículos do servidor
 ESX.TriggerServerCallback('vehicle_shop:getVehicles', function(vehicles)
 SendNUIMessage({
 action = 'showVehicles',
 vehicles = vehicles,
 category = category
 })
 SetNuiFocus(true, true)
 end, category)
 
 DoScreenFadeIn(500)
end

RegisterNUICallback('previewVehicle', function(data, cb)
 if currentVehicle then
 DeleteEntity(currentVehicle)
 end
 
 local model = GetHashKey(data.model)
 RequestModel(model)
 
 while not HasModelLoaded(model) do
 Wait(10)
 end
 
 currentVehicle = CreateVehicle(model, vehicleSpawnCoords.x, vehicleSpawnCoords.y, 
 vehicleSpawnCoords.z, vehicleSpawnCoords.w, false, false)
 SetEntityAsMissionEntity(currentVehicle, true, true)
 SetVehicleOnGroundProperly(currentVehicle)
 SetVehicleDoorsLocked(currentVehicle, 2)
 
 cb('ok')
end)

Técnicas avançadas de IA para sistemas complexos

Gerenciamento de contexto de vários arquivos

Ao desenvolver sistemas interconectados como scripts de telefone, forneça à IA um contexto completo:

# Alimente vários arquivos para Claude Code
claude-code analyze --files "server/*.lua,client/*.lua,config.lua" 
 --prompt "Adicione um sistema de garagem que se integre à loja de veículos existente"

Prompt específico da estrutura

Estruturas diferentes exigem abordagens diferentes. Veja como otimizar os prompts de IA para cada uma delas:

Para ESX:

Gerar um script de trabalho ESX com: - Sistema de notas/classificações usando ESX.Jobs - Pagamentos de salários via ESX.GetJobs() - Menu do chefe com fundos da sociedade - Usar padrões esx_society

Para QBCore:

Crie um sistema de gangues QBCore com: - Territórios de gangues usando PolyZone - Sistema de reputação com QB.Shared.Gangs - Estoque/armazenamento usando qb-inventory - Gerenciamento de gangues via padrões qb-gangmenu

Para Scripts VRP:

Crie um sistema de negócios VRP usando: - vRP.getUserId para identificação do jogador - sistema de permissões vRP - métodos de dinheiro vRP (giveMoney, tryPayment) - túnel vRPclient para retornos de chamada do cliente

Geração de Esquema de Banco de Dados

A IA se destaca na criação de estruturas de banco de dados otimizadas:

-- Prompt de IA: "Criar esquema MySQL para loja de veículos avançada com financiamento"
-- Resultado Gerado:

CREATE TABLE IF NOT EXISTS `vehicle_shop_catalog` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `model` varchar(60) NOT NULL,
 `name` varchar(60) NOT NULL,
 `manufacturer` varchar(60) DEFAULT NULL,
 `category` varchar(60) DEFAULT NULL,
 `price` int(11) NOT NULL,
 `stock` int(11) DEFAULT 10,
 `max_speed` int(11) DEFAULT NULL,
 `acceleration` float DEFAULT NULL,
 `braking` float DEFAULT NULL,
 `handling` float DEFAULT NULL,
 PRIMARY KEY (`id`),
 UNIQUE KEY `model` (`model`),
 KEY `idx_category` (`category`),
 KEY `idx_price` (`price`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE IF NOT EXISTS `vehicle_financing` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `identifier` varchar(60) NOT NULL,
 `vehicle_id` int(11) NOT NULL,
 `down_payment` int(11) NOT NULL,
 `weekly_payment` int(11) NOT NULL,
 `weeks_remaining` int(11) NOT NULL,
 `last_payment` timestamp DEFAULT CURRENT_TIMESTAMP,
 `repo_warning_sent` boolean DEFAULT FALSE,
 PRIMARY KEY (`id`),
 KEY `idx_identifier` (`identifier`),
 FOREIGN KEY (`vehicle_id`) REFERENCES `owned_vehicles`(`id`) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

Depuração e otimização com IA

Prompts de perfil de desempenho

-- Prompt: "Adicionar monitoramento de desempenho a este recurso"
-- IA gera:

local performanceStats = {
 events = {},
 queries = {}
}

local function profileEvent(eventName, func)
 return function(...)
 local startTime = GetGameTimer()
 local result = {func(...)}
 local executionTime = GetGameTimer() - startTime
 
 performanceStats.events[eventName] = performanceStats.events[eventName] or {}
 table.insert(performanceStats.events[eventName], executionTime)
 
 if executionTime > 50 then
 print(('[^3WARNING^7] Event %s took %dms'):format(eventName, executionTime))
 end
 
 return table.unpack(result)
 end
end

-- Wrap existing events
RegisterNetEvent('vehicle_shop:server:purchaseVehicle', 
 profileEvent('purchaseVehicle', purchaseVehicleHandler))

Validação de Segurança

A IA pode identificar e corrigir vulnerabilidades de segurança:

-- Prompt: "Adicionar validação de segurança a este evento cliente-servidor"
-- Antes (vulnerável):
RegisterNetEvent('giveWeapon', function(weapon)
 local src = source
 GiveWeaponToPed(GetPlayerPed(src), weapon, 250, false, true)
end)

-- Depois (protegido por IA):
local allowedWeapons = {
 ['WEAPON_PISTOL'] = true,
 ['WEAPON_COMBATPISTOL'] = true
}

RegisterNetEvent('giveWeapon', function(weapon)
 local src = source
 local xPlayer = ESX.GetPlayerFromId(src)
 
 -- Multiple validation layers
 if not xPlayer then return end
 if not allowedWeapons[weapon] then
 return DropPlayer(src, 'Attempted to spawn invalid weapon')
 end
 if not xPlayer.hasPermission('weapons.spawn') then
 return TriggerClientEvent('ox_lib:notify', src, {
 title = 'Access Denied',
 type = 'error'
 })
 end
 
 -- Log the action
 print(('[^3WEAPON^7] %s spawned %s'):format(xPlayer.getName(), weapon))
 
 xPlayer.addWeapon(weapon, 250)
end)

Desenvolvimento NUI com IA

Criar interfaces modernas para o FiveM exige expertise em HTML/CSS/JavaScript. A IA simplifica esse processo:

Geração de componentes React

// Prompt: "Create a React vehicle shop UI with category filtering"
// AI generates:

import React, { useState, useEffect } from 'react';
import './VehicleShop.css';

const VehicleShop = () => {
 const [vehicles, setVehicles] = useState([]);
 const [selectedCategory, setSelectedCategory] = useState('all');
 const [selectedVehicle, setSelectedVehicle] = useState(null);
 const [searchTerm, setSearchTerm] = useState('');

 useEffect(() => {
 window.addEventListener('message', handleMessage);
 return () => window.removeEventListener('message', handleMessage);
 }, []);

 const handleMessage = (event) => {
 const { action, data } = event.data;
 
 switch(action) {
 case 'showVehicles':
 setVehicles(data.vehicles);
 break;
 case 'updateStock':
 updateVehicleStock(data.model, data.stock);
 break;
 }
 };

 const filteredVehicles = vehicles.filter(vehicle => {
 const matchesCategory = selectedCategory === 'all' || 
 vehicle.category === selectedCategory;
 const matchesSearch = vehicle.name.toLowerCase()
 .includes(searchTerm.toLowerCase());
 return matchesCategory && matchesSearch;
 });

 const purchaseVehicle = (vehicle, paymentMethod) => {
 fetch(`https://${GetParentResourceName()}/purchaseVehicle`, {
 method: 'POST',
 headers: { 'Content-Type': 'application/json' },
 body: JSON.stringify({
 model: vehicle.model,
 paymentMethod: paymentMethod
 })
 });
 };

 return (
 <div classname="vehicle-shop-container">
 <div classname="shop-header">
 <h1>Premium Deluxe Motorsport</h1>
 <input 
 type="text"
 placeholder="Pesquisar veículos..."
 value="{searchTerm}"
 onchange="{(e)" > setSearchTerm(e.target.value)}\n className=\"search-input\"\n \/&gt;
 </div>

 <div classname="category-filters">
 {[&#039;todos&#039;, &#039;esportes&#039;, &#039;super&#039;, &#039;sedan&#039;, &#039;suv&#039;, &#039;motocicleta&#039;].map(cat =&gt; (
 <button
 key="{cat}"
 classname="{`category-btn" ${selectedcategory ="==" cat ? 'active' : ''}`}
 onclick="{()" > setSelectedCategory(cat)}\n &gt;\n {cat.toUpperCase()}
 </button>
 ))}
 </div>

 <div classname="vehicles-grid">
 {filteredVehicles.map(veículo =&gt; (
 <vehiclecard 
 key="{vehicle.model}"
 vehicle="{vehicle}"
 onselect="{()" > setSelectedVehicle(vehicle)}\n \/&gt;\n ))}
 </div>

 {veículo selecionado &amp;&amp; (
 <vehicledetails 
 vehicle="{selectedVehicle}"
 onpurchase="{purchaseVehicle}"
 onclose="{()" > setSelectedVehicle(null)}\n \/&gt;\n )}
 </div>
 );
};

Armadilhas comuns de IA e soluções

Problema 1: Funções Nativas Desatualizadas

Emitir: A IA sugere nativos FiveM obsoletos Solução: Sempre especifique a versão do jogo no seu prompt:

Use apenas nativos FiveM compatíveis com a versão do jogo 3095+ Substitua nativos obsoletos como GetPlayerPed(-1) por PlayerPedId()

Problema 2: Vazamentos de memória em loops

Emitir: A IA cria loops infinitos sem limpeza adequada Solução: Solicitar padrões de coleta de lixo:

-- Versão melhorada por IA com limpeza
local activeThreads = {}

local function createManagedThread(id, func)
 if activeThreads[id] then
 -- Kill existing thread
 activeThreads[id] = false
 end
 
 activeThreads[id] = true
 
 CreateThread(function()
 while activeThreads[id] do
 func()
 Wait(0)
 end
 end)
end

-- Cleanup on resource stop
AddEventHandler('onResourceStop', function(resourceName)
 if GetCurrentResourceName() == resourceName then
 for id, _ in pairs(activeThreads) do
 activeThreads[id] = false
 end
 end
end)

Problema 3: Problemas de sincronização

Emitir: Incompatibilidades de estado cliente-servidor Solução: Use IA para gerar gerenciamento de estado:

-- Prompt: "Criar um gerenciador de estado sincronizado para dados cliente-servidor"
-- IA gera:

-- Gerenciador de estado do lado do servidor
local StateManager = {}
StateManager.states = {}

function StateManager:set(key, value)
 self.states[key] = value
 TriggerClientEvent('stateManager:sync', -1, key, value)
end

function StateManager:get(key)
 return self.states[key]
end

RegisterNetEvent('stateManager:requestSync', function()
 local src = source
 TriggerClientEvent('stateManager:fullSync', src, StateManager.states)
end)

-- Gerenciador de estado do lado do cliente
local ClientState = {}

RegisterNetEvent('stateManager:sync', function(key, value)
 ClientState[key] = value
end)

RegisterNetEvent('stateManager:fullSync', function(states)
 ClientState = states
end)

-- Solicitar sincronização inicial
CreateThread(function()
 Wait(1000)
 TriggerServerEvent('stateManager:requestSync')
end)

Estratégias de teste e implantação

Testes automatizados com IA

Gere conjuntos de testes abrangentes:

-- Prompt: "Create unit tests for the vehicle shop purchase function"
-- AI generates:

local function runTests()
 local testResults = {
 passed = 0,
 failed = 0,
 tests = {}
 }

 -- Test 1: Valid purchase with sufficient funds
 local function testValidPurchase()
 local mockPlayer = {
 identifier = 'test_player_1',
 money = 50000,
 getMoney = function() return 50000 end,
 removeMoney = function(amount) 
 mockPlayer.money = mockPlayer.money - amount
 return true
 end
 }
 
 local result = attemptPurchase(mockPlayer, 'adder', 45000)
 assert(result.success == true, 'Valid purchase should succeed')
 assert(mockPlayer.money == 5000, 'Money should be deducted correctly')
 
 return true
 end

 -- Test 2: Purchase with insufficient funds
 local function testInsufficientFunds()
 local mockPlayer = {
 identifier = 'test_player_2',
 money = 1000,
 getMoney = function() return 1000 end
 }
 
 local result = attemptPurchase(mockPlayer, 'adder', 45000)
 assert(result.success == false, 'Purchase should fail with insufficient funds')
 assert(result.error == 'insufficient_funds', 'Should return correct error code')
 
 return true
 end

 -- Run all tests
 local tests = {
 {name = 'Valid Purchase', func = testValidPurchase},
 {name = 'Insufficient Funds', func = testInsufficientFunds}
 }

 for _, test in ipairs(tests) do
 local success, error = pcall(test.func)
 if success then
 testResults.passed = testResults.passed + 1
 print(('[^2✓^7] %s passed'):format(test.name))
 else
 testResults.failed = testResults.failed + 1
 print(('[^1✗^7] %s failed: %s'):format(test.name, error))
 end
 
 table.insert(testResults.tests, {
 name = test.name,
 passed = success,
 error = error
 })
 end

 return testResults
end

-- Run tests on resource start in development mode
if Config.Debug then
 CreateThread(function()
 Wait(1000)
 local results = runTests()
 print(('Tests completed: %d passed, %d failed'):format(
 results.passed, results.failed
 ))
 end)
end

Monitoramento de desempenho

-- Prompt: "Add performance monitoring for production deployment"
-- AI generates:

local Monitor = {
 metrics = {
 eventCalls = {},
 dbQueries = {},
 memoryUsage = {}
 }
}

function Monitor:trackEvent(eventName)
 self.metrics.eventCalls[eventName] = (self.metrics.eventCalls[eventName] or 0) + 1
end

function Monitor:trackQuery(queryType, duration)
 table.insert(self.metrics.dbQueries, {
 type = queryType,
 duration = duration,
 timestamp = os.time()
 })
end

function Monitor:getReport()
 local report = {
 uptime = GetGameTimer() / 1000,
 totalEvents = 0,
 averageQueryTime = 0,
 memoryUsage = collectgarbage('count')
 }
 
 for _, count in pairs(self.metrics.eventCalls) do
 report.totalEvents = report.totalEvents + count
 end
 
 if #self.metrics.dbQueries > 0 then
 local totalTime = 0
 for _, query in ipairs(self.metrics.dbQueries) do
 totalTime = totalTime + query.duration
 end
 report.averageQueryTime = totalTime / #self.metrics.dbQueries
 end
 
 return report
end

-- Export metrics endpoint
RegisterCommand('metrics', function(source)
 if source == 0 or IsPlayerAceAllowed(source, 'admin.metrics') then
 print(json.encode(Monitor:getReport(), {indent = true}))
 end
end, true)

Integração com recursos existentes

Ao adicionar scripts gerados por IA a servidores existentes com Scripts ESX ou scripts autônomos, siga estes padrões de integração:

Dependências de recursos

-- config.lua - AI-generated configuration for compatibility
Config = {}

-- Framework detection
Config.Framework = nil

CreateThread(function()
 if GetResourceState('es_extended') == 'started' then
 Config.Framework = 'esx'
 ESX = exports['es_extended']:getSharedObject()
 elseif GetResourceState('qb-core') == 'started' then
 Config.Framework = 'qbcore'
 QBCore = exports['qb-core']:GetCoreObject()
 else
 Config.Framework = 'standalone'
 end
 
 print(('[^2INFO^7] Detected framework: %s'):format(Config.Framework))
end)

-- Framework-agnostic money functions
function GetPlayerMoney(source)
 if Config.Framework == 'esx' then
 local xPlayer = ESX.GetPlayerFromId(source)
 return xPlayer.getMoney()
 elseif Config.Framework == 'qbcore' then
 local Player = QBCore.Functions.GetPlayer(source)
 return Player.PlayerData.money.cash
 else
 -- Standalone implementation
 return exports['your_economy']:GetMoney(source)
 end
end

Lista de verificação de melhores práticas

Antes de implantar scripts gerados por IA:

• [ ] Validação de Segurança: Todos os eventos cliente-servidor validados
• [ ] Teste de desempenho: Nenhum loop sem Wait()
• [ ] Gerenciamento de memória: Limpeza adequada na parada de recursos
• [ ] Índices de banco de dados: Índices em colunas consultadas com frequência
• [ ] Erro Manuseio:Blocos try-catch em torno de operações críticas
• [ ] Registro: Registro estruturado para depuração
• [ ] Configuração: Valores de configuração externalizados
• [ ] Documentação: LEIA-ME com as etapas de instalação
• [ ] Controle de versão:Versão semântica em fxmanifest
• [ ] Licença: Arquivo de licença apropriado incluído

Prompt otimizado para um agente de desenvolvedor FiveM

Você é um desenvolvedor FiveM experiente com mais de 5 anos de experiência em produção, gerenciando servidores de alta densidade. Sua expertise abrange todos os principais frameworks e você prioriza código seguro e de alto desempenho.

---

Conclusão

Ferramentas de IA como o Claude Code transformam o desenvolvimento do FiveM de um processo de aprendizado que dura meses em um script produtivo em poucas horas, permitindo prototipagem rápida e desenvolvimento de sistemas complexos, mantendo os padrões de segurança e desempenho.

---

Pronto para melhorar o servidor? Explore nossa coleção curada de scripts premium ou revisão soluções autônomas que complementam seus recursos gerados por IA.

IA para próximos passos com FiveM

• Como usar IA com FiveM
• Escreva scripts FiveM usando IA
• Prompts do ChatGPT para FiveM
• Traduza scripts FiveM com IA
• Ferramentas de desenvolvimento FiveM
• Roteiros FiveM, Scripts ESX, Scripts QBCore, e Scripts QBOX

Forneça o contexto correto à IA sem expor segredos

Indique se o recurso utiliza ESX, QBCore, QBOX, ox_lib, oxmysql, NUI ou código standalone, e peça ao ferramenta para listar todas as dependências que assume. Não cole chaves de licença, senhas de banco de dados, URLs de webhooks, dados de clientes ou código de servidor privado em um serviço a menos que os termos de manipulação de dados desse serviço e sua permissão para compartilhar esse código sejam claros.

Reveja manualmente os manipuladores de eventos gerados, callbacks, valores fornecidos pelo jogador, verificações de permissão, lógica de recompensa e escritas no banco de dados. Teste as alterações em um ambiente de staging com permissões de jogador normal, bem como permissões de administrador, inspecione os logs do cliente e do servidor, e mantenha uma cópia de rollback antes do deploy em produção.