Een hart voor zelfgeprogrammeerde retrospelletjes

Het idee klinkt vast gek. Om zelf een spel te ontwikkelen, oké. Maar voor de Commodore 64 en dan in Basic? Het project werd geboren uit pure nostalgie. Het verlangen naar mijn eerste ervaringen met computers leidde me daarheen. En ik merkte al snel dat het net zo leuk was als eind jaren '80.

In die tijd programmeerde ik niet op een Commodore 64, maar op een kindercomputer die alleen tekst kon weergeven. Van graphics kon ik alleen maar dromen. Het programmeren van een spel met graphics is daarom voor mij de vervulling van een jongensdroom.

Van het eerste vage idee tot het voltooide spel gaan ontelbare uren voorbij. Ik offer bijna een maand lang een groot deel van mijn vrije tijd op. Hoewel het spel erg bescheiden is, vind ik het geen tijdverspilling. Ik ben zelfs een beetje trots op het resultaat.

De gameplay is eenvoudig. Je bestuurt een hart met de WASD-toetsen. Je doel is het doel in de andere hoek, en je moet slechteriken en obstakels ontwijken.

Het is moeilijk de fascinatie van mijn project uit te leggen. Nostalgie speelt slechts een marginale rol. Belangrijker is dat een programma als dit een grote mentale taak is die in vele kleine opgedeeld wordt. Elke taak die wordt opgelost brengt me dichter bij het doel en kan onmiddellijk worden gezien en gespeeld. Dat motiveert.

Het is vooral een bevredigend gevoel om zelf iets uit het niets te maken. Zonder geprefabriceerde onderdelen en gereedschappen, zoals bij een moderne computer het geval zou zijn. Het is allemaal volledig zelf gemaakt.

In het volgende laat ik je zien hoe het eerste idee geleidelijk het voltooide spel werd.

Voorschriften: Sleutelinvoer en plaatsing

Eerst moet het programma herkennen wanneer je een bepaalde toets indrukt en daar onmiddellijk op reageren. Hiervoor dient het Basic commando GET K$. Het slaat de huidige ingedrukte toets op in de variabele K$. Als kind kende ik alleen het commando INPUT. Hiermee zijn real-time spellen niet mogelijk, omdat de computer pas reageert als je na het typen op de return-toets hebt gedrukt. .

Plaats element vrij

De tweede eis is dat ik een element vrij op het scherm kan plaatsen. Dit is zelfs bij tekst niet vanzelfsprekend. Het commando PRINT schrijft de tekst waar de cursor staat - de C64 kent geen Basic commando om de cursor in te stellen. Daarom moet ik het POKE commando gebruiken om een specifiek adres in het registergeheugen van de chip te veranderen.

Grafiek als tekst

Ironisch gezien bestaat mijn eerste poging tot een grafisch spel uit tekst. Er is niets anders te zien dan twee speciale tekens in de vorm van hartjes. Het blauwe hart moet het rode vangen.

Als het hart verhuist, moet het niet alleen worden uitgevoerd op de nieuwe plaats, maar ook verwijderd op de oude. Ik los dit op door eerst bij elke programmarun een spatie te schrijven - bij elk frame, zeg maar - en dan het hart op de nieuwe positie te schrijven. Daarom flikkeren de hartjes.

Dit voorstadium van het spel omvat slechts 41 regels code. Het rode hart beweegt willekeurig en is daarom gemakkelijk te vangen.

Rechtse graphics met sprites

Een sprite is een grafisch element dat vrij over het scherm beweegt. In tegenstelling tot mijn teksthart werkt de computer de achtergrond zelf bij. Dit betekent dat ik de sprite niet telkens hoef te verwijderen als ik hem naar een nieuwe locatie verplaats.

Bovendien kan ik het uiterlijk van de sprite vrij ontwerpen. Op de C64 bestaat een eenkleurige sprite uit 504 pixels (21 rijen en 24 kolommen). Er zijn ook meerkleurige sprites, maar ik wil het om te beginnen niet overdrijven.

Zonder hulpmiddelen is het maken van een sprite uiterst vervelend. Om de sprite op het scherm te toveren, moet ik de geheugenadressen van de C64 opnieuw bewerken. Daarbij
Ik moet de waarden pixel voor pixel berekenen. Gelukkig is er de C64 Wiki en de zeer goede C64 Gebruikershandleiding, die me de nodige info verschaffen.

Een sprite editor zou een grote hulp zijn bij het tekenen en berekenen. Ik ben echter ongeduldig en wil onmiddellijk mijn eerste sprite. Daarom maak ik het handmatig.

Ik wilde eigenlijk een sprite maken.

Ik wilde eigenlijk een gebroken hart tekenen. Het ziet er nu uit als een ezel, maar het past ook.

Wat voor mij niet past: Het spel loopt tergend langzaam. Hoewel het uiterst eenvoudig is. Ik kan het dus moeilijk verbeteren of interessanter maken, want dat zou het nog langzamer maken.

Compileren in machinetaal

De oplossing is verrassend eenvoudig: Basisprogramma's kunnen met een compiler automatisch vertaald worden naar machinetaal. Dit maakt het programma veel sneller. Ik probeer de compiler Basic Boss, en het werkt meteen.

Maar zelfs bij een acceptabele snelheid geniet ik niet van het spel. Het lijkt nog saaier dan de tekstversie. Het hart beweegt niet langer willekeurig, maar vlucht voor mij en kan ook naar de tegenoverliggende rand van het spel springen. Maar dat is niet genoeg om het spel interessant te maken.

Ik besluit daarom van rol te wisselen: Als speler moet ik niet meer vangen, maar wegrennen. Opdat het niet te simpel wordt, zijn er twee personages waarvoor ik moet vluchten. En omdat dat er vreemd uitziet met al die hartjes, heb ik een nieuwe sprite nodig. Eén voor de schurk. En misschien een nieuwe voor het gebroken hart.

Door te compileren is het spel veel sneller dan in Basic, maar nog steeds traag. Zodra ik het complexer maak, loopt het weer snoozy. De noodzakelijke impuls komt van zogenaamde compiler directives. Dit zijn instructies voor de compiler in de vorm van commentaarregels in het Basic programma. Hierdoor kan ik bijvoorbeeld kleine gehele variabelen als zodanig declareren, waardoor de berekening veel sneller gaat. Inmiddels heb ik de snelheid zodanig geoptimaliseerd dat ik het spel niet eens meer aankan. Maar misschien lukt het je - je kunt het hier downloaden. Je kunt het uitgepakte .d64 bestand in het drag-and-drop vak van de online emulator slepen.

Ik maak een sprite editor

. Aangezien ik geen zin heb om nog een grafiek met de hand uit te werken, besluit ik zonder meer een sprite editor te programmeren. Dat is veel meer werk, maar wel leuk.

Dit stukje software is verre van perfect, maar het doet het werk. Het duurde ook maar een heel weekend om de editor te coderen. Al doende leerde ik veel over laden en opslaan op de C64. En ik weet nu hoe ik het hele scherm in de cache kan zetten en later kan herstellen. Dat kan ik later zeker gebruiken.

Botsingscontrole

Sinds je in het spel geen hart meer hoeft te vangen, maar moet ontsnappen, heeft het spel een nieuw doel nodig. Ook hier maak ik het zo gemakkelijk mogelijk: het personage moet een kleine opening bereiken zonder gepakt te worden. Om de moeilijkheidsgraad wat te verhogen plaats ik wat obstakels.

De C64 heeft ingebouwde botsingsdetectie. Door de waarde van twee specifieke geheugenregisters op te vragen, weet mijn programma of het spelkarakter respectievelijk tegen een slechterik of tegen de obstakels zal botsen.

Meerdere levels en meerdere levens

Volgende wil ik verschillende niveaus maken. Dit kan met weinig moeite. In principe hoef ik alleen maar een paar variabelen te veranderen, zoals de startpositie van de personages of obstakels, en dan het programma opnieuw uit te voeren.

Het is veel moeilijker om de niveaus zo aan te passen dat ze niet te makkelijk of onoplosbaar zijn. Want ik kan het spel alleen gecompileerd op de juiste snelheid spelen en moet daarom na elke verandering opnieuw compileren om het uit te proberen. In de emulator kan ik de CPU versnellen, maar dat geeft slechts een ruwe indruk, het is niet hetzelfde.

Met acht levels is het eerlijk om mij als speler meerdere levens te geven. Deze worden rechts weergegeven in de vorm van hartjes - het teksthart is terug!

Daarnaast heeft het spel een begin- en eindscherm nodig. Nogmaals, ik maak het mezelf gemakkelijk en blaas de grootte van de sprites op. De C64 kan dit standaard. Als je alle acht niveaus hebt voltooid, verschijnt er een kleine animatie. Het spel heeft dus alle basiselementen.

Conclusie: niet zo eenvoudig

In de hier getoonde vorm heeft het programma ongeveer 240 regels. Zelfs in een volkomen eenvoudig spel zit al heel wat werk, denkwerk en concept. Tenminste als je het spel zelf vanaf nul maakt. Nu ik de basis heb, kan ik het relatief gemakkelijk uitbreiden: meer levels toevoegen, andere sprites inbouwen en nieuwe vijanden met verschillende looppaden programmeren. Er zijn ook complexere uitbreidingen: Bijvoorbeeld dat de vijanden obstakels ontwijken of er tegenaan botsen. Dat de personages tijdens bepaalde gebeurtenissen van uiterlijk veranderen. Een geheel apart thema zou muziek en geluidseffecten zijn.

Ik zal me niet snel vervelen. Ik hoop alleen dat alle gekte tegelijk met de winter ophoudt.

Hier is de downloadlink weer: Heartbreak voor de C64 .