MultiGen: Level-Design for Editable Multiplayer Worlds in Diffusion Game Engines

Het paper introduceert MultiGen, een diffusion game engine die door het gebruik van een persistente externe geheugenmodule en een decompositie in geheugen, observatie en dynamiek, gebruikers directe controle over de wereldstructuur biedt en consistente multiplayer-interacties mogelijk maakt.

De kern

🎮 MultiGen: De Speelbaan die Zichzelf Onthoudt

Stel je voor dat je een video game speelt die volledig door een kunstmatige intelligentie (AI) wordt bedacht terwijl je speelt. Dit is wat "wereldmodellen" doen: ze kijken naar wat je net hebt gedaan en bedenken het volgende beeld.

Maar tot nu toe hadden deze AI's een groot probleem: ze hadden een korte geheugenspanne.

• Het oude probleem: Stel je voor dat je een verhaal vertelt, maar je vergeet na elke zin wat je in de eerste zin hebt gezegd. Als je in een game een deur openmaakt, vergeet de AI na een tijdje misschien dat die deur openstaat. Of als twee spelers in een game tegen elkaar vechten, ziet de ene speler misschien dat de ander doodgaat, terwijl de andere speler denkt dat die nog leeft. De wereld is niet consistent.

MultiGen lost dit op door de AI een extern geheugen te geven. Het is alsof we de AI niet alleen een brein geven, maar ook een notitieblok en een plattegrond die ze altijd kunnen raadplegen.

Hier is hoe het werkt, opgedeeld in drie simpele onderdelen:

1. Het Notitieblok (Het Externe Geheugen) 📝

In plaats van dat de AI alles in haar hoofd moet houden (wat snel vol raakt), houden we een apart notitieblok bij.

• Wat staat erop? Een simpele plattegrond van het niveau (waar zijn de muren?) en een lijstje met waar alle spelers zich bevinden.
• Waarom is dit cool? Zelfs als de AI een uur lang speelt, kan ze altijd terugkijken op dit notitieblok. Ze weet dus altijd zeker: "Ja, die muur staat hier, en die speler is daar." Dit voorkomt dat de wereld "dwaalt" of onzin begint te genereren.

2. De Architect (De Ontwerper) 🏗️

Met dit notitieblok kunnen mensen nu zelf levels ontwerpen!

• Hoe werkt het? Je tekent een simpele lijnplaatje (een plattegrond) op een vel papier. Je hoeft geen ingewikkelde 3D-modellen te maken.
• Het resultaat: De AI kijkt naar jouw simpele lijntjes en bouwt daar een prachtige, realistische game-wereld omheen. Je kunt de lijntjes zelfs aanpassen terwijl je speelt, en de AI past de wereld direct aan. Het is alsof je een huis bouwt met LEGO-blokken, maar de muren en meubels worden door de AI in detail getekend.

3. De Groepsdynamiek (Meerdere Spelers) 🤝

Dit is misschien wel het meest indrukwekkende deel: Multiplayer.

• Het oude probleem: In oude systemen speelde elke speler zijn eigen "droom". Als Speler A Speler B doodde, zag Speler B misschien niets, omdat die in zijn eigen droom leefde.
• Het nieuwe systeem: Alle spelers kijken naar één en hetzelfde notitieblok.
  • Als Speler A een kogel schiet, schrijft hij dit in het notitieblok.
  • Speler B kijkt naar hetzelfde notitieblok, ziet de kogel en ziet Speler A vallen.
  • Het is alsof een groep vrienden samen een verhaal bedenkt, maar ze hebben allemaal dezelfde script. Niemand vergeten wat er is gebeurd.

🌟 De Vergelijking: De Regisseur en de Toneelmeester

Om het nog duidelijker te maken, laten we het vergelijken met een toneelstuk:

• De Oude AI (Zonder geheugen): De regisseur probeert het hele toneelstuk in zijn hoofd te onthouden. Na een paar scènes vergeet hij waar de kast stond of welke acteur er doodging. De acteurs beginnen dan te improviseren en het verhaal loopt uit de hand.
• MultiGen (Met geheugen):
  • De Regisseur (De AI) is gespecialiseerd in het maken van mooie beelden (de acteurs, de kleding, de gezichten).
  • De Toneelmeester (Het Externe Geheugen) houdt een lijst bij: "De kast staat links, Speler A is hier, Speler B is daar."
  • De Regisseur kijkt constant naar de lijst van de Toneelmeester. Zelfs als het toneelstuk uren duurt, weten ze precies waar alles staat. Als de Toneelmeester de lijst aanpast (bijvoorbeeld: "Speler B is nu dood"), past de Regisseur het beeld direct aan.

Waarom is dit belangrijk?

1. Bewerkbaarheid: Gameontwerpers kunnen nu snel levels maken door alleen een simpele tekening te maken, in plaats van uren te werken aan complexe 3D-modellen.
2. Echte Multiplayer: Het maakt het mogelijk om echte, consistente multiplayer games te spelen die door AI worden gegenereerd. Iedereen ziet hetzelfde, en wat jij doet, heeft direct invloed op wat je vriend ziet.
3. Geen Dwaalpaden: De game blijft logisch. De muren verdwijnen niet zomaar en de regels blijven gelden, hoe lang je ook speelt.

Kortom: MultiGen geeft de AI een "herinnering" en een "plattegrond", zodat ze niet alleen mooie beelden kan maken, maar ook een samenhangende, bewerkbare en eerlijke wereld kan creëren voor iedereen die erin speelt.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het paper "MultiGen: Level-Design for Editable Multiplayer Worlds in Diffusion Game Engines" in het Nederlands.

Probleemstelling

Bestaande video-wereldmodellen (video world models) tonen veelbelovende resultaten voor interactieve simulatie en entertainment, maar ze kampen met twee fundamentele beperkingen op het gebied van interactiviteit:

1. Gebrek aan controle en reproduceerbaarheid: De meeste systemen genereren de wereld "on the fly" met slechts een impliciete interne staat (vaak een beperkt venster van vorige frames). Dit maakt het moeilijk voor gebruikers om de structuur van de omgeving vooraf te specificeren of te bewerken. Langdurige rollouts (gesimuleerde sessies) worden vaak oncontroleerbaar, moeilijk te reproduceren en wijken af van de intentie van de gebruiker.
2. Moeilijkheden met gedeelde werelden: Huidige systemen zijn overwegend single-user ervaringen. Het is lastig om een gedeelde wereld te creëren waarin meerdere spelers betrouwbaar kunnen interageren via een gemeenschappelijke onderliggende staat, omdat de staat niet expliciet wordt vastgehouden buiten het contextvenster van het model.

De auteurs stellen dat er een ontbrekend primitief nodig is: een expliciete externe geheugenmodule die bestaat buiten het contextvenster van het model, wordt bijgewerkt door gebruikersacties en dient als gedeelde staat voor meerdere agenten.

Methodologie

MultiGen introduceert een modulair diffusion game engine dat de generatie decomposeert in drie gespecialiseerde modules, in plaats van te vertrouwen op één enkel netwerk dat zowel de staat beheert als de beelden genereert. Het systeem gebruikt Doom als testomgeving.

De architectuur bestaat uit drie kerncomponenten:

1. Memory Module (Geheugenmodule):

   • Bevat een expliciete externe staat die persistent is en onafhankelijk werkt van het contextvenster van het diffusiemodel.
   • Map ($M$): Een statische, top-down 2D kaart gedefinieerd door vertices en lijnsegmenten (muren). Dit fungeert als een blauwdruk die de globale geometrie vastlegt en voorkomt dat het model hallucineert over de lay-out tijdens lange sessies.
   • Pose ($p_t$): De positie en oriëntatie van de speler(s) in de kaart.
   • Context: Een venster van recente visuele frames ($o_{t-L+1:t}$) voor korte-termijn continuïteit.
   • Deze module levert geometrische signalen (zoals ray-traced diepte/dispariteit) aan de observatiemodule.

2. Observation Module (Observatiemodule):

   • Genereert de volgende visuele observatie (het volgende frame) conditioneel op:
     • De recente visuele context.
     • De geometrische readout uit het externe geheugen (bijv. dispariteitskaart).
     • De actie van de speler.
   • Dit is een diffusion model (UNet-gebaseerd) dat getraind is om de volgende frame te voorspellen. Het gebruikt cross-attention voor acties en voegt de geometrische signalen toe als extra kanalen aan de input.
   • Om "drift" (accumulatie van fouten) te verminderen, wordt tijdens het trainen ruis toegevoegd aan de contextframes (noised-context training).

3. Dynamics Module (Dynamica-module):

   • Een lichtgewicht transformer-encoder die de volgende speler-pose voorspelt op basis van de huidige actie, de geometrische signalen en intermediate features van de UNet.
   • Deze module update de externe staat (de pose) zodat deze kan worden gebruikt voor de volgende stap in de simulatie.

Inference (Afleiding):
Tijdens het genereren lezen en schrijven alle spelers naar dezelfde externe geheugenmodule. Voor elke tijdstap:

1. De geheugenmodule leest de huidige pose en kaart om geometrische signalen te genereren.
2. De observatiemodule genereert het nieuwe beeld voor de speler.
3. De dynamica-module update de pose.
4. De staat wordt verschoven en de cyclus herhaalt zich.

Belangrijkste Bijdragen

1. Formulering met Extern Geheugen: Een nieuwe aanpak voor diffusiewereldmodellen die gedeelde staatupdates ondersteunt via een expliciete externe geheugenmodule, wat leidt tot consistente lange-termijn interacties.
2. Modulaire Architectuur: Het vervangen van het "single-model" paradigma door een gescheiden structuur (Memory, Observation, Dynamics). Dit biedt een schone interface voor het lezen en schrijven van externe geheugen en maakt het makkelijker om de wereldstructuur te controleren.
3. Toepassingen:
   • Bewerkbare Level-Design: Gebruikers kunnen een ruwe top-down kaart (minimap) tekenen of bewerken, en het model genereert daarop consistente first-person rollouts die strikt aan deze lay-out houden.
   • Real-time Multiplayer: Het systeem ondersteunt meerdere spelers die in dezelfde wereld interageren. Omdat ze allemaal naar dezelfde externe staat kijken, zijn hun perspectieven consistent (bijv. als speler A speler B doodt, verdwijnt speler B ook uit het perspectief van speler A).

Resultaten

De auteurs evalueren het systeem in twee scenario's:

1. Level-Design (Single Player):

   • Het model werd getraind op 100 procedurally gegenereerde Doom-kaarten.
   • Resultaat: In vergelijking met een baseline zonder extern geheugen (zoals GameNGen), behoudt MultiGen de structurele consistentie veel beter tijdens lange rollouts.
   • Metingen: De structuur-similariteit (SSIM) blijft hoger en de perceptuele afstand (LPIPS) lager, vooral in latere fases van de sessie waar baselines vaak "drift" vertonen (de kaart verandert onbedoeld).

2. Multiplayer Interactie:

   • Het systeem genereert gesynchroniseerde first-person beelden voor meerdere spelers.
   • Consistentie: Een VLM-based judge (Vision Language Model) evalueerde of spelers zichtbaar waren wanneer ze dat zouden moeten zijn. MultiGen scoorde aanzienlijk hoger (75,38% nauwkeurigheid vs 65,31% voor een "split-screen" baseline zonder extern geheugen).
   • Interactie: Het systeem slaagt erin om complexe interacties zoals het doden en opnieuw spawnen van spelers correct te handhaven over verschillende perspectieven heen.
   • Schaalbaarheid: Het systeem draait in real-time (ongeveer 20 FPS per speler op een NVIDIA A100) en ondersteunt een willekeurig aantal spelers zonder de modelinterface te hoeven aanpassen.

Betekenis en Conclusie

MultiGen vertegenwoordigt een belangrijke stap in de richting van controleerbare en uitbreidbare generatieve game engines. Door de wereldstaat expliciet te scheiden van de visuele generatie, lost het paper twee grote problemen op:

• Het stelt makers in staat om de wereldstructuur vooraf te definiëren en te bewerken, wat essentieel is voor level-design.
• Het maakt echte multiplayer-ervaringen mogelijk waarbij spelers invloed hebben op een gedeelde wereld, zonder dat de coherentie verloren gaat door de beperkingen van een enkel contextvenster.

De aanpak toont aan dat het combineren van een persistente, bewerkbare geometrische staat met krachtige diffusion-modellen de weg vrijmaakt voor interactieve simulaties die zowel creatief controleerbaar als sociaal gedeeld zijn.