Een van de eerste spellen die ik ooit maakte, is AIRPLANE. Ik programmeerde het als kind in MSX-BASIC. Het is een eenvoudig spelletje waarin je met een vliegtuig door een speelveld vliegt en obstakels moet ontwijken. Hoewel het weinig voorstelt, is het nog steeds een spel dat ik toch elke keer als ik het opstart een paar minuutjes speel.
Ruim dertig jaar later wilde ik eens proberen een nieuwe versie van dit spel te vibe coden. Deze keer als echte MSX-cartridgegame in Z80-assembly. Een mooie combinatie van nostalgie, technisch puzzelen en AI.
Terug naar het oorspronkelijke BASIC-spel
Mijn eerste MSX-games maakte ik tussen 1990 en 1993. AIRPLANE maakte ik toen ik 12 jaar oud was. Het oorspronkelijke spel kun je nog altijd direct in de browser starten:
Speel de oorspronkelijke BASIC-versie:
https://webmsx.org/?DISK_FILES=http://www.jeroenderwort.nl/wp-content/uploads/jermsx/AIRPLANE.BAS&BASIC_RUN=AIRPLANE.BAS
Dat ik dit spel op zo’n vroege leeftijd al kon maken, had te maken met de kracht van MSX-BASIC. Je zet de computer aan en kan meteen beginnen. Commando’s als SCREEN, LOCATE, PRINT, STICK en GOTO zijn begrijpelijk en geven je direct controle.
Daar staat tegenover dat BASIC relatief langzaam is. Zodra er meer objecten bewegen, botsingen moeten worden berekend of het scherm voortdurend wordt aangepast, loop je al snel tegen de grenzen van de taal aan.
Waarom een remake in assembly?
Zou het mogelijk zijn deze game te upgraden met behulp van AI in Z80 assembly? In assembly krijg je op een relatief langzame 8-bit computer veel meer snelheid en dus mogelijkheden.
Maar assembly staat ook wat programmeren betreft vrijwel aan de andere kant van het spectrum ten opzichte van BASIC. Het zit dicht tegen de machine aan. Je werkt rechtstreeks met registers, geheugenadressen, BIOS-routines, videogeheugen en hardwarepoorten. Dat maakt de ontwikkeling ingewikkelder. Als kind is het me nooit gelukt om een volledige game in assembly te maken.
AI kan wél Z80 code schrijven. Het nieuwe AIRPLANE is een ROM-cartridge geworden. De game bestaat inmiddels uit meer dan drieduizend regels assemblycode en bevat vijftien levels.
Ontwikkelen met Antigravity
Bij het ontwikkelen heb ik gebruikgemaakt van Antigravity als AI-programmeerassistent.
Ik heb in natuurlijke taal beschreven wat ik wilde maken, met het oorspronkelijke spel als inspiratie. Hierbij gebruikte ik zowel de de BASIC sourcecode als een screenshot van het spel.
Daarnaast gaf ik wat basisdingen mee, zoals: laat het vliegtuig horizontaal en vertikaal vliegen. Controleer botsingen met het landschap. Laat watertegels bewegen. Voeg varende zeilbootjes toe. Maak een titelbeeld in SCREEN 2. Speel muziek af via de PSG met inspiratie en zorg dat de ROM ook op een echte MSX werkt.
De AI is vervolgens code gaan schrijven. Dat ging niet in één keer goed. Ik heb heel wat iteraties moeten doen met nieuwe aanwijzingen, voordat het spel goed werkte en ik er tevreden over was.
Mijn rol was ontwerpen, testen, analyseren en gericht bijsturen. Ik moest voortdurend beoordelen of de voorgestelde oplossing logisch was en of het resultaat ook echt goed speelde. AI maakte de ontwikkeling sneller, maar een ‘one-shot’ was het geenszins.
Van een simpel spel naar vijftien levels
De nieuwe versie is veel uitgebreider dan mijn oorspronkelijke BASIC-game.
Je bestuurt nog altijd een vliegtuig, maar beweegt nu vloeiend en springt niet simpelweg van positie naar positie.
De game bevat onder andere:
- vijftien verschillende levels;
- vijf levens;
- score en highscore;
- vloeiende acceleratie en vertraging;
- botsingsdetectie;
- geanimeerd water;
- draaiende munten;
- bewegende zeilbootjes;
- explosie-animaties;
- een titelscherm;
- levelintro’s;
- muziek en geluidseffecten via de MSX PSG;
- een eindscherm na het voltooien van alle levels.
De hoofdstructuur is een klassieke game loop. Per beeldframe wordt de invoer gelezen, het vliegtuig verplaatst, de botsingsdetectie uitgevoerd en worden de sprites, animaties, muziek en score bijgewerkt.
Dat klinkt tegenwoordig vanzelfsprekend, maar op een MSX1 moet je daarbij voortdurend rekening houden met de beschikbare rekentijd en het beperkte geheugen.
Tekens, tiles en sprites
Een belangrijke ontwerpkeuze is het gebruik van zowel karaktergraphics als hardware-sprites.
Het speelveld wordt grotendeels opgebouwd uit aangepaste tekens van acht bij acht pixels. Ieder level kan daardoor compact als een raster van tekencodes worden opgeslagen. Dat bespaart veel geheugen en past goed bij de manier waarop veel klassieke MSX-games werden gemaakt.
Toen ik de oorspronkelijke game aan Gemini liet zien, viel het mijn “Senior Level Designer”-agent op dat het thema van de game Nederlands aanvoelt, met water en dijken. Het koos ervoor om voor de extra levels Nederlandse landschapsthema’s te kiezen en kwam met dit voorstel:
Overzicht van de voorgestelde thema’s:
Level 6: Het Markermeer & Houtribdijk
Level 7: Kinderdijk Molenpark
Level 8: Rotterdamse Haven
Level 9: Veluwe Heuvelrug & Bos
Level 10: Biesbosch Delta Doolhof
Level 11: Waddeneilanden & Texel
Level 12: Deltawerken Stormvloedkering
Level 13: Amsterdam Grachtengordel
Level 14: Afsluitdijk Megastructure
Level 15: Het Grote Oranje Slotakkoord
Eerlijk is eerlijk, als je de game bekijkt zal het niet direct opvallen. Er is veel fantasie nodig om de thema’s te herkennen. Maar juist daarom vond ik het heel grappig om te zien dat de AI het level design zo diepgaand probeerde aan te pakken.
Het vliegtuig zelf is een hardware-sprite. Hierdoor kan het soepel over het karakterraster bewegen zonder dat voortdurend alle achtergrondtekens opnieuw hoeven te worden getekend. Ook de zeilbootjes worden met sprites weergegeven.
Een zeilbootje van alleen de letter O
Een grappig detail is dat ik voor een van de grafische elementen eerst een zeilbootje als ASCII-art liet ontwerpen. Het bootje moest binnen een raster van acht bij acht tekens passen en mocht uiteindelijk alleen uit de letter O bestaan.
Zo’n opdracht lijkt misschien nogal willekeurig, maar raakt precies aan de manier waarop je voor een oude computer ontwerpt. Je werkt voortdurend binnen harde grenzen: acht bij acht pixels, een beperkt aantal kleuren, weinig sprites en slechts enkele kilobytes beschikbaar geheugen.
Binnen zulke beperkingen moet je een vorm toch direct herkenbaar zien te maken.
Dat is een belangrijk verschil met moderne gameontwikkeling. Tegenwoordig kun je vrijwel onbeperkt afbeeldingen, animaties en effecten toevoegen. Op de MSX moet ieder bit een duidelijke functie hebben.
SCREEN 1 en SCREEN 2 combineren
Het eigenlijke spel gebruikt een tekenmodus die goed geschikt is voor snel opgebouwde levels. Het titelscherm gebruikt SCREEN 2, waarmee veel gedetailleerdere patronen en kleurinformatie kunnen worden getoond.
Dit titelscherm is bijzonder fraai geworden vind ik, zeker als je weet wat de beperkingen in resolutien en kleurweergave zijn. Om de AI de goede richting op de sturen, heb ik als referentieafbeelding een plaatje van de commerciële MSX1-game Army Moves gebruikt.
Bij het starten van een spel wordt tussen de verschillende schermmodi geschakeld. De game initialiseert het beeldscherm, uploadt een aangepast lettertype en zet de benodigde patronen, kleuren en sprites in het videogeheugen.
Muziek op drie geluidskanalen
De muziek is wat minder goed uit de verf gekomen. MSX beschikt standaard over de Programmable Sound Generator. Deze PSG heeft drie toonkanalen en kan ruis produceren. Daarmee moet zowel de muziek als het geluid worden gemaakt.
AIRPLANE bevat routines voor verschillende muziekmodi, noten, volumes, vibrato en drumsimulatie. Ook geluidseffecten, zoals het oppakken van een munt en het neerstorten van het vliegtuig, lopen via dezelfde chip.
De AI heeft de muziek gemaakt waarbij ik de muziek en geluideffecten uit het oorspronkelijke spel als basis heb meegegeven. Omdat die niet geweldig waren, is het resultaat in de remake dat ook niet: garbage in is garbage out. Natuurlijk zou ik nog meer tijd hieraan kunnen besteden, maar omdat dit dicht bij de oorsprong blijft, heb ik het zo gelaten.
Werken op echte hardware
Een belangrijk doel was dat AIRPLANE niet alleen in een emulator, maar ook op een echte MSX zou draaien: een Toshiba HX-10S met 16kb geheugen.
Dat maakte het extra lastig. Een ROM die probleemloos start in openMSX of WebMSX hoeft namelijk niet automatisch goed te functioneren op ieder fysiek MSX-model. Ik heb heel wat iteraties van de game moeten testen voordat dit goed werkte.
Met behulp van de MSX Pico heb ik de ROM op een echte MSX gestart. Na de bekende MSX-copyrights kwam het vliegtuig in beeld. Het werkte. Magisch!
Fijne vlucht
AIRPLANE begon als een eenvoudig BASIC-programma van een kind dat wilde ontdekken hoe computerspellen worden gemaakt.
Nu bestaat dezelfde game als een cartridge-ROM, geschreven in Z80-assembly, met vijftien levels, sprites, muziek, animaties en code die rekening houdt met de eigenaardigheden van echte MSX-hardware.
Daarbij gebruikte ik een technologie die destijds pure sciencefiction zou zijn geweest: een AI die mee kan denken over code, bugs analyseert en helpt om ideeën om te zetten in werkende routines. Maar het resultaat had in 1983 ook kunnen bestaan: een speelbare game 32kb.
Leermomenten
Het maken van deze game kostte nog behoorlijk wat moeite. Ik heb heel wat LLM-credits verbruikt met onnodige iteraties. Elke keer als er een update klaar was, brak het op een andere plek weer.
Een aantal dingen kan ik verbeteren bij het volgende project:
- Programmeren in C en niet in pure assembly;
- Gebruik gaan maken van standaard libraries zoals MSXgl;
- Pak het stapsgewijs aan, zorg dat er goede documentatie is voordat je gaat bouwen;
- Als iets goed is gedaan, laat de LLM dat dan vastleggen zodat het daarna weer goed gedaan kan worden;
- Laat de software testen;
- Maak gebruik van een MCP server om openMSX aan te sturen.
Ik heb de smaak nu wel te pakken. Als ik weer wat credits heb ga ik maar eens naar de volgende BASIC game kijken die ik kan laten reïncarneren!
Zelf spelen of de broncode bekijken
De nieuwe cartridgeversie kun je rechtstreeks starten in WebMSX:
Speel AIRPLANE:
http://webmsx.org/?ROM=https://www.jeroenderwort.nl/wp-content/uploads/airplane.rom
De volledige broncode staat op GitHub:
Broncode:
https://github.com/Randam/MSX-Airplane
Het project bevat onder andere de hoofdcode, leveldata, grafische bestanden, buildscript en ontwerpregels voor de levels. De repository omschrijft het project toepasselijk als een herleving van mijn allereerste MSX-BASIC-game.
En voor wie wil zien waar het allemaal begon:
Speel het oorspronkelijke AIRPLANE in MSX-BASIC:
https://webmsx.org/?DISK_FILES=http://www.jeroenderwort.nl/wp-content/uploads/jermsx/AIRPLANE.BAS&BASIC_RUN=AIRPLANE.BAS
