DT 85 15

From C64 Diskmag Wiki
(Difference between revisions)
Jump to: navigation, search
 
 
Line 1: Line 1:
[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&szlig;,  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&auml;sst sich jedoch nur  ra-
 
tional in Maschinensprache  realisieren,
 
Basic ist daf&uuml;r einfach zu langsam. Auch
 
diesmal l&auml;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&auml;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&ouml;g-
 
lichkeit f&uuml;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&uuml;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  &uuml;bertragen,
 
so geschieht dies folgenderma&szlig;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&uuml;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&uuml;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&auml;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&uuml;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>
 
&gt; 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
 
 
&gt; Der Bildschirm wird mit den Daten aus
 
&gt; dem Label "Screen" gef&uuml;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
 
 
&gt; Das "Digital Talk"-Logo wird auf dem
 
&gt; Bildschirm positioniert.
 
 
        ldy #$00
 
        lda #$ff
 
a3      sta $2ff8,y
 
        iny
 
</pre>
 
<pre>
 
        cpy #$08
 
        bne a3
 
 
&gt; Der Zeichensatz f&uuml;r das Logo steht ab
 
&gt; $2800 (s.u.). Hier wird ein Zeichen
 
&gt; gef&uuml;llt und zwar das letzte Zeichen
 
&gt; 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
 
 
&gt; Der ROM-Zeichensatz respektive ein
 
&gt; Teil davon wird nach $3000 kopiert.
 
&gt; Dieser wird f&uuml;r die Laufschrift
 
</pre>
 
<pre>
 
&gt; ben&ouml;tigt. Die Sprites stehen ab $2000,
 
&gt; dieser Bereich wird mit #0 gef&uuml;llt.
 
 
        lda #$00
 
        sta $57
 
        sta $58
 
        sta $5a
 
        sta $5b
 
        sta $5c
 
 
&gt; Speicherstellen und Z&auml;hler werden
 
&gt; 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
 
 
&gt; Bis hier werden die Sprites
 
&gt; eingeschaltet und auf dem Bildschirm
 
&gt; positioniert. Auch wird die Farbe auf
 
&gt; Hellgrau gesetzt ($0f = #15).
 
</pre>
 
<pre>
 
        jsr irq
 
 
        jmp *
 
 
&gt; Der IRQ wird angesprungen, danach wird
 
&gt; mit JMP * das Programm quasi
 
&gt; angehalten. Alles, was man dann sieht,
 
&gt; l&auml;uft ausschlie&szlig;lich im IRQ ab.
 
 
irq      sei
 
        lda #$81
 
        sta $d01a
 
        lda #$7f
 
        sta $dc0d
 
        lda #$00
 
        sta $d012
 
</pre>
 
<pre>
 
        ldx #&lt;irq1
 
        ldy #&gt;irq1
 
        stx $0314
 
        sty $0315
 
        cli
 
        lda #27
 
        sta $d011
 
        rts
 
 
irq1    asl $d019
 
 
&gt; Hier die bekannten Einstellungen f&uuml;r
 
&gt; den IRQ. Ich hoffe, da nichts mehr
 
&gt; erkl&auml;ren zu m&uuml;ssen.
 
 
        jsr sprmove
 
</pre>
 
<pre>
 
&gt; Hier wird f&uuml;r die vertikale Bewegung
 
&gt; des Sprite-Scrollers eine kleine
 
&gt; Routine angesprungen, die f&uuml;r die
 
&gt; nette H&uuml;pfbewegung des Scrollers
 
&gt; verantwortlich ist. Dieser Sprite-
 
&gt; Sinus wurde mir von dflame zur
 
&gt; Verf&uuml;gung gestellt. Herzlichen Dank
 
&gt; 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
 
 
&gt; Jetzt gehts ins Eingemachte. Hier
 
&gt; werden die Zeichen berechnet und
 
</pre>
 
<pre>
 
&gt; zwischengespeichert. Der Text der
 
&gt; Laufschrift steht ab Label "txt".
 
&gt; Von dort wird ein Zeichen gelesen und
 
&gt; danach berechnet, wo dieses Zeichen
 
&gt; sich in unserem zuvor kopierten ROM-
 
&gt; Zeichensatz befindet. Daf&uuml;r muss man
 
&gt; den Wert des Zeichens * 8 nehmen und
 
&gt; den Wert zu $3000 rechnen ($fa/$fb).
 
&gt; Am Ende wird das aktuelle Zeichen nach
 
&gt; $02c0-$02c7 geschrieben. Dort kann es
 
&gt; dann gleich ver&auml;ndert werden. Diese
 
&gt; Zwischenspeicherung ist notwendig,
 
&gt; weil wir ja sonst nach jedem Zeichen
 
&gt; den ROM-Zeichensatz neu kopieren
 
&gt; m&uuml;ssten, weil jedes Zeichen durch den
 
&gt; ASL-Befehl gleich geleert wird.
 
</pre>
 
<pre>
 
&gt; Der Wert in $5a wird &uuml;brigens von 0
 
&gt; auf 1 gestellt, weil ja nicht nach
 
&gt; jedem Durchgang ein neues Zeichen
 
&gt; berechnet werden darf, sondern erst,
 
&gt; wenn alle 8 Bits eines Zeichens
 
&gt; 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
 
 
&gt; Nun werden die ersten 8 Bits des
 
&gt; aktuellen Zeichens per ASL-Befehl in
 
&gt; die Sprites &uuml;bertragen. Genauer gesagt
 
&gt; in Sprite Nr. 8, das ganz rechts
 
&gt; steht. Dieses Sprite steht ab Adresse
 
&gt; 8640 (Hex $21c0, ich habe ausnahms-
 
&gt; weise mal mit dezimalen Adressen
 
&gt; gearbeitet). In Adresse 8642 beginnt
 
&gt; somit das erste Zeichen. Dort werden
 
&gt; die Bits einfach hinzuaddiert.
 
</pre>
 
<pre>
 
        inc $5a
 
        lda $5a
 
        cmp #$08
 
        bne irq5
 
        lda #$00
 
        sta $58
 
        sta $5a
 
 
 
&gt; $5a dient als Z&auml;hler f&uuml;r die Anzahl
 
&gt; der Durchg&auml;nge f&uuml;r ein Zeichen. Steht
 
&gt; dieser auf 8, so wurden alle 8 Bits
 
&gt; des aktuellen Zeichens verarbeitet und
 
&gt; beim n&auml;chsten Durchgang wird das
 
&gt; n&auml;chste Zeichen aus dem Laufschrift-
 
&gt; text genommen.
 
</pre>
 
<pre>
 
&gt; Was nun kommt (von Label "irq5" und
 
&gt; "irq27"), sollte klar sein. Jede
 
&gt; Stelle in den Sprites, von links nach
 
&gt; rechts gesehen, in die ein Zeichen
 
&gt; passt, wird per ASL-Befehl um ein Bit
 
&gt; nach links ger&uuml;ckt. Dabei wird jeweils
 
&gt; mit dem BCC-Befehl auf ein belegtes
 
&gt; Bit reagiert und dieses auf die Stelle
 
&gt; davor hinzuaddiert. Dies bewirkt am
 
&gt; Ende ein Durchrollen der jeweiligen
 
&gt; Bits und somit einen weichen Scroller.
 
 
irq5    ldy #$00
 
        ldx #$00
 
 
irq6    asl 8192,x
 
</pre>
 
<pre>
 
&gt; 8192-8199 wird NUR nach links
 
&gt; geschoben. Hierbei ist es nicht
 
&gt; notwendig, auf die Bits zu achten,
 
&gt; weil hier der Scroller eh zu Ende ist
 
&gt; und die Bits einfach links
 
&gt; verschwinden k&ouml;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
 
 
 
&gt; Diese ganze Prozedur muss nat&uuml;rlich
 
&gt; 8 mal durchlaufen werden, f&uuml;r jedes
 
</pre>
 
<pre>
 
&gt; Byte eines Zeichens, das aus 8 Bytes
 
&gt; besteht.
 
 
irqend  jmp $ea31
 
 
&gt; Ende der Irq-Routine.
 
 
&lt;++++++++++++++++++++++++++++++++++++++&gt;
 
 
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
 
 
&gt; Dies ist die kleine Routine, die den
 
&gt; Scroller von oben nach unten "h&uuml;pfen"
 
&gt; l&auml;sst. Unter anderem sorgt diese
 
&gt; daf&uuml;r, dass sich der Sprite-Scroller
 
&gt; abwechselnd hinter bzw. vor dem
 
&gt; Digital Talk-Logo befindet. Dies wird
 
&gt; in der Adresse $d01b kontrolliert.
 
 
&lt;--------------------------------------&gt;
 
 
txt      .byte $03,$08,$09,$03,$0f,$20
 
        .byte $0f,$06,$20,$03,$09,$16
 
        .byte $09,$14,$01,$13,$20,$00
 
</pre>
 
<pre>
 
&gt; Hier steht der kurze Laufschrifttext.
 
&gt; Dieser kann hier nur max. 255 Zeichen
 
&gt; lang sein. Man kann das Programm
 
&gt; jedoch so modifizieren, dass der Text
 
&gt; auch l&auml;nger sein kann. Vielleicht eine
 
&gt; kleine Aufgabe f&uuml;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.
 
 
&gt; Hier stehen die Werte f&uuml;r die Sinus-
 
&gt; Routine.
 
 
&lt;--------------------------------------&gt;
 
</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.
 
 
&gt; Hier stehen die Werte f&uuml;r das Logo.
 
 
&lt;--------------------------------------&gt;
 
screen  .byte $ff,$ff,$ff,$ff,$ff,$ff
 
        .byte $ff,$ff,$ff,$ff,$ff,$ff
 
        .byte $ff,$ff,$ff,$ff,$ff,$ff
 
usw.
 
&gt; Hier stehen die Werte f&uuml;r den
 
&gt; Bildschirm.
 
 
&lt;--------------------------------------&gt;
 
</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.
 
 
&gt; Ab $2800 steht der Zeichensatz f&uuml;r das
 
&gt; Logo.
 
 
 
Das war's dann soweit.
 
 
Solltet  Ihr  Fragen, W&uuml;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&uuml;r Euch war.
 
 
Dann bis zum n&auml;chsten Mal...
 
 
Euer
 
 
XXXXXXXXXXXXXXXXXX
 
CHICO/CIVITAS
 
 
 
 
 
 
 
                                      _
 
</pre>
 

Latest revision as of 00:16, 18 January 2011

Personal tools
Namespaces

Variants
Actions
Navigation
Toolbox