Scrolling – Laufschrift

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

CBM prg Studio
Als die Texte Laufen lernten…

Es ist langsam an der Zeit, dass wir uns mal mit dem Softscrolling beschäftigen. Laßt uns daher als erste Übung einfach mal einen Text ‚geschmeidig‚ über den Bildschirm bewegen.

Scrolling brauche ich wohl nicht mehr erklären, so bezeichnet man das Pixelweise verschieben der Anzeige, um eine flüssige Bewegung zu erzielen. Das kennt ihr aus unzähligen Spielen. Dabei unterscheidet man zwischen Horizontalem- (links/rechts), Vertikalem- (hoch/runter) und als ‚Krönung‚ dem 8-Wege-Scrolling (in ‚alle‚ Richtungen).

Unsere Laufschrift wird sich von rechts nach links über den Bildschirm bewegen, wir beginnen hier also mit dem Horizontalen-Scrolling.

 

Horizontales-Scrolling
Das VIC-II-Register 22 / $D016 ist für das Horizontale-Scrolling zuständig. Mit den unteren drei BITs läßt sich der Pixel-Offset vom linken Rand einstellen.

Was heißt das nun genau?
Dazu fangen wir mit einem kleinen Testprogramm an…

Sobald ihr das kleine Programm startet, werdet ihr keinen Unterschied zur gewohnten Anzeige sehen. Aber wir sind um eine Erkenntnis reicher, der Standard-Offset vom linken Rand beträgt 0!
Fügt hinter dem and noch ein ora #%00000001 ein, damit verschieben wir den Ausgabebereich um einen Pixel. Vergleicht ihr nun die neue Anzeige mit der gewohnten von eben, sollte ihr bemerken, dass sich der gesamte Bildschirm etwas nach rechts verschoben hat. Falls euch der Unterschied nicht direkt auffällt, erhöht den Wert hinter ora. Ihr könnt die Anzeige, durch die drei zur Verfügung stehenden BITs, um max. 7 Pixel verschieben.

Wie sich die Anzeige 'verschiebt'.
Wie sich die Anzeige ‚verschiebt‚.

Oben erkennt ihr, wie sich die Anzeige bei jedem Offset verschiebt. Außerdem nimmt sie den nächsten Schritt schon voraus. Um eine fließende Bewegung zu erziehlen, müssen wir den Offset einfach nur laufend verändern. Also passen wir unser Testprogramm entsprechend an.

Wie ihr seht, haben wir eine Variable scrollpos angelegt. Diese verwenden wir jetzt beim ora. Außerdem erhöhen wir den Wert von scrollpos laufend. Dabei sollten wir darauf achten, dass nur Werte von 0 bis 7 möglich sind, sonst setzen wir bei $D016 BITs, die wir nicht ändern möchten! Das Programm bleibt nun in einer Endlosschleife und wiederholt den obigen Block laufend.

Die Anzeige ist allerdings noch nicht wirklich zu etwas zu gebrauchen. Es läuft alles zu schnell und die Ausgabe ist verzerrt.

Die verrzerte Anzeige.
Die verrzerte Anzeige.

Die Anzeige ist verzerrt, da wir unkontrolliert den Offset für das Horizontale-Scrolling ändern, damit erhält jede Zeile einen neuen Offset und wird verschoben. Dies können wir später für Effekte nutzen, aktuell möchten wir aber den gesamten Bildschirm ‘sauber‚ verschieben. Wir sollten also unsere Änderungen am Scrollregister mit dem Bildschirmaufbau synchronisieren. Dazu bauen wir direkt hinter sta $D016 ;und zurück ins VIC-II-Register schreiben eine kleine Warteschleife ein…

Mit dem obigen Block können wir, ohne extra einen Rasterzeileninterrupt einzurichten, auf das Erreichen einer bestimmten Rasterzeile warten, um unser Timing zu erzielen. Wir holen uns die gewünschte Rasterzeile einfach in den Akku und vergleichen diese mit der aktuellen Zeile. Sollte diese bereits die von uns gewünschte Zeile sein, dann warten wir, bis die Zeile verlassen wird. Anschließend warten wir solange, bis unsere gesuchte Rasterzeile wieder erreicht wird.

Jetzt sollte eure Ausgabe ‚annehmbar‚ sein. Die Ausgabe wird immer um max. 7 Pixel gescrollt und springt dann zum Offset 0 zurück.

 

Wie mehr als 7 Pixel scrollen?
Da schon nach sieben Pixeln schluß mit dem Scrolling ist, stellt sich nun die Frage, wie wir größere Bereiche bewegen. Nun es trifft sich doch gut, dass beim C64 alles, was mit der Anzeige zu tun hat, in 8*8 Pixel große Blöcke unterteilt ist. Ein Zeichen ist bekanntlich auch 8-Pixel breit. Wir müssen also die Anzeige mit dem Offset verschieben und immer wenn wir den Offset wieder zurückstellen, müssen wir den gesamten Bildschirminhalt um ein Zeichen umkopieren.

Wir wollen gleich nur eine Laufschrift erzeugen, daher müssen wir nicht den gesamten Bildschirm umkopieren. Wir beschränken uns auf die vierte Zeile, in der normalerweise 64K RAM SYSTEM... steht. Dort zeigen wir gleich unsere Laufschrift an, aber als Erstes wollen wir die Systemmeldung mal als Test vom Bildschirmscrollen lassen.

Fügt hinter das jmp main ;auf ein Neues die neue Funktion moverow ein.

Wir beginnen hier am rechten Bildschirmrand und kopieren immer das vorherige Zeichen ins aktuelle um. Es wird also das Zeichen in Spalte 39 nach 40 kopiert, dann 38 nach 39, 37 nach 38 usw.

Die Funktion müssen wir nun immer aufrufen, wenn der Offset zurück auf 0 springt. Dies erreichen wir durch die folgenden beiden Zeilen, die direkt vor jmp main ;auf ein Neues eingefügt werden.

Das bne main ‚reagiert‚ direkt auf die davor von uns veränderte scrollpos und springt immer zu main, solange der Offset ungleich 0 ist. Sobald er aber null erreicht, wird jsr moverow ;sonst die Zeile umkopieren ausgeführt.

Startet das Programm und ihr sollte sehen wie sich die 64K RAM SYSTEM...-Zeile nach rechts aus dem Bildschirm herausbewegt.

Die 64K-Zeile scrollt 'soft' heraus.
Die 64K-Zeile scrollt ‘soft‚ heraus.

Da wir nur eine Zeile umkopieren, zuckelt der Rest des Bildschirms natürlich immer noch wild herum.

Eine Kleinigkeit möchte ich noch erwähnen, wir fügen links keine ‚frischen‚ Zeichen ein, damit wird das links stehende Zeichen immer mitkopiert. Eben sah es nur ‚gut‚ aus, da das erste Zeichen ein Leerzeichen ist, aber wehe es steht etwas Anderes an der ersten Stelle!

Das Problem mit der ersten Zeichen.
Das Problem mit der ersten Zeichen.

Hier habe ich mal ein  X an die erste Stelle geschrieben. Wie ihr seht, wird dies laufend umkopiert. Wir müssen also beim umkopieren auch noch dafür sorgen, dass an der ersten Stelle ein neues Zeichen eingefügt wird. Darum kümmern wir uns gleich, jetzt wollen wir erstmal die Richtung umkehren, schließlich liest sich unsere Laufschrift besser, wenn sie von rechts nach links scrollt.

Um die Richtung zu ändern müssen wir den Offset nur, statt von 0 nach 7 hochzählen, einfach von 7 nach 0 runterzählen. Außerdem müssen wir natürlich noch moverow so ändern, dass nun Spalte 2 nach 1, 3 nach 2, 4 nach 3 usw. umkopiert wird.

Hier das komplette Programm (die Änderungen sind gelb markiert)…

Die Änderungen sind so minimal, dass sie wohl keiner weiteren Worte bedürfen. Das Programm ‘scrollt‚ nun in die andere Richtung.

In die andere Richtung scrollen.
In die andere Richtung scrollen.

 

Die letzten Schritte zur Laufschrift

Wir haben uns nun fast alle Voraussetzungen für eine Laufschrift erarbeitet, also zaubern wir doch endlich unsere Nachricht an die Welt auf den Bildschirm. 😉
Dazu legen wir erstmal unseren Text ab. Ich würde vorschlagen, wir markieren das Textende wieder mit $00. Fügt also euren Text am Ende des Programms ein, außerdem brauchen wir noch eine Variable, die auf das nächste Zeichen aus  scrolltext zeigt.

Diesen Text fügen wir jetzt Zeichen für Zeichen am rechten Bildschirmrand ein, jedes Mal nach dem wir  jsr moverow ;sonst die Zeile umkopieren aufgerufen haben. Ergänzt das Programm direkt dahinter um den folgenden Block…

Wir holen hier also, die Position des nächsten Zeichens aus scrolltext ins X-Register und laden damit das Zeichen in den Akku. Ist es $00, dann springen wir nach @skip, um die Position wieder auf 0 zu stellen. Sonst geben wir das Zeichen am rechten Rand der vierten Zeile auf dem Bildschirm aus. Dann erhöhen wir die Position im X-Register und speichern diese für den nächsten Durchlauf. Schließlich geht es wieder zurück zu main.

Bevor wir das Programm starten sollten wir noch den Bildschirm löschen, fügt also vor main noch diese zwei Zeilen ein.

Wenn ihr nun das Programm startet, läuft euer Text sanft über den Bildschirm. Es gibt allerdings noch einen letzten kleinen Punkt, um den wir uns kümmern sollten.

Um den linken Rand sollten wir uns noch kümmern.
Um den linken Rand sollten wir uns noch kümmern.

Wenn ihr den linken Rand beobachtet, dann seht ihr, dass die Zeichen einfach vom Bildschirm verschwinden. Es wäre doch schöner, wenn sie aus dem Bildschirm heraus scrollen. Dies ist nur durch einen ‚Trick‚ möglich, da wir keine Zeichen in den Rahmen verschieben können. Ihr habt euch evtl. schon über die Möglichkeit gewundert, warum man die Anzeige zwischen 40 und 38 Zeichen umschalten kann. Welchen Sinn soll dies wohl haben? Nun genau damit können wir unsere Buchstaben aus der Laufschrift sauber vom Bildschirm verschwinden lassen. Die Umschaltung bewirkt nämlich nicht, dass wir nur noch 38 Zeichen zur Verfügung haben! Es wird einfach der Rahmen um ein Zeichen weiter nach innen gezogen, sodass nur 38 Zeichen sichtbar sind. Dazu müssen wir nur unser and #%11111000 ;BITs für den Offset vom linken Rand löschen so ändern, dass auch BIT-3 gelöscht wird. Dazu reicht es einfach and #%11110000 zu verwenden.

Startet ihr jetzt das Programm, dann verschwinden die Zeichen unter dem Rahmen und die Laufschrift sieht ‘sauber‚ aus.

Die Buchstaben verschwinden unter dem Rand.
Die Buchstaben verschwinden unter dem Rand.

 


Damit sind wir am Ende angelangt. Natürlich könnt ihr das Programm noch beschleunigen, durch die Verringerung der Anzeigen, müssten jetzt z. B. weniger Zeichen kopiert werden. Natürlich funktioniert das Scrolling nicht nur im einfachen Textmodus, außerdem müsst ihr ggf. noch das Farb-RAM umkopieren, dies hängt halt ganz von euren Gegebenheiten ab.

Wollt ihr größere Bereiche scrollen, dann müsst ihr statt einer Zeile einfach mehrere bzw. alle um kopieren.

Um die ganze Sache etwas aufzupeppen, könnt ihr z. B. Rasterzeilen-Interrupts und Color-Cycling einsetzen. Wie das aussehen kann zeigt das folgende Bild, ihr könnt es auch im Java-Emulator in Aktion erleben und euch als D64-Image herunterladen.

Scrolling + Raster-IRQ + Color-Cycling
Scrolling + Raster-IRQ + Color-Cycling

Beachtet die ‚Sternchen‚-Zeile, die obere und untere Hälfte werden in die entgegengesetzte Richtungen gescrollt. Außerdem ist der Zeichensatz im unteren Bereich für den zurücklaufenden Text gespiegelt.
 


Schrott!!Naja...Geht so...Ganz gut...SUPER! (9 Bewertungen | Ø 4,78 von 5 | 95,56%)

Loading...


 

<<< zurück |

 

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

2 Gedanken zu „Scrolling – Laufschrift“

  1. Hallo Björn,

    könntest Du vielleicht kurz erklären, was der Befehl beq *-3 macht. BEQ ist ein Vergleichsbefehl (Branch wenn gleich), aber das *-3 dahinter kann ich nicht nachvollziehen.

    1. Damit wird die Zieladresse berechnet.

      Der Stern „*“ steht für den aktuellen Programm-Counter. Der Assembler zieht hier, bei der Programmerstellung, also vom PC einfach 3 (drei BYTES für den vorangegangenen CMP $D012-Befehl) ab und berechnet auf dieser Basis dann die Sprungweite für den bedingten Sprung.

      Damit kann man Sprung-Label einsparen.
      Ohne diese schreibweise, müsste der Block z. B. so aussehen:

      loop1
      cmp $D012 ;mit der aktuellen Rasterzeile vergleichen
      beq loop1 ;statt *-3
      loop2
      cmp $D012 ;wieder mit der aktuellen Zeile vergleichen
      bne loop2 ;statt *-3

      Aber Vorsicht: Wirklich Sinn macht das nur bei sehr kurzen Schleifen, wie hier! Es besteht die Gefahr, dass man Befehle einfügt und der Sprung dann im Nirvana landet.

      Gruß,
      Jörn

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