Nutzung der C64 Architektur für eine GameEngine in Assembler.

Prinzipiell stellt der C64 Bildschirminhalt (wie schon mehrfach beschrieben) im Textmode oder im Grafikmode dar. Es gibt verschiedenste Grafikmodi: 320*200 in 2 Farben oder 160*200 in 16 vordefinierten Farben (Multicolormode). Wobei nur 4 Farben pro 8*8 oder 4*8 Block gesetzt werden können: 3 jeweils wählbare neben der allgemeinen Hintergrundfarbe. Dabei lassen sich diese Modi wie beim inspirierenden System Atari 400 hin und herschalten anhand des Rasters und damit Mischen. Sichtbar in unendlich vielen Spielen und auch Grund für die Teilung des Screens bei ManicMansion.

Das Problem: C64

Betrachtet man die Spiele, die mit dem C64 entstanden sind, ist man einigermassen fasziniert, da wirklich alles aus dieser ursprünglich als Gameconsole konzipierten Maschine rausgeholt wurde. Dabei ist der C64 alles andere als ein Paradies für Entwickler. Angefangen von den Text/Grafikmodis, über die Repräsentation des Bildschirms als RAM in Blöcken. Dann die maximale Auflösung von 320*200, die völlig überdimenstioniert ist für den Prozessor, der nur 8Bit ist (650x). Die Hardware und der Prozessor sind dabei eigentlich nicht aufeinanderabgestimmt und vieles ist einfach möglich günstig gelöst. Als Entwickler* hat man zu keinem Zeitpunkt das Gefühl, dass auch nur einen Moment an die Entwickler* gedacht wurde. So fehlen elementarste Dinge für Gamedevs – etwa (und das haben alle Consolen natürlich eingebaut) die Möglichkeit Text in den Grafikmode zu rendern. Hier soll allen Ernstes mit Modis umgeschaltet werden. Dies führt dann auch zu der immer künstlichen Trennung von Bild und Text in C64 Games. Die Sprites können von 0-386(?) in X und 0-300 (?) gesetzt werden. Dadurch können sehr schön Sprites reinhuschen in den Screen, dafür ist es die „Hölle“, die Sprites zu verwalten, da der Prozessor nur von 0-255 rechnet. Dann muss ein LowerByte hin. Wer dann auch noch eine eigene Kollisionsabfrage will, ja der hat viel „Spass“. Anders gesagt: Der C64 ist ein Bolide mit einem schwachen Herz. Zu erst sieht der Prozessor ja einigermassen schnell aus, bis man die Taktrate und die möglichen Instruktionen runterrechnet auf eine Frame. Dann zeigt sich dann sehr schnell, dass ohne die Zuatz-Hardware für Sprites, Scrolling oder die Zusatzmöglicheiten des SIDs, der C64 recht langsam ist. Es ist dann auch verständlich warum, der Apple II leider nie zum Gamecomputer avanzieren konnte in die Breite. Selbst mit den grosszügigen 64KB RAM stösst man sehr schnell auf Probleme bei der Entwicklung und es wird schnell klar, warum viele Spiel auf dem C64 so sind, wie sie sind..

Man mag Jack Tramiel danken für sein „Computer to the masses and not classes“, aber dass darum die Programmier* dabei Unterklasse werden, das bleibt im Dunkeln und wird auch fast nicht thematisiert, wenn man* so gemütlich ein C64 Spiel spielt.

GameEngine: ‚Philosophie‚ (Designrules)

In der entwickelten GameEngine wurde versucht aus diesem „Ungetüm C64“ etwas zu machen, das keine Herausforderung in der Nutzung ist, sondern den Entwicklern* hilft. Es ist eine TopDown-Entwicklung. Die Engine wurde auch so entwickelt, dass sie für verschiedene Genres genutzt werden kann. Nicht implementiert sollte Scrolling werden, da dies immer eine je eigene Entwicklung benötigt (Playfieldgrösse, vertikale oder horizontale Ausrichtung etc) und schwer abstrahierbar ist.

// ToDo: Vergleiche mit real entwickelten Spielen in jener Zeit und deren Ansatz – je eine eigene Engine für jedes Spiel oder eine Metaengine

Technologie: KickAssembler

Als Sprache wurde KickAssembler benutzt. Dies ist ein scriptbare Assembler in Java mit der Möglichkeit klassische C/Java-Kommentare zu machen // & /* */. Zusätzlich gibt es vordefinierte Scripts. Durch Java als Grundsprache läuft der Assembler auf allen Systemen. Eine Anforderung, die wichtig ist, weil Entwickeln auch auf Mac ein Goal des Projektes ist. Die meisten anderen Tools laufen vor allem auf Windows bzw. sind Plugins im Universum von Microsofts VisualStudio.

Das Compilieren ist (nach Installation von Java und dem Wechseln in den Ordner) simple:

java -jar KickAss.jar game.asm

Das generierte game.prg lässt sich dann in jedem Emulator ausprobieren. Oft wurde in der Entwicklung aber der folgende Online-Emulator verwendet.
https://c64emulator.111mb.de/index.php?site=pp_javascript&lang=en&group=c64

Er funktioniert einfach mit Drag&Drop, lädt sehr schnell, die Joysticks etc sind Standard mässig installiert. Dinge die gerade beim Platzhirsch VICE (https://vice-emu.sourceforge.io) konfiguriert werden muss.

EngineArchitektur

Die Architektur der Engine orientiert sich an frühen Engines (keine Eventengine) und basiert auf einem oder mehreren Loops (die linear angeordnet sind). Hier sind es: Titelbild-Loop, Menuloop, Submenloops und der Gameloop.

In der Organisation und Bewirschaftung der Daten wird auf die Eigenheiten/Verteilung durch die Hardware eingeganen. Das heisst, es gibt nicht nur eine Klasse GameObjekte (wie etwa in Unity), die alles abbildet sondern zwei Teilsysteme:

Diese zwei Objektkategorien sind bei Consolen und auch beim C64 als eigene Hardware/Teilsysteme abgebildet.

Dies führt dann auch zu verschiedenen Interaktionen/Events zusammen.

Auflösung und Playfield

(Viele 8Bit-Consolen nutzen Playfields für den Background bzw. die Umgebung/Architektur vgl. Intellivsion Ausnahmen natürlich Atari 2600 und Vectrex)

Für die entwickelte Engine wurde der Multicolormode genutzt. Damit lässt sich am meisten rausholen aus den Grafikmöglichkeiten (Die meisten Games verwenden auch diesen Mode). Anstelle des vermutlich gedachten Playgrounds mit einem Multicolorzeichensatz verwendet die Engine 8*16 Pixel grosse Blöcke. Das sind pro Block 4 Blöcke des C64 Grafiksystems.

Die Nutzung eines so „Niedrig“ aufgelösten Rasters erlaubt es, dass das Playfield eine Liste von 0-255 Feldern ist und so leicht manipuliert und abgespeichert werden kann.

Die Engine nutzt dabei eine Liste mit den Blöcken (Blocks) und ein aktuelles Playfield. Dieses kann gerendert werden in den Screen. Einzelne Blöcken lassen sich updaten. Es gibt ein System zu Animationen der Blöcke (synchron) für Gameplay wichtige Animation und ein System, das asynchron Animation bietet.

Die Menuszenen wie auch die einzelnen Szenen (alias Levels) sind als Levels im Speicher abgelegt. Dadurch muss nur ein System betreut werden und auch in Menuscenen kann etwa das Animationssystem benutzt werden.

Block & Playfieldtool

Um dies nicht nur im Code nutzen zu können, wurde ein Tool entwickelt in Processing. Dieses Tool ist zum einen ein Designtool für die Blöcke und zum Anderen ein Tool zum Gestalten der Playfielder (Levels).

Das Tool speichert die Daten als „rohe“ JSON Daten bei den Blocks und einzelne Levels. Gleichzeitig werden die Daten per .asm File gespeichert und können dann eingezogen (include) werden.

Das Tool ist so aufgebaut, dass man jeweils nach links Blocks designed und nach rechts die Levels. Im Bereich des Blockdesigns müssen die Farben nicht ausgelesen werden, sondern werden automatisch aus den benutzten selektiert. Dies macht es einfacher zu designen. Eine farblich angeordnete Palette macht das Pixeln einfacher.

// ToDo: Welche Spiele nutzten Leveleditoren und wer arbeitet Hardcore in den Listen/Tables oder nutzte einfach Files? Zumindest für die 16Bit Generation lassen sich Leveleditoren nachweisen (Bsp. WAR HELI) und sind sogar in die Games (KRACKOUT) eingebaut.

Gestaltung von Blocks/Szenen

Das Gestalten von Blocks zur nachfolgenden Mehrfachverwendung ist eine Designsparte für sich. So müssen die Blöcke zwar unique aussehen, dürfen aber auch nicht zu unique aussehen, damit sie nicht zu fest ausfallen. Das Umgekehrte gilt für den Hintergrund, dieser muss Regelmässig aber nicht zu regelmässig aussehen.
Die Limitation des C64 pro Tile/Segment nur 4 Farben (Hintergrund nicht wählbar und 3 Vordergrundfarben) machen es sehr schwierig interessante Dinge zu gesalten. Erschwerend kommt die wirklich schwierige (weil einfach seltsame Farben) Farbpalette hinzu. Zu guter letzt ist erst auf dem C64 laufend, dann klar, wie es wirklich aussieht. Da liegen dann die eine oder andere Farbe schon gar eng beieinander.

In die Blocks gehört auch ein Alphabet und Zahlen. So lassen sich Strings mit Zahlen ausgeben in der Grafik. Zusätzlich verfügt die Engine über die Möglichkeite 1/4 Blocks, klassische Tiles/Blöckchen zu zeichnen. Dadurch lassen sich normale Texte in 4×8 Pixeln rendern.

Gestaltung von Levels/Szenen

Levels besitzen wie Blöcke eine spielmechanische wie auch visuelle Funktion. Um Levels zu gesalten gibt es besondere „Commandsblöcke“, diese Spawnen etwa den „Spieler“ oder den Gegner etc. Diese werden dann umgewandelt in normale etwa Hintergrundblöcke.

Die visuellen Designregeln transportieren die Mechanik, dürfen aber auch nicht zu statisch sein und sollten irgendwie leben. Siehe dazu anderen Blogbeitrag.

Einige Beispiele:

Menuscene ohne Menupunkte

Ein Level mit Spielerspwanpunkt und Enemyspawnpunkt

GameObject bzw. Sprites

Das problematischste Element ist die GameObject/Spriteverwaltung. Diese besteht aus einer Liste von GameObjekten, die auch gerade Sprites abbilden.

Ein Objekt hat jeweils die Länge von 17 Bytes:

0	1	2	3	4	5	6	5	6	7	8	9	10	11	12	13	14	15	16
x	xshift	y	yshift	w	h	state	statesub	arg	behaviour	animtodo	animindex	mina	maxa	animtype	animeoden

Positionen

Die Sprites können in zwei Modis genutzt werden. Von 0-255 im Boxmode. Hier endet die Darstellung nach 256 Pixeln oder im 320 Pixel-Mode: Hier rechnet die Engine intern mit 2 Pixeln und dem Offset. 270 Pixel in X Richtung sind: 135 Pixel (x). Möchte man das Sprite auf 271 Pixel bewegen, so gibt es dafür eine ShiftNumber (x-shift). Da der C64 einen Rahmen von 20 px und 50 px hat, muss dies jeweils abgezogen werden für Vergleich oder Kollisionen mit dem Playfield.

320 Pixel-Mode (0-160, 0-250):

Animationssystem

Das Animationssystem ist simpel. Jedes Gameobject hat einen Animationstyp (Endlos,einmal,einmal&destroy). Per MinAnimation und MaxAnimation definiert man die Animation. Und los geht es.

GameObject-GameObject-Collision

Die Engine führt eine Kollision von jedem Objekt mit jedem anderen durch. Kollisionen können in der Schleife abgefragt werden.

Avatar-Playground-Collision

Die Engine prüft per Default Avatar-Playground-Kollisionen und ist damit in der Lage Objekte aufzunehmen. Objekte können dadurch einfach Objekte ‚auflesen‘ aus dem Playfield.

Spritetool

Das SpriteTool arbeitet ähnlich wie das Blockeditor-Tool. Geht aber auf die Eigenheiten von Sprites ein. Das heisst es können zwei Grundfarben ausgewählt werden und dann pro Sprite jeweils eine Zeichenfarbe.

Anwendung

Die GameEngine wurde bis anhin in 3 Projekten angewendet:
– Squarez – ein einfaches Spiel, das im Rahmen des CHLudens-Projekts durch die Geschichte der Computer nachprogrammiert wird.
– TheHolyCube – eine OneButtonSpiel von la1n ein OneButton JumpAndRun mit Animationen und vielen Levels
– ‚Züri brännt‘ – ein einfaches Adventure im Rahmen des CHLudens-Projektes zur Frage der Machbarkeit und Einschränkungen der Hardware/Medium: Game(HardwareC64) (In Entwicklung)

Fazit

Die GameEngine umfasst die meisten genutzten Funktionalitäten in Spielen mit Ausnahme des Scrollings und des Sounds.

Files

Engine (TheHolyCube.asm, alle Json-Files etc)

Processing-Editoren:

// ToDo: Thematisierung des RAM Problems etc.