MSWebX.com
ServiziCosa facciamoConfigurazione di agenti IAClaude Code che funziona sul vostro codice realeIntegrazione IAUn’IA che parte dai vostri dati e dai vostri flussiSiti webSiti web costruiti come i nostriSEO & GEOSEO tecnico che i motori di ricerca e gli assistenti IA sanno leggereCostruire un motore di gioco AAA con l’IA

Awesome Graphics Tools

Tutti gli strumenti graficiDLSS, FSR e XeSS per DayZ e rFactor 2DayZ DLSSWindows · LinuxrFactor 2 DLSSWindows · Linux
Aiuto e supportoContattiMettiti in contatto con il teamFAQRisposte alle domande comuniPagina della chat di supportoFAQ, guide e chat dal vivo in un unico posto
Impostazioni

Aspetto

Accento

Lingua

Benvenuto

Accedi per salvare i preferiti e gestire il tuo account.

Motore di gioco con IA

Costruire un motore di gioco di classe AAA con agenti IA

Stiamo sviluppando FRIENDLY?, un gioco di sopravvivenza su un motore tutto nostro in Rust e Vulkan, pensato per puntare a grafica e netcode di classe AAA. Il motore è scritto da agenti IA sotto guida umana e vincolato a un contratto rigoroso: nulla entra nel merge finché non supera i controlli. Questa pagina mostra il ciclo e le nove regole che lo reggono.

Vista nell’ora d’oro su colline boscose e una valle di montagna, con sole basso e caldo e crinali immersi nella foschia che sfumano in lontananza.

Che cosa stiamo costruendo

FRIENDLY? è un gioco di sopravvivenza in una fase iniziale di sviluppo.

Il motore è scritto in Rust (edizione 2024) direttamente su Vulkan 1.3 o superiore, con shader Slang precompilati, il crate Bevy ECS, Jolt Physics 5.6 e upscaling DLSS e FSR.

Il netcode è server-authoritative, su QUIC con TLS 1.3. Il mondo è una vera valle di circa 6 × 6 km.

Circa il 100 % del codice è scritto da agenti IA sotto guida umana. Il file di progetto del gioco riassume il contratto in una frase: «Strictness is the product.» (Il rigore è il prodotto.)

Il ciclo: piano, decisione, corsia, controlli, merge

Lo stesso ciclo fa girare il nostro motore di gioco e arriva nel vostro repository quando configuriamo i vostri agenti.

  1. Pianificare

    Il piano è del responsabile. Le funzionalità seguono PRD → attività → esecuzione.

  2. Decidere

    Ogni decisione viene scritta come ADR prima che esista il codice.

  3. Corsia

    Una modifica, una corsia. Agenti specialisti, un solo responsabile.

  4. Controlli

    Test e un muro di lint che diventa solo più severo. Un nuovo controllo deve prima fallire una volta.

  5. Merge

    Entra solo il lavoro in verde. Gli agenti non possono allentare le proprie regole.

Nove regole che rendono affidabili gli agenti

Ogni regola ha la sua motivazione e un esempio concreto tratto dal motore.

  1. Il piano appartiene al responsabile

    Regola
    Le persone decidono che cosa si costruisce. Gli agenti lo costruiscono.
    Perché
    Gli agenti eseguono bene un piano. Scegliere il piano è la parte che non si può delegare.
    Esempio
    Le funzionalità seguono PRD → attività → esecuzione, e il piano resta al responsabile.
  2. Prima si decide, per iscritto

    Regola
    Una decisione viene scritta prima che esista il codice.
    Perché
    Una decisione scritta si può verificare e ritirare. Una decisione nascosta in un diff, no.
    Esempio
    Ogni decisione è un ADR, e un nuovo crate richiede il proprio ADR prima di esistere.
  3. Una modifica, una corsia

    Regola
    Ogni modifica ha la propria corsia.
    Perché
    Una modifica piccola e separata è facile da rivedere e facile da scartare.
    Esempio
    Ogni modifica al motore vive nella propria corsia e deve superare i controlli prima del merge.
  4. Controlli prima del merge, e ogni nuovo controllo deve prima fallire

    Regola
    Nulla entra nel merge finché i controlli non passano, e ogni nuovo controllo va visto fallire prima di fidarsene.
    Perché
    Un controllo che non ha mai fallito potrebbe non controllare nulla.
    Esempio
    Il muro di lint è fatto dei gruppi clippy all, pedantic e nursery più circa 70 lint di restrizione. Il codice rilasciato non contiene panic, il codice unsafe vive solo in crate di una lista autorizzata, ogni elemento è documentato e i test vengono per primi.
  5. L’agente non può allentare le proprie regole

    Regola
    Il piano di controllo è in sola lettura per gli agenti.
    Perché
    Una regola che un agente può modificare è solo un suggerimento.
    Esempio
    Regole, hook, agenti e muro di lint sono bloccati in sola lettura. #[allow] è vietato; è ammesso solo #[expect(lint, reason)], con una motivazione scritta. Il muro diventa solo più severo.
  6. La conoscenza vive nei file

    Regola
    Ciò che gli agenti devono sapere è scritto nel repository.
    Perché
    Ciò che vive in una chat sparisce alla sessione successiva. Ciò che vive nel repository viene letto ogni volta.
    Esempio
    Conserviamo la conoscenza del progetto in file del repository che chiamiamo living skills.
  7. Un agente di accoglienza e gli specialisti

    Regola
    Un agente principale riceve il lavoro e lo passa agli specialisti.
    Perché
    Un agente mantiene il quadro d’insieme. Gli specialisti portano la profondità.
    Esempio
    Un agente principale, la «porta», lavora con agenti specialisti per il rendering, il netcode e la revisione del codice Rust.
  8. Gli hook fermano le azioni pericolose

    Regola
    Le azioni pericolose le bloccano gli hook, non le istruzioni.
    Perché
    Un’istruzione è un consiglio. Un hook è un vincolo.
    Esempio
    Nel repository del motore, gli hook fermano le azioni pericolose prima che vengano eseguite.
  9. Nessuna affermazione senza un’esecuzione reale

    Regola
    Un numero si pubblica solo se lo ha prodotto un’esecuzione reale.
    Perché
    Un numero detto a memoria è una voce di corridoio.
    Esempio
    Pubblichiamo solo numeri misurati in esecuzioni reali, con l’hardware indicato. Per questo in questa pagina non ci sono valori di frame rate.

Tre esempi dal motore

Ogni esempio è una funzione del motore e la regola che la sostiene.

Un meteo calibrato su rilevazioni reali

Il modello meteorologico è calibrato sulla rianalisi ERA5 e sulle serie delle stazioni di NCEI e DWD. Governa nuvole volumetriche e usa le posizioni reali di sole e luna.

La regola 9 all’opera: il modello è adattato a rilevazioni misurate, non a occhio. Le nuvole sono la parte ancora incompiuta; vedi più sotto.

Valle innevata vista oltre gli abeti in primo piano, con un crinale boscoso a destra e montagne in lontananza.
Valle innevata nel motore.

Alberi dove crescono alberi veri

La mappa è una vera valle vicino a Ružomberok, in Slovacchia, circa 6 × 6 km di territorio reale. Gli alberi si trovano dove i dati LiDAR della valle, con risoluzione di 1 m, indicano la presenza di alberi.

La scelta di costruire su una vera valle è registrata in un ADR, come ogni decisione (regola 2).

Sole basso che filtra tra alti abeti rossi su un pendio boscoso.
Sole basso tra gli abeti rossi su un versante boscoso nel motore.

Proiettili senza hitscan

Ogni proiettile segue la propria traiettoria sotto l’effetto della gravità, della resistenza dell’aria dipendente dal numero di Mach e del vento. Non esiste hitscan.

In una funzione come questa, «sembra giusto» non dimostra nulla; per questo il metodo richiede controlli ed esecuzioni reali (regole 4 e 9).

Che cosa non è ancora finito

  • Forme delle nuvole. Il modello meteorologico governa nuvole volumetriche, ma le loro forme non sono ancora come vorremmo.
  • Illuminazione globale. In sviluppo, disattivata per impostazione predefinita.
  • Il gioco stesso. È un lavoro in corso in fase iniziale: una piccola scena giocabile con due case, grandi foreste e meteo, e zombie provvisori che dimostrano il rilevamento dei colpi e la balistica in rete.
  • L’obiettivo di classe AAA. È l’obiettivo verso cui lavoriamo. Non affermiamo di essere alla pari con altri motori e non pubblichiamo valori di frame rate.

La configurazione dietro le quinte

La nostra configurazione IA su Claude Code, in numeri: un sistema di 27 agenti specializzati con 73 moduli di conoscenza e cinque server MCP sviluppati in casa.

Nei nostri prodotti non viene rilasciato nulla che non superi PHPStan al livello più alto ed ESLint, Stylelint, TypeScript, Dart e Clippy nella configurazione più rigorosa, più 215 regole personalizzate. Il codice generato non fa eccezione.

Dietro ci sono oltre 20 anni di sviluppo web full stack, più di quattro anni di lavoro con l’IA e un framework web proprio in 18 lingue.

Domande frequenti

Gli agenti IA possono costruire un motore di gioco?

Da noi circa il 100 % del codice è scritto da agenti IA sotto guida umana. Il risultato è un lavoro in corso in fase iniziale, e a mantenerlo corretto è un contratto rigoroso di regole e controlli.

Che cosa rende affidabile il codice scritto dall’IA?

Controlli prima del merge: test, un muro di lint con i gruppi clippy più circa 70 lint di restrizione, e ulteriori verifiche. In più, regole e hook che gli agenti non possono allentare.

Il gioco è finito?

No. Lo stiamo costruendo ed è in fase iniziale. Ciò che manca ancora è elencato sotto «Che cosa non è ancora finito».

Fonti del modello meteorologico: rianalisi ERA5, serie delle stazioni NCEI e serie delle stazioni DWD (dati DWD con licenza CC BY 4.0).

Volete questa disciplina nel vostro repository?

Configuriamo agenti di programmazione IA per i team di sviluppo: un file di regole che l’agente rispetta, protezioni contro le azioni pericolose, controlli di qualità prima di ogni merge, memoria e collegamenti agli strumenti. Tutto viene testato sul vostro repository, documentato e consegnato al vostro team.

Scoprite come configuriamo gli agenti IA