Nyquist at 23:16, 17 January 2011

2011-01-17T23:16:53Z

Nyquist at 11:39, 13 June 2010

2010-06-13T11:39:49Z

New page

[http://translate.google.com/translate?hl=de&ie=UTF-8&sl=de&tl=en&u=http://c64mags.untergrund.net/wiki/index.php%3Ftitle%3DDT_85_15&prev=_t English Translation]
<pre>
Hallo liebe DT-Leser,
_______________________

es ist mal wieder soweit, ein neues Pro-
gramm erwartet Euch in der DT Ass-Ru-
brik. Wie beim ersten Teil geht es auch
heute noch einmal um das Thema Lauf-
schrift. Nur unterscheidet sich die
Technik, die ich diesmal verwendet habe,
von der aus dem ersten Teil nicht uner-
heblich. Heute will ich Euch mal zeigen,
wie man eine Laufschrift in einem Sprite
verarbeiten kann. Das Thema lautet somit

"SPRITE-SCROLLER"
"SPRITE-SCROLLER"
</pre>
<pre>
Die Technik, die dahinter steckt, ist
eigentlich trivial, vorausgesetzt, man
weiß, wie ein Sprite aufgebaut ist und
wie man Sprites anzeigen und manipulie-
ren kann. Eingefleischte Basicprogram-
mierer werden hier keine Schwierigkeiten
haben.

Dieser Effekt lässt sich jedoch nur ra-
tional in Maschinensprache realisieren,
Basic ist dafür einfach zu langsam. Auch
diesmal läuft die Laufschrift im IRQ ab.

Es ist ratsam, sich das Programm vorher
mal anzusehen, damit Ihr auch wisst, wo-
von ich hier rede. ;)
</pre>
<pre>
Gut, die Laufschrift läuft in einem
Sprite bzw. "durch" mehrere Sprites. Es
ist also nicht so, dass jedes Sprite ei-
nen Buchstaben darstellt und der Lauf-
schrift-Text einfach durch diese durch-
gerollt wird (das ist eine weitere Mög-
lichkeit für eine Laufschrift). Hier be-
nutzen wir einen normalen 1x1-Zeichen-
satz, in diesem Fall den des C64, den
ROM-Zeichensatz, den wir dann von rechts
nach links durch 8 Sprites durchrollen
lassen.

Ein Sprite besteht aus 64 Bytes. Füllt
man ein Sprite mit z.B. dem Wert 255, so
geschieht das von links nach rechts (und
</pre>
<pre>
nicht wie im Hires-Modus von oben nach
unten). Um nun z.B. den Buchstaben "A"
(Wert $01) in ein Sprite zu übertragen,
so geschieht dies folgendermaßen:

Sprite liegt ab: $2000
Buchstabe A ab: $3000 (nur Beispiele)

ldy #$00
ldx #$00
a1 lda $3000,y
sta $2000,x
inx
inx
inx
iny
</pre>
<pre>
cpy #$08
bne a1
rts

Hier seht Ihr, dass man jedes Byte des
Buchstabens in jede dritte Speicherstel-
le des Sprites schreiben muss, um den
Buchstaben ordentlich im Sprite darzu-
stellen. Im normalen Modus sind nur 8
Sprites erlaubt, also verwenden wir auch
alle für die Laufschrift.

In jedes Sprite passen jeweils 3 Buch-
staben.
Diese befinden sich im oberen Bereich
der Sprites, den ersten 24 Bytes.
</pre>
<pre>
Sprite1 Sprite2 Sprite3 Sprite4 Sprite5
ABC DEF GHI JKL MNO
Sprite6 Sprite7 Sprite8
PQR STU VWX

Der Laufschrifttext würde dann hier so
aussehen:

ABCDEFGHIJKLMNOPQRSTUVWX

Die Laufschrift kann somit nur aus max.
24 sichtbaren Zeichen bestehen. Der Text
an sich kann so lang sein wie man ihn
braucht.

Dazu später mehr im Code.
</pre>
<pre>
Das Prinzip dahinter sollte jetzt ei-
gentlich klar sein, zumindest wie die
Zeichen in den Sprites erscheinen sol-
len.

Die Technik, die dahinter steckt, ist
simpel:
Die Zeichen bzw. die Bits der Zeichen
werden mit dem Befehl ASL von rechts
nach links einfach durch die Sprites ge-
rollt. Dabei muss auf das Carry-Flag ge-
achtet werden, damit die Bits auch or-
dentlich transportiert werden. Dazu nun
im Programm mehr, dabei werde ich jedoch
nur im Kern des Programms etwas ausführ-
licher:
</pre>
<pre>
*= $0810

lda #1
sta $d011
lda #0
sta $d020
sta $d021
lda #15
sta $0286
lda #$93
jsr $ffd2
lda #26
sta $d018
lda #$08
jsr $ffd2
</pre>
<pre>
> Bildschirmeinstellungen.

ldy #$00
a1 lda screen,y
sta $0400,y
lda screen+256,y
sta $0500,y
lda screen+512,y
sta $0600,y
lda screen+768,y
sta $0700,y
iny
bne a1

> Der Bildschirm wird mit den Daten aus
> dem Label "Screen" gefüllt.
</pre>
<pre>
ldy #$00
lda #11
a2 sta $d800+(5*40)+9,y
sta $d800+(6*40)+9,y
sta $d800+(7*40)+9,y
iny
cpy #$16
bne a2

> Das "Digital Talk"-Logo wird auf dem
> Bildschirm positioniert.

ldy #$00
lda #$ff
a3 sta $2ff8,y
iny
</pre>
<pre>
cpy #$08
bne a3

> Der Zeichensatz für das Logo steht ab
> $2800 (s.u.). Hier wird ein Zeichen
> gefüllt und zwar das letzte Zeichen
> des Zeichensatzes.

sei
lda #$33
sta $01
ldy #$00
a4 lda $d000,y
sta $3000,y
lda $d100,y
sta $3100,y
</pre>
<pre>
lda $d200,y
sta $3200,y
lda $d300,y
sta $3300,y
lda #0
sta $2000,y
sta $2100,y
iny
bne a4
lda #$37
sta $01
cli

> Der ROM-Zeichensatz respektive ein
> Teil davon wird nach $3000 kopiert.
> Dieser wird für die Laufschrift
</pre>
<pre>
> benötigt. Die Sprites stehen ab $2000,
> dieser Bereich wird mit #0 gefüllt.

lda #$00
sta $57
sta $58
sta $5a
sta $5b
sta $5c

> Speicherstellen und Zähler werden
> freigemacht.

lda #255
sta $d000+21
</pre>
<pre>
ldy #$00
ldx #128
a5 txa
sta 2040,y
lda #15
sta $d000+39,y
inx
iny
cpy #$08
bne a5

ldx #87
stx $d000
ldx #87+(1*24)
stx $d002
ldx #87+(2*24)
</pre>
<pre>
stx $d004
ldx #87+(3*24)
stx $d006
ldx #87+(4*24)
stx $d008
ldx #87+(5*24)
stx $d00a
ldx #87+(6*24)
stx $d00c
ldx #87+(7*24)
stx $d00e

> Bis hier werden die Sprites
> eingeschaltet und auf dem Bildschirm
> positioniert. Auch wird die Farbe auf
> Hellgrau gesetzt ($0f = #15).
</pre>
<pre>
jsr irq

jmp *

> Der IRQ wird angesprungen, danach wird
> mit JMP * das Programm quasi
> angehalten. Alles, was man dann sieht,
> läuft ausschließlich im IRQ ab.

irq sei
lda #$81
sta $d01a
lda #$7f
sta $dc0d
lda #$00
sta $d012
</pre>
<pre>
ldx #<irq1
ldy #>irq1
stx $0314
sty $0315
cli
lda #27
sta $d011
rts

irq1 asl $d019

> Hier die bekannten Einstellungen für
> den IRQ. Ich hoffe, da nichts mehr
> erklären zu müssen.

jsr sprmove
</pre>
<pre>
> Hier wird für die vertikale Bewegung
> des Sprite-Scrollers eine kleine
> Routine angesprungen, die für die
> nette Hüpfbewegung des Scrollers
> verantwortlich ist. Dieser Sprite-
> Sinus wurde mir von dflame zur
> Verfügung gestellt. Herzlichen Dank
> nochmal!! :)

irqq lda $58
bne irq2

ldy #$30
ldx #$00
stx $fa
sty $fb
</pre>
<pre>
inc $58
lda #$00
sta $02
irq02 ldy $57
lda txt,y
bne irq01
lda #$00
sta $57
jmp irq02
irq01 inc $57
asl
rol $02
asl
rol $02
asl
rol $02
</pre>
<pre>
clc
adc $fa
sta $fa
lda $02
adc $fb
sta $fb

ldy #$00
irq0 lda ($fa),y
sta $02c0,y
iny
cpy #$08
bne irq0

> Jetzt gehts ins Eingemachte. Hier
> werden die Zeichen berechnet und
</pre>
<pre>
> zwischengespeichert. Der Text der
> Laufschrift steht ab Label "txt".
> Von dort wird ein Zeichen gelesen und
> danach berechnet, wo dieses Zeichen
> sich in unserem zuvor kopierten ROM-
> Zeichensatz befindet. Dafür muss man
> den Wert des Zeichens * 8 nehmen und
> den Wert zu $3000 rechnen ($fa/$fb).
> Am Ende wird das aktuelle Zeichen nach
> $02c0-$02c7 geschrieben. Dort kann es
> dann gleich verändert werden. Diese
> Zwischenspeicherung ist notwendig,
> weil wir ja sonst nach jedem Zeichen
> den ROM-Zeichensatz neu kopieren
> müssten, weil jedes Zeichen durch den
> ASL-Befehl gleich geleert wird.
</pre>
<pre>
> Der Wert in $5a wird übrigens von 0
> auf 1 gestellt, weil ja nicht nach
> jedem Durchgang ein neues Zeichen
> berechnet werden darf, sondern erst,
> wenn alle 8 Bits eines Zeichens
> abgearbeitet wurden.

irq2 ldy #$00
ldx #$00
irq4 asl $02c0,x
bcc irq3
lda #$01
clc
adc 8642,y
sta 8642,y
irq3 iny
</pre>
<pre>
iny
iny
inx
cpx #$08
bne irq4

> Nun werden die ersten 8 Bits des
> aktuellen Zeichens per ASL-Befehl in
> die Sprites übertragen. Genauer gesagt
> in Sprite Nr. 8, das ganz rechts
> steht. Dieses Sprite steht ab Adresse
> 8640 (Hex $21c0, ich habe ausnahms-
> weise mal mit dezimalen Adressen
> gearbeitet). In Adresse 8642 beginnt
> somit das erste Zeichen. Dort werden
> die Bits einfach hinzuaddiert.
</pre>
<pre>
inc $5a
lda $5a
cmp #$08
bne irq5
lda #$00
sta $58
sta $5a

> $5a dient als Zähler für die Anzahl
> der Durchgänge für ein Zeichen. Steht
> dieser auf 8, so wurden alle 8 Bits
> des aktuellen Zeichens verarbeitet und
> beim nächsten Durchgang wird das
> nächste Zeichen aus dem Laufschrift-
> text genommen.
</pre>
<pre>
> Was nun kommt (von Label "irq5" und
> "irq27"), sollte klar sein. Jede
> Stelle in den Sprites, von links nach
> rechts gesehen, in die ein Zeichen
> passt, wird per ASL-Befehl um ein Bit
> nach links gerückt. Dabei wird jeweils
> mit dem BCC-Befehl auf ein belegtes
> Bit reagiert und dieses auf die Stelle
> davor hinzuaddiert. Dies bewirkt am
> Ende ein Durchrollen der jeweiligen
> Bits und somit einen weichen Scroller.

irq5 ldy #$00
ldx #$00

irq6 asl 8192,x
</pre>
<pre>
> 8192-8199 wird NUR nach links
> geschoben. Hierbei ist es nicht
> notwendig, auf die Bits zu achten,
> weil hier der Scroller eh zu Ende ist
> und die Bits einfach links
> verschwinden können.

asl 8193,x
bcc irq7
lda #$01
clc
adc 8192,x
sta 8192,x

irq7 asl 8194,x
bcc irq8
</pre>
<pre>
lda #$01
clc
adc 8193,x
sta 8193,x

irq8 asl 8256,x
bcc irq9
lda #$01
clc
adc 8194,x
sta 8194,x

irq9 asl 8257,x
bcc irq10
lda #$01
clc
</pre>
<pre>
adc 8256,x
sta 8256,x

irq10 asl 8258,x
bcc irq11
lda #$01
clc
adc 8257,x
sta 8257,x

irq11 asl 8320,x
bcc irq12
lda #$01
clc
adc 8258,x
sta 8258,x
</pre>
<pre>
irq12 asl 8321,x
bcc irq13
lda #$01
clc
adc 8320,x
sta 8320,x

irq13 asl 8322,x
bcc irq14
lda #$01
clc
adc 8321,x
sta 8321,x

irq14 asl 8384,x
bcc irq15
</pre>
<pre>
lda #$01
clc
adc 8322,x
sta 8322,x

irq15 asl 8385,x
bcc irq16
lda #$01
clc
adc 8384,x
sta 8384,x

irq16 asl 8386,x
bcc irq17
lda #$01
clc
</pre>
<pre>
adc 8385,x
sta 8385,x

irq17 asl 8448,x
bcc irq18
lda #$01
clc
adc 8386,x
sta 8386,x

irq18 asl 8449,x
bcc irq188
lda #$01
clc
adc 8448,x
sta 8448,x
</pre>
<pre>
irq188 asl 8450,x
bcc irq19
lda #$01
clc
adc 8449,x
sta 8449,x

irq19 asl 8512,x
bcc irq20
lda #$01
clc
adc 8450,x
sta 8450,x

irq20 asl 8513,x
bcc irq21
</pre>
<pre>
lda #$01
clc
adc 8512,x
sta 8512,x

irq21 asl 8514,x
bcc irq22
lda #$01
clc
adc 8513,x
sta 8513,x

irq22 asl 8576,x
bcc irq23
lda #$01
clc
</pre>
<pre>
adc 8514,x
sta 8514,x

irq23 asl 8577,x
bcc irq24
lda #$01
clc
adc 8576,x
sta 8576,x

irq24 asl 8578,x
bcc irq255
lda #$01
clc
adc 8577,x
sta 8577,x
</pre>
<pre>
irq255 asl 8640,x
bcc irq25
lda #$01
clc
adc 8578,x
sta 8578,x

irq25 asl 8641,x
bcc irq26
lda #$01
clc
adc 8640,x
sta 8640,x

irq26 asl 8642,x
bcc irq27
</pre>
<pre>
lda #$01
clc
adc 8641,x
sta 8641,x

irq27 inx
inx
inx
iny
cpy #$08
beq irqend
jmp irq6

> Diese ganze Prozedur muss natürlich
> 8 mal durchlaufen werden, für jedes
</pre>
<pre>
> Byte eines Zeichens, das aus 8 Bytes
> besteht.

irqend jmp $ea31

> Ende der Irq-Routine.

<++++++++++++++++++++++++++++++++++++++>

sprmove lda #$5c
ldy #$00
ldx #$00
spr1 sta $d001,y
iny
iny
inx
</pre>
<pre>
cpx #$08
bne spr1
spr2 ldx #$9f
lda sinus,x
cmp #$3c
bne spr3
lda #$ff
sta $d01b
spr3 cmp #$80
bne spr4
lda #$00
sta $d01b
spr4 lda sinus,x
clc
adc #$05
sta sprmove+1
</pre>
<pre>
inc spr2+1
rts

> Dies ist die kleine Routine, die den
> Scroller von oben nach unten "hüpfen"
> lässt. Unter anderem sorgt diese
> dafür, dass sich der Sprite-Scroller
> abwechselnd hinter bzw. vor dem
> Digital Talk-Logo befindet. Dies wird
> in der Adresse $d01b kontrolliert.

<-------------------------------------->

txt .byte $03,$08,$09,$03,$0f,$20
.byte $0f,$06,$20,$03,$09,$16
.byte $09,$14,$01,$13,$20,$00
</pre>
<pre>
> Hier steht der kurze Laufschrifttext.
> Dieser kann hier nur max. 255 Zeichen
> lang sein. Man kann das Programm
> jedoch so modifizieren, dass der Text
> auch länger sein kann. Vielleicht eine
> kleine Aufgabe für Euch??? ;-)

sinus .byte $46,$45,$45,$44,$44,$43
.byte $42,$41,$40,$3f,$3e,$3d
.byte $3d,$3c,$3c,$3c,$3c,$3d
usw.

> Hier stehen die Werte für die Sinus-
> Routine.

<-------------------------------------->
</pre>
<pre>
logo .byte $01,$02,$03,$04,$05,$06
.byte $03,$07,$08,$09,$0a,$03
.byte $0b,$00,$0c,$0d,$0e,$0f
usw.

> Hier stehen die Werte für das Logo.

<-------------------------------------->
screen .byte $ff,$ff,$ff,$ff,$ff,$ff
.byte $ff,$ff,$ff,$ff,$ff,$ff
.byte $ff,$ff,$ff,$ff,$ff,$ff
usw.
> Hier stehen die Werte für den
> Bildschirm.

<-------------------------------------->
</pre>
<pre>
*= $2800

.byte $00,$00,$00,$00,$00,$00
.byte $00,$00,$00,$7f,$7f,$7f
.byte $7f,$7f,$7d,$7c,$00,$00
usw.

> Ab $2800 steht der Zeichensatz für das
> Logo.

Das war's dann soweit.

Solltet Ihr Fragen, Wünsche oder Anre-
gungen haben, dann schreibt doch einfach
an die DT-Redaktion.
</pre>
<pre>
Auch hoffe ich, dass auch dieser Ass-
Kurs ein wenig interessant für Euch war.

Dann bis zum nächsten Mal...

Euer

XXXXXXXXXXXXXXXXXX
CHICO/CIVITAS

_
</pre>

DT 85 15 - Revision history

Nyquist at 23:16, 17 January 2011

Nyquist at 11:39, 13 June 2010