Technische Samenvatting: Kennisgeconditioneerde, Single-Pass LLM-synthese van Uitvoerbare Unity Game Scènes

Probleemstelling

Huidige demonstraties van Large Language Models (LLMs) die Unity C#-gamescripts genereren, leunen zwaar op iteratieve reparatielussen, waarbij modellen code regenereren totdat deze compileert. Deze workflow verzwakt de intrinsieke parametrische kennis van het model door de corrigerende kracht van de reparatielus of menselijke interventie. Bovendien missen bestaande evaluaties vaak stabiele genrelabels of vrije natuurlijke taal, wat de reproduceerbaarheid ontbeert die vereist is voor cumulatief onderzoek.

Dit paper adresseert de vraag: Wat is de intrinsieke capaciteitscel van single-pass LLM-generatie van uitvoerbare game-artefacten wanneer geen menselijke feedback of iteratieve reparatie is toegestaan? De studie isoleert de opgeslagen kennis van het model van de domeinexpertise van de praktijkbeoefenaar, waarbij de compiler wordt behandeld als een strikte, objectieve poortwachter. Als een script niet in de eerste pass compileert, is dat een falen dat uitsluitend aan het model kan worden toegeschreven.

Methodologie

Experimenteel Ontwerp

De studie evalueert de generatie van Goal Playable Concepts (GPCs)—speelbare tegenhangers van 26 specifieke gameplay-ontwerppatronen gedefinieerd door Björk en Holopainen. Deze patronen dienen als een theoretisch gefundeerde, reproduceerbare vocabulaire voor game-ontwerp, ter vervanging van instabiele genrelabels.

• Schaal: 10.400 generatie-records.
• Modellen: Vier open-weight modellen uit verschillende families (7B-Qwen2.5, 16B-DeepSeek, 22B-Codestral, 30B-Qwen3).
• Generatiemodi:
  • Editor-stijl: Scripts die scènes bouwen tijdens de edit-tijd met behulp van UnityEditor API's.
  • Runtime-builder: Scripts die scènes programmatisch construeren tijdens de play-tijd met behulp van MonoBehaviour (alleen getest op het 30B-model).
• Conditioneringsniveaus: Vier niveaus van Intermediate Representation (IR) conditionering:
  • Geen Schema: Directe generatie vanuit de patroonbeschrijving.
  • Met Schema (Free/Min/Full): Generatie van eerst een JSON IR, gevolgd door C# code-generatie. De striktheid van het schema varieert van top-level veldnamen tot volledige velddefinities en restricties.
• Procedure: Elk record is een enkele generatiepass. Het gegenereerde C#-script wordt gecompileerd binnen een vooraf gebouwd Unity-project. Er wordt geen compilerfout teruggekoppeld naar het model.

Constructie van de Falingstaxonomie

De auteurs categoriseren de 99 onderscheidende C# compilerfoutcodes die werden waargenomen over 90.673 foutenoccurrences in twee wederzijds uitsluitende klassen:

1. Grounding Errors (18 codes): Domeinspecifieke fouten die kennis van de Unity-engine vereisen om op te lossen. Dit betreft verzonnen of verkeerd gebruikte Unity-types, namespaces en API's (bijv. CS0246: type of namespace niet gevonden; CS1061: geen dergelijk lid).
2. Hygiene Errors (81 codes): Domeinonafhankelijke structurele defecten die zonder Unity-kennis te diagnosticeren zijn. Dit omvat syntactische fouten zoals ontbrekende puntkomma's, niet-gesloten accolades en niet-gedeclareerde variabelen (bijv. CS1003, CS1002).

Belangrijkste Resultaten

1. Universele Compilatiefout

Geen enkel gegenereerd C#-script compileerde tot een uitvoerbare scène in de 10.400 records. Dit uniforme falen elimineert survivorship bias, waardoor een exhaustieve census van faalmodi mogelijk is.

2. Foutcompositie en Modelgedrag

• Verdeling Grounding vs. Hygiene: De splitsing tussen Grounding en Hygiene fouten varieert significant per doelpatroon en modelconfiguratie.
  • Hoge Grounding Patronen: Concepten gekoppeld aan Unity's perceptie- en physics-API's (bijv. Stealth, Rescue, Exploration, Survive) falen voornamelijk met Grounding errors. Het model verzint niet-bestaande engine-componenten (bijv. GuardAI, Pathfinding) om de design-semantiek te voldoen.
  • Hoge Hygiene Patronen: Concepten die reduceerbaar zijn tot algemene staatmanipulatie (bijv. Capture, Collection) falen voornamelijk met Hygiene errors. De gegenereerde scripts storten structureel in (syntactische fouten) voordat ze de laag bereiken waar Unity-kennis wordt getest.
• Modelschaal en Identiteit: Het vergroten van de modelgrootte (van 7B naar 30B) levert geen uitvoerbare scène op. In plaats daarvan verandert het de compositie van de fouten. Grotere modellen (zoals 3B-Qwen3-Ed) bereiken de compiler vaker en falen op de Grounding-laag (ontbrekende API-kennis), terwijl kleinere modellen vaak falen bij de format-gate (sanitizer rejectie) of de Hygiene-laag (syntaxis).
• Effecten van IR-conditionering: Striktere schema-conditionering lost fouten niet op, maar verplaatst ze.
  • Voor kleinere modellen (7B, 16B) verhogen striktere schema's de sanitizer-rejectie ratio (tot 89%), waardoor code de compiler niet bereikt.
  • Voor grotere modellen (22B, 30B-Ed) verbeteren striktere schema's de format-compliance, waardoor meer records de compiler bereiken. Echter, dit verschuift het foutprofiel naar Grounding errors, aangezien het model wordt gedwongen om syntactisch geldige code te produceren die nog steeds onjuiste engine-referenties mist.
• Generatiemodus: Het schakelen van Editor-stijl naar Runtime-builder modus (getest op 30B) herverdeelt de fouten maar elimineert Grounding-fouten niet. In sommige gevallen (bijv. Collection) introduceerde de Runtime-modus ernstige Hygiene-pieken zonder de compilatiesucces te verbeteren.

3. Per-Patroon Foutprofielen

De studie stelt een empirische ordening vast van de 26 doelpatronen op basis van de engine-kennis die hun instantiatie vereist.

• Stealth (Grounding aandeel ~0.98 in sommige configuraties) faalt primair omdat het model engine-specifieke types verzint voor visie en detectie die niet bestaan.
• Capture (Grounding aandeel ~0.0 in sommige configuraties) faalt primair door structurele syntactische fouten, aangezien de logica kan worden uitgedrukt in pure C# zonder specifieke engine API's.

Betekenis en Claims

Het paper claimt de eerste systematische census te bieden van LLM-faalmodi in engine-gekoppelde code-generatie op het niveau van individuele compiler-diagnostiek. De belangrijkste bijdragen zijn:

1. Een Grounding/Hygiene Taxonomie: Een formeel onderscheid tussen domeinspecifieke (engine-kennis) en domeinonafhankelijke (structurele) fouten, afgeleid van 90.673 geobserveerde compiler-diagnostieken.
2. Een Error-Driven Lens op Design Complexiteit: De studie demonstreert dat de semantische complexiteit van een gameplay-concept empirisch geordend kan worden door het type fout dat het oproept. Patronen die specifieke engine API's vereisen (perceptie, physics), leggen het gebrek aan parametrische engine-kennis van het model bloot, terwijl patronen die vertrouwen op algemene logica structurele generatiezwakheden blootleggen.
3. De Single-Pass Ceiling: De bevindingen stellen vast dat, binnen de 7B–30B open-weight tier, de bottleneck voor single-pass generatie ontbrekende engine-specifieke kennis is, en niet modelgrootte, generatiemodus of structurele conditionering.
4. Praktische Diagnostiek voor Designers: De foutprofielen bieden een concrete gids voor game designers en ontwikkelaars. Ze geven aan welke gameplay-concepten (bijv. Stealth) momenteel buiten het bereik liggen van unaided single-pass LLM-generatie en externe engine-kennis ondersteuning vereisen (bijv. retrieval-augmented generation of fine-tuning), versus welke concepten (bijv. Capture) geschikt kunnen zijn voor syntactische post-processing of grammar-guided decoding.

De auteurs concluderen dat hoewel iteratieve reparatielussen in de praktijk productief zijn, zij de intrinsieke beperkingen van huidige LLM's maskeren. De single-pass evaluatie onthult dat, zonder externe injectie van engine-kennis, huidige modellen geen uitvoerbare Unity-scènes kunnen synthetiseren, ongeacht de complexiteit van het designpatroon of de grootte van het model.