Mega Drive programmieren – Teil 1: Erstes ROM mit SGDK

· von Alex #mega-drive #retro-gaming #programmierung #homebrew

Du wolltest schon immer mal dein eigenes Sega-Spiel entwickeln? Das geht:

  • einfacher Einstieg,
  • schnelle Erfolge,
  • kostenlos und
  • lauffähig auf echter Retro-Hardware (mit einem Flash-Modul wie dem EverDrive).

Und du musst dafür kein erfahrener Programmierer sein. Probier es aus.

Teil 1 – Erstes Programm #

Im ersten Teil schauen wir uns die Grundlagen zum Sega Mega Drive (MD) an und richten eine einfache Entwicklungsumgebung auf dem PC ein. Danach lassen wir ein erstes, kleines Programm laufen. Wir nutzen dafür das SGDK, ein kostenloses Framework, das dir viel Arbeit abnimmt und aus deinem Programmcode eine ROM-Datei für den Mega Drive baut.

Was du brauchst: einen Windows-PC und rund 1 GB Platz für SGDK, Visual Studio Code und Emulator. Die Anleitung beschreibt Windows. Unter Linux und macOS läuft das SGDK über Docker oder Wine, dort unterscheiden sich die Schritte.

Das erwartet dich in Teil 1:

  1. Mega-Drive-Grundlagen (ohne die geht es nicht)
    • MD-Spezifikationen und Systemarchitektur
    • Bildaufbau und Ebenen
    • Auflösung, Farben und Paletten
  2. Programme und initiale Einrichtung
    • SGDK (Framework für Sega MD)
    • Visual Studio Code
    • Emulator (Gens, BlastEm)
    • Aseprite (Pixelgrafiken erstellen)
  3. Erstes Sega-Programm
    • Unser erstes, lauffähiges Programm
    • Grundlegender Codeaufbau in Spielen

Mega-Drive-Grundlagen (ohne die geht es nicht) #

Bevor wir loslegen, schauen wir uns an, was der Mega Drive kann und wo die Grenzen in der Hardware und im Bildaufbau liegen.

MD-Spezifikationen und Systemarchitektur #

Das steckt im Mega Drive:

Sega Genesis, die US-Version des Mega Drive, mit 3-Button-Controller neben einer Tabelle der Hauptspezifikationen: Motorola 68000 mit 7,67 MHz, Zilog Z80 mit 3,58 MHz, 64 KB RAM plus 8 KB für den Z80, 64 KB VRAM, 512 Farben, Auflösung 320 x 224 bzw. 320 x 240

Die Tabelle zeigt die wichtigsten Eckdaten: Der Motorola 68000 arbeitet mit 7,67 MHz, dazu kommt ein Zilog Z80 als Co-Prozessor, der sich vor allem um den Sound kümmert.

Blockschaltbild der Mega-Drive-Architektur mit Cartridge, 68000, Z80, Video- und Soundchips, den drei Speichern sowie I/O- und Audio-Ausgang, rechts eine Übersicht der FM- und PSG-Tonkanäle

Das Blockschaltbild zeigt, wie die Bausteine zusammenspielen: Der 68000 liest das Modul und arbeitet im RAM, der VDP erzeugt das Bild aus dem Videospeicher, und der Z80 steuert den Ton, den der FM-Chip YM2612 und der PSG erzeugen.

Bildaufbau und Ebenen #

Der Mega Drive hat grundlegend 3 Ebenen, die von hinten nach vorne der Reihenfolge nach auf dem Bildschirm gezeichnet werden: Hintergrund B, Hintergrund A und Sprites. Einen Vordergrund gibt es nicht als eigene Ebene, er entsteht über ein Prioritäts-Bit: Tiles der Hintergründe mit hoher Priorität werden vor den Sprites gezeichnet. Dazu kommt optional das Fenster (Window), ein statischer, fester Bereich, der einen Teil von Hintergrund A ersetzt und in dem man z. B. Highscores oder Status-Informationen ausgeben kann. Das Fenster werden wir in unserem Tutorial nicht nutzen.

Darstellungsreihenfolge von hinten nach vorne am Beispiel Sonic: Hintergrund B, Hintergrund A, Fenster-Ebene, Sprites und Vordergrund mit Punkteanzeige

An diesem Sonic-Bild siehst du die Reihenfolge: Ganz hinten liegen die Berge, davor die Bäume, dann kommen Sprites wie Sonic und die Ringe, ganz vorn stehen Punkte und Zeit, die in Sonic übrigens ebenfalls als Sprites gezeichnet werden.

Übersicht der Mega-Drive-Ebenen mit Aufgaben und Größen: BG_B, BG_A, Window, Sprites und FG, daneben schematische Tile-Raster von 64 mal 32 Tiles

Die Übersicht fasst zusammen, wofür die Ebenen gedacht sind und wie groß sie sind. Die Hintergründe umfassen typischerweise 64 x 32 Tiles, scrollen unterschiedlich schnell und erzeugen so den Tiefeneindruck.

Auflösung, Farben und Paletten #

Der Mega Drive stellt 320 x 224 Bildpunkte dar, auf PAL-Geräten sind auch 320 x 240 möglich. Die 320 Pixel sind der H40-Modus, daneben gibt es H32 mit 256 Pixeln Breite. Der Nullpunkt liegt oben links, X(0), Y(0) ist also die obere linke Ecke.

Bildschirmkoordinaten des Mega Drive an einer Palmenlandschaft: Ursprung 0,0 oben links, 320 Pixel Breite, 224 Zeilen Höhe

Die Farbpalette besteht aus 512 knalligen Farben (RGB) mit 3 Bit pro Farbkanal. Gleichzeitig darstellbar sind davon 61, nämlich vier Paletten mit je 16 Einträgen. Der erste Eintrag jeder Palette ist transparent, für Bildinhalte bleiben also 15 Farben pro Palette, dazu kommt eine Hintergrundfarbe. Hier alle 512 Farben im Überblick:

Alle 512 Farben des Mega Drive als Raster, aufgeteilt in vier Blöcke zu je 128 Farben

Der Mega Drive arbeitet grundsätzlich mit sogenannten Tile-Maps, einen Bitmap-Modus gibt es nicht. So lassen sich einzelne Bildelemente wiederverwenden und Speicherplatz sparen. Ein Tile ist dabei immer 8 x 8 Pixel groß. Sprites setzt der Mega Drive aus 1 bis 4 Tiles je Kante zusammen, also bis zu 32 x 32 Pixel. Hier ein Beispiel einer Map aus Sonic. Aus den einzelnen Teilen werden Hintergrund, Sprites und Vordergrund bis zum fertigen Bild zusammengebaut:

Vom Tile-Satz zum fertigen Bild: links die Tile-Map aus Sonic, in der Mitte Hintergrund, Vordergrund und Sprites einzeln, rechts das zusammengesetzte Spielbild

Programme und initiale Einrichtung #

Jetzt richten wir die Entwicklungsumgebung so ein, dass wir starten können. Der Reihe nach.

SGDK (Framework für Sega MD) #

Das Herzstück für die Entwicklung ist das SGDK, ein Framework von Stéphane Dallongeville, das viele Funktionen und die Ansteuerung der Hardware für dich übernimmt. Darin steckt auch der m68k-elf-GCC-Compiler, der aus deinem Code ein Mega-Drive-ROM für den Motorola 68000 erzeugt.

Du kannst es kostenlos auf GitHub herunterladen. Dort findest du eine gute Einführung in das Thema, dazu enthält das Paket einige Beispielprogramme, die du dir anschauen kannst.

Jetzt gehen wir Schritt für Schritt durch. Ich beschreibe es der Einfachheit halber für Windows:

  • Fang mit dem SGDK an: Lade es herunter und entpacke es in einen Ordner auf deinem PC.
  • Folge danach der Anleitung im SGDK-Wiki.

Starterpaket vom RCD #

Wenn du es schon vorgefertigt haben willst, lade dir das Starterpaket des RCD herunter und entpacke es. Dort ist alles vorbereitet und übersetzt. Zusätzlich enthalten sind der Emulator Gens, ein fertiges Template für Visual Studio Code, die Palette für Aseprite und ein Audio-Converter.

Egal welchen Weg du wählst: Entpacke das SGDK für dieses Tutorial direkt in den Ordner C:\SGDK\.

Umgebungsvariable setzen #

Damit das SGDK beim Bauen des Programms automatisch gefunden wird, braucht Windows eine Systemvariable namens GDK. Lege dazu in den Umgebungsvariablen eine neue Systemvariable an: Variable GDK, Wert C:/SGDK. Achte beim Wert auf den normalen Schrägstrich (/), nicht auf den Backslash ().

Visual Studio Code #

Als Entwicklungsumgebung und Editor für unseren Code nutzen wir Visual Studio Code. Lade Visual Studio Code herunter und installiere es.

Wichtig: Nach der Installation brauchst du noch ein paar Erweiterungen, die du bequem nachinstallieren kannst. Starte dazu VS Code und geh auf der linken Seite auf „Extensions“:

Erweiterungs-Marktplatz in Visual Studio Code mit der Suche nach Genesis Code und der Detailansicht der Erweiterung von zerasul

Dort suchst du diese beiden Pakete und installierst sie über „Install“:

  • C/C++ Extension Pack (von Microsoft)
  • Genesis Code (von zerasul)

Emulator (Gens, BlastEm) #

Den Emulator brauchst du, damit du dein fertiges ROM direkt am PC laden und ausprobieren kannst. Im Starterpaket des RCD ist Gens bereits enthalten. Ansonsten lade dir den Gens-Emulator herunter. Eine gute Alternative ist BlastEm.

Aseprite (Pixelgrafiken erstellen) #

Damit du Pixelgrafiken erstellen kannst, brauchst du ein Programm, das Paletten laden kann und die Grafiken so speichert, dass der Mega Drive sie später auch versteht. Unsere Empfehlung ist Aseprite. Es kostet wenig und ist über Steam oder direkt beim Hersteller zu haben.

Erstes Sega-Programm #

Nun wollen wir doch mal sehen, ob ein erstes Testprogramm funktioniert.

Unser erstes, lauffähiges Programm #

Leg dir auf dem PC einen Ordner an, in dem du deine Sega-Projekte ablegen willst, zum Beispiel C:\Projekte\SEGA\. Darin legst du einen ersten Ordner für das Testprojekt an, etwa Bildschirmspiel01.

In den Ordner Bildschirmspiel01 kopierst du den Inhalt der VS-Code-Projektvorlage aus dem SGDK-Ordner project\template. Im Starterpaket des RCD ist sie schon dabei.

Jetzt, da alles installiert und eingerichtet ist, öffne Visual Studio Code, falls es noch nicht offen ist. Öffne dort über „File“ → „Open Folder“ den Ordner Bildschirmspiel01. Du siehst nun bereits folgende Ordnerstruktur:

Projektordner Bildschirmspiel01 im Explorer von Visual Studio Code mit den Unterordnern inc, out, res und src sowie geöffneter main.c

Terminal

  • Öffne in VS Code ein Terminal über „Terminal“ → „New Terminal“.
  • Stell danach unten im Terminal das Default-Profil auf „Command Prompt“, denn das Bauen und Ausführen deines Sega-Programms läuft nur über die Eingabeaufforderung.

Emulator

  • Drück nun in VS Code Strg + Shift + P, um die Befehlspalette zu öffnen, und gib „Genesis Code“ ein. Es tauchen automatisch mehrere Befehle auf.
  • Wähl zunächst „Genesis Code: Set Gens Emulator Command Path“, um den Pfad zum Emulator zu setzen, und drück Enter.
  • Gib jetzt den Pfad direkt in die Eingabe ein, beim Starterpaket des RCD ist das c:\sgdk\gens\gens. Hast du Gens selbst heruntergeladen, trägst du den Pfad zu deiner gens.exe ein.

Bauen und Ausführen

  • Drück wieder Strg + Shift + P, um die Befehlspalette zu öffnen.
  • Gib „Genesis“ ein, um die Genesis-Befehle zu filtern.
  • Wähl jetzt „Genesis Code: Compile & Run Project“.

Hinweis: Falls du beim Ausführen kein „Genesis“ siehst, kann das daran liegen, dass du in VS Code erst „Yes, I trust the authors“ bestätigen musst.

Im Terminal unten läuft jetzt der Build durch. War er erfolgreich, öffnet sich sofort der Gens-Emulator mit dem gebauten ROM und zeigt dir „Hello Sega!“ an. Dann hast du es geschafft, dein erstes Sega-Programm läuft.

Grundlegender Codeaufbau in Spielen #

Den zugehörigen Code findest du im Ordner src in der Datei main.c:

#include 

int main(bool hard)
{
    VDP_drawText("Hello Sega!", 10, 12);

    while (TRUE)
    {
        SYS_doVBlankProcess();
    }
    return 0;
}

VDP_drawText schreibt den Text an die Position 10, 12 im Zeichenraster. Danach läuft das Programm in einer Endlosschleife, die mit SYS_doVBlankProcess() jeweils auf das Ende des Bildaufbaus wartet. Genau so ist fast jedes Mega-Drive-Spiel aufgebaut: einmal alles vorbereiten, danach Bild für Bild aktualisieren.

Was das alles bedeutet und wie du jetzt eigenen Code hier reinbekommst, behandeln wir in Teil 2 unserer Serie.

Noch Fragen? #

Bei Fragen und Unklarheiten kannst du mich (Jupi) gern im Discord-Kanal „Sega“ fragen, hier geht es zu unserem Discord. Ich versuche, sie dir zu beantworten. Oder komm einfach bei uns im Verein vorbei: zum Retro Mittwoch, jeden Mittwoch ab 18 Uhr.

Wenn du lieber mit 8 Bit anfängst, findest du im Beitrag AgonLight programmieren einen ähnlichen Einstieg. Wie der Mega-Drive-Vortrag bei unserer Retro Computer Lounge lief, steht im Rückblick auf die Retro Computer Lounge.

Bis bald!

Jupi