Fahrt 003

weitersagen ...
Tweet about this on TwitterShare on FacebookShare on Google+Share on LinkedIn

C64 Studio
Fahrtstrecke erstellen

Im letzten Beitrag haben wir erste Erfahrungen mit einem eigenen Zeichensatz gesammelt. Nun wollen wir das Erlernte in die endgültige Form bringen, um unsere Fahrstrecke zu erstellen. Ausgangspunkt sollte der Download aus ‚Fahrt 002‚ sein.

 

Datenstruktur für die Fahrbahn
Wir haben zuletzt unsere Demo-Ausgabe erzeugt, indem wir unsere entworfenen Zeichen direkt einzeln auf den Bildschirm gebracht haben. Um die Strecke zu bauen sind diese einzelnen Zeichen aber nicht sonderlich gut geeignet. Wir müssten beim Erstellen einfach zuviele Sonderfälle beachten. Es wäre schöner, wenn wir einfach direkt aneinander passende Bauteile hätten. Also lasst uns, wie bereits bei ‚VIC-II: Eigener Zeichensatz‚ am Wizball-Beispiel gesehen, die sog. Tiles verwenden.

Den Level mit den Tiles erstellen.
Den Level mit den Tiles erstellen.

 

Tiles
Fasst man einzelne Zeichen zu größeren Bauteilen zusammen, dann werden diese Tiles genannt. Einer der Vorteile ist, dass man für die Speicherung der Leveldaten weniger Arbeitsspeicher benötigt. Gehen wir mal von einem ‘normalen‚ Schirm mit 40*25 Zeichen aus. Ein Levelbildschirm würde somit 1000 BYTES benötigen. Wollt ihr nun 10 Bildschirme scrollen, dann wären es bereits fast 10KB. Stellen wir den Level aber aus Tiles mit den Abmessungen von z. B. 5*5 Zeichen zusammen, dann bräuchten wir nur noch 8*5 Tiles für einen kompletten Bildschirm. Wenn wir von max. 256 Tiles ausgehen reicht ein BYTE zum Festlegen eines Tiles. Es wären dann also nur noch 40 BYTES je Bildschirm oder für die oben erwähnten zehn Schirme 400 BYTES! Natürlich ‚kosten‚ die Tiles auch noch etwas Speicher, im obigen Beispiel sind es 25 BYTES je Tile. Umso mehr Bildschirme wir aber mit den selben Tiles erstellen, desto weniger fällt dieser Speicherbedarf ins Gewicht. Die Vorteile (z. B. der geringere Speicherbedarf für einen Bildschirm) wiegen den Nachteil der eingeschränkten Flexibilität locker wieder auf.

Um nun unsere Tiles zu erstellen, können wir den Map-Editor des C64-Studios (oder einen anderen Editor) verwenden. Da wir für die Fahrstrecke aber nur wenige Tiles benötigen, verzichten wir auf einen Editor und definieren unsere benötigten Bauteile selbst.

Zunächst habe ich die Bauteile etwas überarbeitet. Es gibt jetzt gerade Stücke, sanfte und steile Abhänge und einen Schutthaufen als Hindernis.

Der überarbeitete Zeichensatz
Der überarbeitete Zeichensatz

Nun müssen wir nur einige BYTE-Anweisungen mit den Zeichencodes der Bauteile füllen, um die Tiles zu erstellen. Wie ihr im Bild seht wird der Zeichencode auch im Character-Editor angezeigt. Wir verwenden jetzt Tiles die fünf Zeichen breit und vier Zeilen hoch sind. Löschen wir zunächst die Abschnitte  demoroad, drawdemo und den dazugehörigen Aufruf jsr drawdemo ;Testausgabe wieder. Dann fügen wir die BYTE-Anweisung am Ende des Programms vor dem Einbinden des Zeichensatzes ein.

Wie ihr seht verwenden wir zunächst nur diese vier verschiedenen Tiles…

Die ersten Tiles
Die ersten Tiles

 

Jetzt stellen wir unsere Strecke mit diesen Bauteilen zusammen. Dazu legen wir wieder einige BYTES im Speicher ab. Am besten direkt vor den Tiles.

Die ersten acht BYTES reichen, um mit unseren 5*4 großen Tiles einen Streckenabschnitt zu bauen, der sich über die gesamte Bildschirmbreite erstreckt. Mit !fill sorgen wir noch für etwas mehr Platz, den wir später brauchen, ein Bildschirm ist doch etwas wenig 😉 .

Lasst uns noch drei Konstanten anlegen. Zwei in denen die Breite und Höhe (5*4) der Tiles abgelegt werden und eine als Schleifenzähler auf der Zero-Page.

Jetzt brauchen wir natürlich eine Funktion, die unsere Tiles auf den Bildschirm zaubert. Diese bringt nur die ersten acht Tiles ganz unten auf den Bildschirm. Später werden wir die Routine nochmal anpassen, aber für den Moment reicht sie.

Die Funktion initRoad setzt zu Beginn die Zeichenfarbe für die letzen vier Zeilen auf hellgrün. Dann holt sie von roadtobase die Nr. des nächsten Tiles. Dabei wird das Y-Register benutzt, um die nächste Tileposition zu bestimmen. Diese Position im Y-Register und die Tile-Nr. im X-Register werden an  drawtile übergeben, um das Tile zu zeichnen. Da wir Y als Schleifenzähler verwenden, merken wir uns den Inhalt während des Zeichnens auf dem Stack. Die Funktion zeichnet alle acht Tiles, die für die gesamte Bildschirmbreite benötigt werden und wird dann verlassen.

Die nun folgende Routine drawtile ist speziell an unsere Bedürfnisse angepasst und bringt das Tile ganz unten auf den Bildschirm.

Im Y-Register wurde die Position des Tiles übergeben. Um die Zeichen auszugeben, müssen wir natürlich noch die endgültige Bildschirmposition ermitteln. Tileposition 0 befindet sich ganz links, das nächste Tile Nr. 1 muss um die Tile-Breite verschoben werden. Seine Ausgabe beginnt also ab dem fünften Zeichen usw.

Position der Tiles ink. der einzelnen Zeichen bei Tile 0.
Position der Tiles ink. der einzelnen Zeichen bei Tile 0.

Um die Position schnell ermitteln zu können, verwenden wir die Hilfstabelle  screenposoffset in der wir zur jeweiligen Tileposition den Spaltenbeginn für die Ausgabe ablegen. Auch um die Daten für das eigentliche Tile, das im X-Register übergeben wurde, zu finden, verwenden wir eine Hilfstabelle. In  tileoffsettable steht, wieviele BYTES ab dem Label  tiles übersprungen werden müssen, um beim gesuchten Baustein zu landen. Jetzt holen wir byteweise immer das jeweilige Zeichen für alle Zeilen des Tiles und geben es aus. Dabei dient uns  ZP_LOOP auf der Zeropage als Schleifenzähler für die Anzahl der Zeichen in einer Tile-Zeile. Zum Schluß geht es zurück zum Aufrufer.

Die benötigten Hilfstabellen, können wir vom Assembler erstellen lassen. Hinter dem roadtobase Block legen wir als Erstes die Tabelle mit den Offsets für die Tiles fest.

Wir verwenden hier die Label, die wir vor die einzelnen Tiles geschrieben haben, um die zu überspringenden BYTES zu berechnen.

Direkt dahinter folgt dann die Tabelle mit den Spaltenpositionen die zur jeweiligen Tile-Position gehören.

Diese Tabelle läßt sich, dank der Schleifenmöglichkeit des Assemblers, ganz einfach erstellen.

Jetzt müssen wir vor jmp * ;Endlosschleife nur noch ein jsr initroad ;Strecke initialisieren einfügen und können das Programm endlich starten.

Die Strecke aus Tiles zusammengebaut
Die Strecke aus Tiles zusammengebaut

Eure Ausgabe kann natürlich vom obigen Bild abweichen!

Ein weiterer Vorteil, der sich durch die Verwendung von Tiles ergibt, ist, dass wir nun nur noch eine Kleinigkeit ändern müssen, um die Strecke per Zufall zu erstellen.

Fügt also erstmal die bekannte Zufallsroutine  rndTIMER zum Programm hinzu.

Jetzt passen wir noch  initroad an und fügen direkt hinter dem Label die folgenden Zeilen ein.

Wir generieren hier einfach eine zehn Bildschirme breite Strecke, indem wir uns eine Zufallszahl holen, nur die unteren zwei BITs behalten (wir brauchen ja nur die Zahlen 0 bis 3 für unsere vier Tiles) und diese Zufallszahlen dann ab  roadtobase speichern.

Schon können wir uns das Ergbnis ansehen.

Die Zufallsstrecke
Die Zufallsstrecke

Beachtet noch folgendes:

  1. Es sollte euch nicht wundern, dass die Strecke jedes Mal identisch ausehen wird, wenn wir unser Programm direkt aus der IDE mit VICE testen. Die Zeit vom Programmstart bis zur Ermittlung der ersten Zufallszahl ist einfach immer identisch. Später werden wir auf eine Bestätigung des Spielers warten, bevor wir die Strecke zusammenbauen. Dann wird der TIMER ‚zufällige‚ Werte liefern.
     
  2. Wir sollten die Strecke nicht vollkommen zufällig erstellen, da es sonst zu unspielbaren Passagen kommen kann. Schon ein nop vor jsr initroad ;Strecke initialisieren liefert folgendes unspielbares Bild (der Space-Rover würde direkt in zwei Abgründen starten).
Es wird unspielbar
Es wird unspielbar

So weit, so gut 😉 .
Als Nächstes werden wir für eine spielbare Strecke sorgen und diese zumindest zeichenweise komplett durchscrollen lassen.

Hier wie immer die Möglichkeit zum Start im Java-Emulator und der


Schrott!!Naja...Geht so...Ganz gut...SUPER! (2 Bewertungen | Ø 5,00 von 5 | 100,00%)

Loading...


 

<<< zurück | weiter >>>

 

weitersagen ...
Tweet about this on TwitterShare on FacebookShare on Google+Share on LinkedIn

3 Gedanken zu „Fahrt 003“

  1. Ha, ich habe die mehrfachen Winke mit den Zaunpfählen gesehen 🙂

    In der nächsten Version werden direkte Import-Direktiven für Zeichensätze etc. enthalten sein.

    Sehr schickes Blog, mit wunderbar detaillierten Beiträgen. Bitte Bitte bis zum Ende des Spiels durchhalten! 🙂

Schreibe einen Kommentar


Beachtet bitte, dass ich eure Kommentare erst manuell freigegeben muß, bevor sie auf der Seite erscheinen! Da ich nicht pausenlos am Rechner sitze, kann es schon mal etwas dauern, bis ein Kommentar für alle sichtbar ist.

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

Protected by WP Anti Spam