Benutzername
Passwort
C64 < Hauptseite < BASIC V2.0 < Sprites
📑
📘
Sprites sind freibewegliche Objekte, die sich problemlos über den Bildschirm bewegen oder an jeder beliebigen Stelle anzeigen lassen. Es gibt Soft- und Hardware-Sprites, wobei wir uns hier auf die Hardware-Sprites konzentrieren. Diese werden direkt von den Chips des Computers bereitgestellt.

Allerdings können Sprites nur im Hauptbereich des C64-Bildschirms angezeigt werden, da sie hinter dem Rahmen verschwinden. Wenn man jedoch ausgefeilte Assembler-Tricks anwendet, kann man z.B. den Rahmen ausblenden und somit auch Sprites in diesem Bereich sichtbar machen.

Beim C64 gibt es zwei verschiedene „Arten“ von Hardware Sprites:

HiRes-Sprites:
Sind einfarbig und es steht pro Sprite nur eine Farbe für alle sichtbaren Punkte zur Verfügung. Nicht gesetzte Punkte sind transparent und an diesen Stellen ist der Hintergrund sichtbar. Ein HiRes-Sprite besteht aus 24 Punkten in der X-Richtung (Breite/horizontal) und aus 21 Zeilen in der Y-Richtung (Höhe/vertikal).

Multi-Color-Sprites:
Multi-Color-Sprites sind Sprites, die mehrere Farben verwenden können. Neben der Transparenz für nicht gesetzte Punkte können drei verschiedene Farben verwendet werden. Allerdings sind zwei dieser Farben für alle Multi-Color-Sprites, die Sie einsetzen, identisch! Nur eine Farbe lässt sich individuell für jedes Multi-Color-Sprite festlegen.
Es gibt jedoch einen Preis für diese Farboptionen: Die Auflösung in der X-Richtung (Breite / horizontal) wird halbiert. Ein Multi-Color-Sprite besteht daher nur aus 12 Punkten in der X-Richtung, während es in der Y-Richtung (Höhe / vertikal) bei 21 Zeilen bleibt.

Unter Assembler werden wir uns jedoch genauer mit Multi-Color-Sprites befassen.

Die Sprites des C64 sind standardmäßig auf 8 Stück begrenzt, von 0 bis 7 durchnummeriert. Doch unter Assembler kann man durch entsprechende Tricks (z.B. Rasterzeilen-Interrupts oder Sprite-Multiplexing) mehr Sprites darstellen. Was die Sprites damals besonders machte, war die Tatsache, dass man sich keine Gedanken über den Hintergrund machen musste. Der Grafik-Chip VIC (Video Interface Controller) "speichert" automatisch alles, was vom Sprite verdeckt wurde, und stellt es wieder her, sobald das Sprite verschwindet. Zudem ist eine Hardware-Kollisionserkennung sowohl zwischen Sprites als auch zwischen Sprites und dem Hintergrund möglich.
Als erstes sollten wir das Aussehen unseres Sprites festlegen. Für dieses Beispiel nehmen wir einen Smiley. Eine Möglichkeit, das Sprite zu zeichnen, wäre auf Karopapier.

Das könnte dann etwa so aussehen:
Um die Bytes für unser Sprite zu ermitteln, gehen wir nun Zeile für Zeile (1-21) vor und interpretieren die jeweiligen Blockabschnitte (1-3) als Binärzahl (siehe Binäres Zahlensystem). Ein X bedeutet dabei, dass das entsprechende Bit auf 1 gesetzt wird. Die so entstehenden Binärzahlen wandeln wir anschließend in das Dezimalsystem um, um die Byte-Werte zu erhalten.
In das Dezimalsystem umrechnen:
Wert 128 64 32 16 8 4 2 1
Bit 0 X X 0 X X X 0
Bit 0 X X X 0 X X 0
Bit X X X X X 0 X X

Summe 64 + 32 + 8 + 4 + 2 = 110
Summe 64 + 32 + 16 + 4 + 2 = 118
Summe 128 +64 + 32 + 16 + 8 + 2 + 1 = 251

Diese Zahlen notieren wir neben jeder Zeile…
Die ermittelten Zahlen können wir später direkt in unser BASIC-Programm übernehmen.

Als Alternative zur manuellen Ermittlung der Zahlenwerte für unser Sprite können wir auch einen Sprite-Editor nutzen. Ein Sprite-Editor ist ein Programm, mit dem wir unsere Sprites grafisch gestalten können. Es gibt viele verschiedene Sprite-Editoren, von einfachen Text-Editoren mit Sprite-Funktionalität bis hin zu spezialisierten Grafik-Editoren für den C64. Einige der bekanntesten sind C64 Studio, SpritePad und CharPad. Wenn wir unser Sprite mit einem solchen Editor erstellen, können wir die ermittelten Zahlen direkt in unser BASIC-Programm übernehmen. Das spart uns Zeit und reduziert das Risiko von Fehlern beim manuellen Ermitteln der Zahlen.
Lassen wir uns zunächst damit beginnen, das Sprite im Speicher zu schreiben und in einer SEQ-Datei zu sichern:
jetzt abtippen
10000 DATA 0,255,0
10001 DATA 3,255,192
10002 DATA 7,255,224
10003 DATA 15,255,240
10004 DATA 31,255,248
10005 DATA 28,255,56
10006 DATA 56,126,28
10007 DATA 56,126,28
10008 DATA 120,110,30
10009 DATA 123,118,222
10010 DATA 124,251,62
10011 DATA 127,251,254
10012 DATA 127,243,254
10013 DATA 63,255,252
10014 DATA 63,255,252
10015 DATA 31,255,248
10016 DATA 31,0,248
10017 DATA 15,129,240
10018 DATA 7,255,224
10019 DATA 3,255,192
10020 DATA 0,255,0
speichern nicht vergessen😇
und jetzt
10 REM ++++++++++++++++++
11 REM SPRITE SPEICHERN
12 REM ++++++++++++++++++

20 INPUT "GEBEN EIN DATEINAMEN EIN:";NA$

50 OPEN 1,8,2,NA$+",S,W"
55 FOR X=0 TO 62
60 READ B%
65 PRINT#1,CHR$(B%)
70 NEXT
75 CLOSE 1

500 END
Gehen wir die Zeilen noch mal druch:
Zeile 10 - 12
10 REM ++++++++++++++++++
11 REM SPRITE SPEICHERN
12 REM ++++++++++++++++++

Diese Befehle sind eigentlich selbsterklärend. Alles, was nach dem Befehl "REM" steht, ist ein Kommentar und wird von BASIC ignoriert.

Zeile 20
20 INPUT "GEBEN EIN DATEINAMEN EIN:";NA$

Hier wird der Benutzer mittels des INPUT-Befehls nach einem Dateinamen gefragt, der dann in der String-Variable NA$ gespeichert wird. Eine mögliche Ergänzung wäre eine Überprüfung auf korrekte Eingabe oder existierende Dateinamen, dies ist aber optional und ist euch überlassen.😄

Zeile 50
50 OPEN 1,8,2,NA$+",S,W"

Diesei Zeile kann man so lesen:
🖛 Öffne mit der Dateinummer 1,
🖛 Das Diskettenlaufwerk 8,
🖛 Über den Kanal 2,
🖛 Und übergebe den Befehlsstring (unser Dateiname NA$+" Dateityp S,mit SchreibrechteW".

Das Ergebnis ist jetzt, dass wir eine Datei erstellt haben und diese über die Dateinummer 1 beschreiben können.

Zeile 55 - 70
55 FOR X=0 TO 62
60 READ B%
65 PRINT#1,CHR$(B%)
70 NEXT

In Zeile 55 verwenden wir eine FOR-Schleife, um von 0 bis 62 zu zählen und alles, was folgt, zu wiederholen.

In Zeile 60 lesen wir den ersten Wert aus unserer DATA-Zeile aus und speichern ihn in der Ganzzahl-Variablen B% ab.

In Zeile 65 verwenden wir den PRINT#1-Befehl, um über den offenen Dateinummern 1 das Zeichen zu drucken, das sich hinter der Nummer in der ersten DATA-Zeile befindet (CHR$() ist eine Funktion, die eine Dezimalzahl als Parameter nimmt und ein Hex-Werte (Binärzahlen) zurückgibt. Zum Beispiel gibt CHR$(255) = $FF oder auch %1111 1111.

In Zeile 70 erhöhen wir den Wert in X mit NEXT um 1 und wiederholen den Vorgang ab Zeile 55, indem wir das nächste Zeichen aus der DATA-Zeile lesen und es auf unsere Diskette drucken.

Zeile 75
75 CLOSE 1

In Zeile 75 schließen wir die Verbindung zu unserer Datei auf dem Diskettenlaufwerk.

Jetzt haben wir unseren Smiley erfolgreich unter dem eingegebenen Dateinamen auf der Diskette abgespeichert.
Jetzt werden wir anfangen unser Sprite (Smylie) auszugeben.
10 REM+++++++++++++++++
20 REM SB%=0-255
30 REM+++++++++++++++++
40 SB%=13
50 REM+++++++++++++++++
60 SP=SB%*64: VIC = 53248: SN%=0
61 Z$=CHR$(0)

70 REM+++++++++++++++++
80 INPUT "DATEINAMEN EINGEBEN:";NA$
99 REM+++++++++++++++++

100 OPEN 2,8,2,NA$+",R"
105 I%=0:CK=1
110 FOR C=0 TO 1
120 GET#2,A$
125 AI = ASC(A$+Z$)
130 POKE SP+I%,AI :I%=I%+1
140 C=ABS(ST)
150 NEXT C
160 CLOSE 2

199 REM+++++++++++++++++
200 POKE VIC+21,2SN%
210 POKE 2040+SN%,SB%
220 XP=(320-24)/2+24 : YP=(200-21)/2+50
230 POKE VIC+SN%,XP
240 POKE VIC+1+SN%,YP
Gehen wir mal alle Zeilen durch:
40 SB%=13

in Zeile 40
SB%=13 :
Durch die Festlegung des Speicherblocks merken wir uns, wo der VIC unsere Spritedaten ablegen und später finden kann. Ein Spriteblock umfasst 64 Byte (3 Byte (3*8 Bit = 24 Punkte in der Horizontale) * 21 Zeilen = 63 Byte + 1 Byte als Platzhalter). Zusammen mit dem Byte für den Speicherblock ergeben sich somit 256 * 64Byte = 16kb Speicher, in denen wir unsere Daten ablegen können. Es ist jedoch wichtig, unter BASIC sorgfältig zu sein und darauf zu achten, dass wir keinen Speicherbereich nutzen, der von BASIC selbst benötigt wird. Der 13. Block, der sich im Kassettenpuffer befindet, kann hier sicher verwendet werden.

60 SP=SB%*64: VIC = 53248: SN%=0

In Zeile 60
SP=SB%*64 :
Hiermit berechnen wir die Speicherposition, an der wir unsere Spritedaten ablegen möchten. Dazu multiplizieren wir wie zuvor die Nummer des Speicherblocks (hier 13) mit 64 (maximal 64 Byte pro Sprite) und erhalten so in diesem Beispiel die Zahl 832. Demnach werden unsere Spritedaten ab der 832. Speicherstelle zu finden sein.

VIC=53248 :
Hier wird VIC als Fließkommazahl verwendet, da 53248 den Wertebereich einer Ganzzahl überschreitet. Die Zahl 53248 bzw. $D000 ist die Basisadresse des VIC. Gleich werden wir auf einzelne VIC-Registerhttps://www.c64-wiki.de/wiki/VIC zugreifen, indem wir zu dieser Basisadresse die Nummer des entsprechenden Registers addieren.

SN%=0 :
Dort ist die Information gespeichert, welches Sprite im Moment verwendet wird. In unserem Fall wird das erste Sprite mit der Nummer 0 verwendet.

Z$=CHR$(0) :
Hier wird das Zeichen 0 zwischengespeichert. Beachten Sie, dass die ASC-Funktion möglicherweise Fehler verursachen kann und wir diese berücksichtigen müssen, indem wir sie an unsere mit GET ausgelesenen Daten anhängen.

80 INPUT "DATEINAMEN EINGEBEN:";NA$

in Zeile 80
Hier fordern wir den Benutzer auf, den Namen der Datei einzugeben, die später eingelesen werden soll.

ab Zeile 100 - 160
100 OPEN 2,8,2,NA$+",R"
105 I%=0
110 FOR C=0 TO 1
120 GET#2,A$
125 AI = ASC(A$+"0")
130 POKE SP+I%,AI :I%=I%+1
140 C=ABS(ST)
150 NEXT C
160 CLOSE 2

In Zeile 100
🖛 Öffne mit der Dateinummer 2,
🖛 Das Diskettenlaufwerk 8,
🖛 Über den Kanal 2,
🖛 Und übergebe den Befehlsstring (unser Dateiname NA$+",mit LesezugriffR".

In Zeile 105
I%=0 :
Damit merken wir uns die Speicherposition.

Zeile 110,140 und 150
110 FOR C=0 TO 1
...
140 C=ABS(ST)
150 NEXT C
Wir wiederholen die FOR-Schleife solange, bis das Ende der Datei erreicht wurde.

Zeile 120 bis 130
120 GET#2,A$
125 AI = ASC(A$)
130 POKE SP+I%,AI :I%=I%+1

Hier wird mit GET#2 ein Byte aus der Datei gelesen und in der Variable A$ gespeichert. Dann wird das Zeichen mit ASC(A$) in eine Dezimalzahl umgewandelt (z. B. wird $FF zu 255). Anschließend wird der Wert in AI an der Speicherstelle (SP) + I% gespeichert, und die Speicherposition I% um 1 erhöht.

In Zeile 160
110 CLOSE 2

In Zeile 75 schließen wir die Verbindung zu unserer Datei auf dem Diskettenlaufwerk.

Sprite Anzeigen

200 POKE VIC+21,2SN%
210 POKE 2040+SN%,SB%
220 XP=(320-24)/2+24 : YP=(200-21)/2+50
230 POKE VIC+SN%,XP
240 POKE VIC+1+SN%,YP

In Zeile 200
In dieser Zeile setzen wir das erste Sprite (Bit 0) auf der Adresse 53248+21 (jedes Bit entspricht einem Sprite-Schalter) durch das Setzen des Wertes 1 (2(Potenzieren)0 = 1).

In Zeile 210
In dieser Zeile schreiben wir an der Adresse 2040+0(Spritepointerhttps://www.c64-wiki.de/wiki/Bildschirmspeicher für Sprite 0), den Wert 13
( Blocknr. = 13 (13*64=832, in hex: $0340))

In Zeile 220
220 XP=(320-24)/2+24 : YP=(200-21)/2+50
Wir berechnen die Mitte des Bildschirms, wobei wir berücksichtigen müssen, dass Sprites vom Rahmen verdeckt werden können. Der C64 hat eine Auflösung von 320 x 200 Pixeln. Die linke obere Ecke befindet sich bei X=0 und Y=0, die rechte untere Ecke bei X=319 und Y=199. Der Rahmen des Bildschirms ist links 24 Pixel breit und oben 50 Pixel hoch. Um das Sprite in der Mitte des Bildschirms zu platzieren, müssen wir die Breite und Höhe des Sprites berücksichtigen. Wir berechnen die X-Position mit der Formel (Bildschirmbreite - Spritebreite) / 2 + Rahmenbreite_links und die Y-Position entsprechend.

Zeile 230 und 240
230 POKE VIC+SN%,XP
240 POKE VIC+1+SN%,YP

Und zum Schluss schreiben wir in den VIC die Spriteposition für das 0 Sprite.
Okay, aber sieht das jetzt aus wie ein Smiley oder nicht?
Noch eine Besonderheit gibt es beim Einlesen mit GET#: Wir können den Wert, den wir aus der Datei auslesen, mit PRINT AI überprüfen:
Um das zu übersetzen, steht dort "0", "return", "255", "return", "0", "return", ... Das bedeutet, dass jeder zweite Wert (die "return"-Werte) übersprungen werden müssen.
10 REM+++++++++++++++++
20 REM SB%=0-255
30 REM+++++++++++++++++
40 SB%=13
50 REM+++++++++++++++++
60 SP=SB%*64: VIC = 53248: SN%=0
61 Z$=CHR$(0)

70 REM+++++++++++++++++
80 INPUT "DATEINAMEN EINGEBEN:";NA$
99 REM+++++++++++++++++

100 OPEN 2,8,2,NA$+",R"
105 I%=0:CK=1
110 FOR C=0 TO 1
120 GET#2,A$
125 AI = ASC(A$+Z$)
126 IF CK = 0 THEN CK = 1: GOTO 140
130 POKE SP+I%,AI :I%=I%+1
131 CK=0
140 C=ABS(ST)
150 NEXT C
160 CLOSE 2

199 REM+++++++++++++++++
200 POKE VIC+21,2SN%
210 POKE 2040+SN%,SB%
220 XP=(320-24)/2+24 : YP=(200-21)/2+50
230 POKE VIC+SN%,XP
240 POKE VIC+1+SN%,YP
Herzlichen Glückwunsch! Du hast erfolgreich die Grundlagen von BASIC auf dem C64 erlernt. Nun geht es weiter mit der aufregenden Welt des Assembler-Programmierens!

Assembler-Programmierung ist eine höhere Form des Programmierens und erfordert ein tiefes Verständnis der Funktionsweise des Computers. Das Programmieren in Assembler bietet jedoch auch enorme Vorteile wie eine bessere Performance und eine direkte Kontrolle über die Hardware des Computers.

In den kommenden Lektionen werden wir uns mit der Assembler-Programmierung auf dem C64 befassen und lernen, wie wir die Leistung des Computers maximieren können. Also, mach dich bereit für eine aufregende Reise durch die Welt des Maschinencodes!
von:
Betreff :
von:
Impressum / sitemap.xml
version 1.0 © 2022-2026, www.retro-archiv.de Rechte vorbehalten