🎞️Flimmerfrei animieren

Bewegen heißt: alte Stelle wiederherstellen, neue Stelle sichern, neu zeichnen – 50-mal pro Sekunde. Entscheidend ist, wanndas passiert, denn der Bildschirm wird währenddessen ständig vom Strahl gelesen.

⏱️Ein Bild auf der Zeitachse

Schieben Sie Start und Dauer des Zeichnens: Überschneidet sich das Zeichnen mit dem Moment, in dem der Strahl die Sprite-Zeilen ausgibt, sieht man ein halb gezeichnetes Sprite.

Sprite in Zeile 92–107Zeichnen beginnt 0 µs nach Beginn des StrahlrücklaufsDauer: 2901 µs (gemessen: Routine c bewegen = 2901 µs)

✅ Das Zeichnen ist fertig, bevor (oder nachdem) der Strahl die Sprite-Zeilen liest – die Figur erscheint immer vollständig.

Vereinfachtes Modell mit den Standardwerten des CRTC (R4 = 38, R6 = 25, R7 = 30): 312 Rasterzeilen × 64 µs = 19 968 µs; die erste Bildzeile folgt (39 − 30) × 8 = 72 Rasterzeilen nach dem Beginn des VSYNC. Der Emulator unten zeichnet den Bildschirm dagegen einmal je Browser-Bild vollständig – Zerreißen ist dort nicht zu sehen, die Zeitachse zeigt, warum es auf echter Hardware passiert.

🏃Das Sprite läuft – im Emulator

Vier Varianten desselben Programms. Das Programm läuft endlos; „Pause“ und „Schritt“ zeigen jederzeit, wo es gerade steht.

Rakete statt Geist

bereit

ℹ️ Jede Runde wartet mit CALL &BD19 (MC WAIT FLYBACK) auf den Strahlrücklauf, stellt die alte Stelle wieder her, sichert die neue und zeichnet – ein Byte (2 Pixel) je Bild, also 50 Schritte pro Sekunde.

Quelltext (editierbar)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

; VisualCPCSprite – Animation: Sprite läuft über den Hintergrund (Endlosschleife)
        org &8000
start:  call setup
        ld hl,&E370         ; Anfangsposition: Zeile 92, Byte 0
        ld (old),hl
        ld de,buf
        call save_bg
        ld de,(old)
        ld hl,sprm
        call draw_mask
anim:
        call &bd19          ; MC WAIT FLYBACK: warten, bis der Strahlrücklauf (VSYNC) läuft
        ld hl,buf
        ld de,(old)
        call restore_bg     ; 1. alte Stelle: Hintergrund zurück
        ld a,(xpos)
        inc a               ; 2. ein Byte (= 2 Modus-0-Pixel) weiter
        cp 77
        jr c,an_ok
        xor a               ; am rechten Rand wieder links anfangen
an_ok:  ld (xpos),a
        ld e,a
        ld d,0
        ld hl,&E370
        add hl,de           ; HL = Zeilenanfang + x
        ld (old),hl
        ld de,buf
        call save_bg        ; 3. neuen Hintergrund sichern
        ld de,(old)
        ld hl,sprm
        call draw_mask      ; 4. Sprite zeichnen
        jr anim

xpos:   db 0
old:    dw 0

; Bildschirm vorbereiten: Modus 0, Farben, Hintergrundmuster
setup:  xor a
        call &bc0e          ; SCR SET MODE (A = 0) – löscht auch den Bildschirm
        ld hl,inks
        xor a
set_ink:
        push af
        push hl
        ld b,(hl)
        ld c,b              ; B = C = Farbe (nicht blinkend)
        call &bc32          ; SCR SET INK (A = Tinte)
        pop hl
        pop af
        inc hl
        inc a
        cp 16
        jr nz,set_ink
        ld bc,&0101
        call &bc38          ; SCR SET BORDER
        ld hl,&c000         ; Karomuster: 8 Pixel breit, 4 Zeilen hoch
bg_l:   ld a,h
        rrca
        rrca
        rrca                ; Bit 5 von H (Zeile AND 4) nach Bit 2
        xor l               ; mit Bit 2 von L (Spalte) verknüpfen
        and 4
        ld a,&00            ; Tinte 0 in beiden Pixeln
        jr z,bg_s
        ld a,&3F            ; Tinte 14 in beiden Pixeln
bg_s:   ld (hl),a
        inc hl
        ld a,h
        or l
        jr nz,bg_l          ; bis HL über &FFFF hinausläuft
        ret
inks:   db 1,8,26,0,16,24,6,18,20,4,13,3,15,11,2,7      ; Firmware-Farben der Tinten 0–15

; (c) Maskiertes Sprite – HL = Maske/Sprite verschränkt, DE = Bildschirmadresse
draw_mask:
        ld c,16
dm_row: push de
        ld b,4
dm_byte:
        ld a,(de)           ; Hintergrund
        and (hl)            ; Maske: 1 = Hintergrund bleibt
        inc hl
        or (hl)             ; Sprite einsetzen
        inc hl
        ld (de),a
        inc de
        djnz dm_byte
        pop de
        ld a,d            ; nächste Pixelzeile: +&800
        add a,8
        ld d,a
        and &38             ; Block 0? Dann Übertrag in die nächste Zeichenzeile
        jr nz,dm_nx
        ld a,e            ; &C050-Korrektur: +80 Bytes …
        add a,&50
        ld e,a
        ld a,d            ; … und −&4000 (= +&C0 im High-Byte)
        adc a,&c0
        ld d,a
dm_nx:
        dec c
        jr nz,dm_row
        ret

; Hintergrund sichern – HL = Bildschirmadresse, DE = Puffer (64 Bytes)
save_bg:
        ld b,16
sv_row: push hl
        ld c,&ff
        ldi
        ldi
        ldi
        ldi
        pop hl
        ld a,h            ; nächste Pixelzeile: +&800
        add a,8
        ld h,a
        and &38             ; Block 0? Dann Übertrag in die nächste Zeichenzeile
        jr nz,sv_nx
        ld a,l            ; &C050-Korrektur: +80 Bytes …
        add a,&50
        ld l,a
        ld a,h            ; … und −&4000 (= +&C0 im High-Byte)
        adc a,&c0
        ld h,a
sv_nx:
        djnz sv_row
        ret

; (a) Sprite kopieren – HL = Quelle, DE = Bildschirmadresse (4 Bytes × 16 Zeilen)
restore_bg:
        ld b,16             ; B = Zeilenzähler
rs_row: push de
        ld c,&ff            ; LDI zählt BC herunter – C fängt das ab, B bleibt Zeilenzähler
        ldi                 ; (DE) ← (HL), beide +1
        ldi                 ; (DE) ← (HL), beide +1
        ldi                 ; (DE) ← (HL), beide +1
        ldi                 ; (DE) ← (HL), beide +1
        pop de
        ld a,d            ; nächste Pixelzeile: +&800
        add a,8
        ld d,a
        and &38             ; Block 0? Dann Übertrag in die nächste Zeichenzeile
        jr nz,rs_nx
        ld a,e            ; &C050-Korrektur: +80 Bytes …
        add a,&50
        ld e,a
        ld a,d            ; … und −&4000 (= +&C0 im High-Byte)
        adc a,&c0
        ld d,a
rs_nx:
        djnz rs_row
        ret

; Maske und Sprite verschränkt
sprm:
        db &FF,&00,&00,&C0,&00,&C0,&FF,&00
        db &AA,&40,&00,&C0,&00,&C0,&55,&80
        db &00,&C0,&00,&C0,&00,&C0,&00,&C0
        db &00,&C0,&00,&C0,&00,&C0,&00,&C0
        db &00,&84,&00,&48,&00,&84,&00,&48
        db &00,&84,&00,&C8,&00,&84,&00,&C8
        db &00,&84,&00,&C8,&00,&84,&00,&C8
        db &00,&84,&00,&48,&00,&84,&00,&48
        db &00,&C0,&00,&C0,&00,&C0,&00,&C0
        db &00,&C0,&00,&C0,&00,&C0,&00,&C0
        db &00,&90,&00,&C0,&00,&C0,&00,&60
        db &00,&C0,&00,&C0,&00,&C0,&00,&C0
        db &00,&C0,&00,&C1,&00,&C2,&00,&C0
        db &00,&C0,&00,&C0,&00,&C0,&00,&C0
        db &00,&C0,&00,&C0,&00,&C0,&00,&C0
        db &55,&80,&AA,&40,&55,&80,&AA,&40
buf:    ds 64

Assembler-Liste · Klick auf ● = Haltepunkt

Rand

Modus 1 · Basis &C000 · Versatz &0000

Firmware

Firmware jetzt

▶ RESET ENTRY · Details in VisualZ80 ↗

Letzte Falle: –

Letzte Firmware-Aufrufe

noch keine

&FFFF

&0000

&FFFF

&C000

&0000

P/V

AF' &0000

BC' &7F8D

DE' &0000

HL' &0000

I &00

R &00

IM 1

IFF1/2 1/1

Z80-Takte: 0 TCPC-Zeit: 0 µsROMs: unten aus, oben ausRAM-Konfig: &C0

Disassembler ab PC

0000ED FEHLE ▸ RESET ENTRY

0002C9RET

000300NOP

000400NOP

000500NOP

000600NOP

000700NOP

0008ED FEHLE ▸ LOW JUMP

000AC9RET

000BED FEHLE ▸ KL LOW PCHL

Stapel (SP)

C0000000← SP

C0020000

C0040000

C0060000

C0080000

C00A0000

C00C0000

C00E0000

Speicher (Hex)

800000 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ················

801000 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ················

802000 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ················

803000 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ················

804000 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ················

805000 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ················

806000 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ················

807000 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ················

PCSP(HL)(DE)Leseansicht mit aktueller ROM-/Bank-Einblendung

🧠Die Werkzeuge im Überblick

💡 MC WAIT FLYBACK (&BD19)

Firmware-Routine aus dem Machine Pack (SOFT 968): kehrt zurück, sobald der Strahlrücklauf läuft. Bequem, braucht aber die Firmware.

💡 PPI 8255, Port B, Bit 0

LD B,&F5 : IN A,(C) : RRA – Bit 0 von Port B meldet den VSYNC des CRTC. Funktioniert auch bei abgeschalteter Firmware.

💡 CRTC-Register 12/13

Register 12 Bits 5–4 wählen den 16-KB-Block des Bildes: &30 → &C000, &10 → &4000. Register wählen über Port &BCxx, Wert schreiben über &BDxx. Die Firmware bietet dafür SCR SET BASE (&BC08).