How To Write FiveM Scripts Using AI: Complete Developer&#…

Testare uno script gratuito?

Gli script gratuiti vanno bene per controlli rapidi. Per server in produzione, confronta pacchetti server completi o script a pagamento mantenuti, in base al framework e al caso d'uso.

La scrittura di script FiveM ha tradizionalmente richiesto una conoscenza approfondita di Lua, JavaScript e delle API FiveM. Oggi, strumenti di intelligenza artificiale come Claude Code, GitHub Copilot e ChatGPT stanno rivoluzionando il modo in cui gli sviluppatori creano qualsiasi cosa, da Script ESX al complesso sistemi autonomiQuesta guida completa ti mostra esattamente come sfruttare l'intelligenza artificiale per lo sviluppo FiveM, con esempi concreti e flussi di lavoro comprovati.

Perché lo sviluppo FiveM assistito dall'intelligenza artificiale cambia tutto

Lo sviluppo di script FiveM tradizionali richiede la padronanza di più tecnologie contemporaneamente: Lua per la logica lato server, JavaScript per le interfacce NUI, SQL per le operazioni di database e l'esteso Libreria di funzioni native FiveMGli strumenti di intelligenza artificiale condensano mesi di apprendimento in ore di programmazione produttiva.

Impatto reale per i proprietari di server:

• Ridurre il tempo di sviluppo degli script personalizzati del 60-80%
• Genera codice boilerplate all'istante per modelli comuni
• Risolvi problemi di sincronizzazione complessi tra client e server
• Convertire le idee direttamente in prototipi funzionanti

Strumenti di intelligenza artificiale essenziali per lo sviluppo FiveM

Codice Claude (Antropico)

Claude Code eccelle nello sviluppo FiveM perché comprende il contesto di più file ed è in grado di generare strutture di risorse complete. Installazione tramite riga di comando:

pip install claude-code claude-code init --project fivem-resource

Vantaggi specifici di FiveM:

• Genera configurazioni fxmanifest.lua complete
• Comprende i framework ESX, QBCore e VRP
• Crea automaticamente gestori di eventi client/server corrispondenti

Copilota GitHub

Si integra direttamente in VS Code, fornendo suggerimenti in tempo reale durante la digitazione. Particolarmente efficace per:

• Completamento delle chiamate di funzioni native
• Generazione di modelli di gestione degli eventi
• Query di database con completamento automatico

ChatGPT con istruzioni personalizzate

Configura ChatGPT specificamente per FiveM impostando istruzioni personalizzate:

Sei uno sviluppatore di script FiveM. Utilizza sempre: - Sintassi Lua 5.4 per gli script del server - JavaScript moderno per gli script del client - Native FiveM dall'ultima build del gioco - Sicurezza degli eventi adeguata con convalida lato server

Passo dopo passo: creazione del primo script generato dall'intelligenza artificiale

Realizziamo uno script completo per un'officina di veicoli utilizzando Claude Code, illustrando l'intero flusso di lavoro, dall'ideazione alla distribuzione.

Fase 1: definire requisiti chiari

Crea un requisiti.md file:

Requisiti dello script per l'officina di veicoli ## - Framework: ESX Legacy 1.9.0+ - Database: MySQL con oxmysql - Caratteristiche: - Sfoglia i veicoli per categoria - Sistema di test drive con limite di tempo - Opzioni di finanziamento con pagamenti settimanali - Comandi di amministrazione per l'aggiunta di veicoli - Interfaccia utente: NUI moderna con React

Fase 2: Generare la struttura delle risorse

Comando a Claude Codice:

claude-code generate "Crea una risorsa completa per l'officina di veicoli FiveM basata su requirements.md"

Ciò genera:

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/ └── negozio_veicoli.sql

Fase 3: fxmanifest.lua generato dall'IA

fx_version 'cerulean' gioco 'gta5' autore 'YourName' descrizione 'Negozio di veicoli generati dall'IA' versione '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' file { 'ui/index.html', 'ui/style.css', 'ui/script.js' } dipendenze { 'es_extended', 'oxmysql', 'ox_lib' }

Fase 4: implementare le funzionalità principali con l'intelligenza artificiale

Richiedi caricamento veicolo lato server:

-- 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)

Fase 5: implementazione lato client

Richiesta di intelligenza artificiale: "Crea uno showroom lato cliente con controlli della telecamera e anteprima del veicolo"

-- Generato da AI: 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) -- Imposta telecamera 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) -- Richiedi veicoli dal server 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(veicolocorrente, true, true) SetVehicleOnGroundProperly(veicolocorrente) SetVehicleDoorsLocked(veicolocorrente, 2) cb('ok') end)

Tecniche avanzate di intelligenza artificiale per sistemi complessi

Gestione del contesto multi-file

Quando si sviluppano sistemi interconnessi come script telefono, fornisce all'IA un contesto completo:

# Invia più file a Claude Code claude-code analyze --files "server/*.lua,client/*.lua,config.lua" \ --prompt "Aggiungi un sistema di garage che si integra con l'officina esistente"

Prompt specifici del framework

Framework diversi richiedono approcci diversi. Ecco come ottimizzare i prompt di intelligenza artificiale per ciascuno di essi:

Per ESX:

Genera uno script di lavoro ESX con: - Sistema di gradi/classifiche tramite ESX.Jobs - Pagamenti degli stipendi tramite ESX.GetJobs() - Menu del capo con fondi della società - Utilizza i modelli esx_society

Per QBCore:

Crea un sistema di gang QBCore con: - Territori di gang usando PolyZone - Sistema di reputazione con QB.Shared.Gangs - Deposito/archiviazione usando qb-inventory - Gestione delle gang tramite modelli qb-gangmenu

Per Script VRP:

Crea un sistema aziendale VRP utilizzando: - vRP.getUserId per l'identificazione del giocatore - sistema di permessi vRP - metodi di pagamento vRP (giveMoney, tryPayment) - tunnel vRPclient per i callback del client

Generazione dello schema del database

L'intelligenza artificiale eccelle nella creazione di strutture di database ottimizzate:

-- Richiesta AI: "Crea schema MySQL per officina veicoli avanzata con finanziamento" -- Risultato generato: 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` (`categoria`), CHIAVE `idx_price` (`prezzo`) ) MOTORE=InnoDB SET DI CARATTERI PREDEFINITO=utf8mb4; CREA TABELLA SE NON ESISTE `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;

Debug e ottimizzazione con intelligenza artificiale

Prompt di profilazione delle prestazioni

-- Prompt: "Add performance monitoring to this resource"
-- AI generates:

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))

Validazione di sicurezza

L'intelligenza artificiale può identificare e correggere le vulnerabilità della sicurezza:

-- Prompt: "Aggiungi convalida di sicurezza a questo evento client-server" -- Prima (vulnerabile): RegisterNetEvent('giveWeapon', function(weapon) local src = source GiveWeaponToPed(GetPlayerPed(src), weapon, 250, false, true) end) -- Dopo (protetto da IA): local allowedWeapons = { ['WEAPON_PISTOL'] = true, ['WEAPON_COMBATPISTOL'] = true } RegisterNetEvent('giveWeapon', function(weapon) local src = source local xPlayer = ESX.GetPlayerFromId(src) -- Livelli di convalida multipli se non è xPlayer, restituisci end se non è allowedWeapons[weapon], restituisci DropPlayer(src, 'Tentativo di generare un'arma non valida') end se non è xPlayer.hasPermission('weapons.spawn'), restituisci TriggerClientEvent('ox_lib:notify', src, { title = 'Accesso negato', type = 'error' }) end -- Registra l'azione print(('[^3WEAPON^7] %s ha generato %s'):format(xPlayer.getName(), weapon)) xPlayer.addWeapon(weapon, 250) end)

Sviluppo NUI con intelligenza artificiale

La creazione di interfacce moderne per FiveM richiede competenze HTML/CSS/JavaScript. L'intelligenza artificiale semplifica questo processo:

Generazione di componenti React

// Prompt: "Crea un'interfaccia utente per un'officina veicoli React con filtro per categoria" // L'IA genera: 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(azione) { caso 'mostraVeicoli': setVeicoli(dati.veicoli); interruzione; caso 'aggiornaStock': updateVehicleStock(dati.modello, dati.stock); interruzione; } }; const filtratiVeicoli = veicoli.filtro(veicolo => { const corrispondenzeCategoria = CategoriaSelezionata === 'tutti' || veicolo.categoria === CategoriaSelezionata; const corrispondenzeCerca = veicolo.nome.inLowerCase() .includes(ricercaTermine.inLowerCase()); ritorno corrispondenzeCategoria && corrispondenzeCerca; }); 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>Sport motoristici Premium Deluxe</h1>
                <input 
                    type="text"
                    placeholder="Cerca veicoli..."
                    value="{searchTerm}"
                    onchange="{(e)" > setSearchTerm(e.target.value)} className=&quot;search-input&quot; /&gt;
            </div>

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

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

            {veicolo selezionato &amp;&amp; (
                <vehicledetails 
                    vehicle="{selectedVehicle}"
                    onpurchase="{purchaseVehicle}"
                    onclose="{()" > setSelectedVehicle(null)} /&gt; )}
        </div>
    );
};

Insidie comuni dell'intelligenza artificiale e soluzioni

Problema 1: funzioni native obsolete

Problema: L'intelligenza artificiale suggerisce i nativi FiveM deprecati Soluzione: Specifica sempre la build del gioco nel prompt:

Utilizzare solo i nativi FiveM compatibili con la build di gioco 3095+ Sostituisci i nativi deprecati come GetPlayerPed(-1) con PlayerPedId()

Problema 2: perdite di memoria nei loop

Problema: L'intelligenza artificiale crea loop infiniti senza una pulizia adeguata Soluzione: Richiedi modelli di garbage collection:

-- Versione migliorata dall'IA con pulizia locale activeThreads = {} funzione locale createManagedThread(id, func) if activeThreads[id] then -- Elimina il thread esistente activeThreads[id] = false end activeThreads[id] = true CreateThread(function() while activeThreads[id] do func() Wait(0) end end) end -- Pulizia all'arresto della risorsa AddEventHandler('onResourceStop', function(resourceName) if GetCurrentResourceName() == resourceName then for id, _ in pairs(activeThreads) do activeThreads[id] = false end end end)

Problema 3: Problemi di sincronizzazione

Problema: Discordanze di stato client-server Soluzione: Utilizzare l'intelligenza artificiale per generare la gestione dello stato:

-- Prompt: "Crea un gestore di stato sincronizzato per i dati client-server" -- L'intelligenza artificiale genera: -- Gestore di stato lato server 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) -- Gestore di stato lato client local ClientState = {} RegisterNetEvent('stateManager:sync', function(key, value) ClientState[key] = value end) RegisterNetEvent('stateManager:fullSync', function(states) ClientState = states end) -- Richiedi sincronizzazione iniziale CreateThread(function() Wait(1000) TriggerServerEvent('stateManager:requestSync') fine)

Strategie di test e distribuzione

Test automatizzati con intelligenza artificiale

Genera suite di test complete:

-- 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

Monitoraggio delle prestazioni

-- 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)

Integrazione con risorse esistenti

Quando si aggiungono script generati dall'intelligenza artificiale ai server esistenti con Script ESX O script autonomi, seguire questi modelli di integrazione:

Dipendenze dalle risorse

-- 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 di controllo delle migliori pratiche

Prima di distribuire gli script generati dall'intelligenza artificiale:

• [ ] Validazione di sicurezza: Tutti gli eventi client-server convalidati
• [ ] Test delle prestazioni: Nessun ciclo senza Wait()
• [ ] Gestione della memoria: Pulizia corretta durante l'arresto delle risorse
• [ ] Indici del database: Indici sulle colonne interrogate frequentemente
• [ ] Errore Gestione: Blocchi try-catch attorno alle operazioni critiche
• [ ] Registrazione: Registrazione strutturata per il debug
• [ ] Configurazione: Valori di configurazione esternalizzati
• [ ] Documentazione: README con i passaggi di installazione
• [ ] Controllo della versione: Versionamento semantico in fxmanifest
• [ ] Licenza: File di licenza appropriato incluso

Prompt ottimizzato per un agente sviluppatore FiveM

Sei uno sviluppatore FiveM esperto con oltre 5 anni di esperienza in produzione e gestione di server ad alta densità di utenti. La tua competenza abbraccia tutti i principali framework e dai priorità a codice sicuro e performante.

---

Conclusione

Strumenti di intelligenza artificiale come Claude Code trasformano lo sviluppo FiveM da un processo di apprendimento lungo mesi a uno scripting produttivo nel giro di poche ore, consentendo una rapida prototipazione e lo sviluppo di sistemi complessi, mantenendo al contempo standard di sicurezza e prestazioni.

---

Pronto a migliorare il tuo server FiveM? Esplora la nostra collezione curata di script premium o tuffarsi in soluzioni autonome che integrano le risorse generate dall'intelligenza artificiale.