⚙️Zeichenroutinen in Z80

Sechs Wege, ein Software-Sprite auf den Bildschirm zu bringen – jeder als lauffähiges Programm im Emulator, mit Einzelschritt, „Schritt zurück“, Haltepunkten und gemessener Laufzeit.

🧪

Simulation im Browser. Der Z80 wird Befehl für Befehl emuliert; die CPC-Firmware ist dagegen in TypeScript nachgebildet (HLE) – nach den Ein-/Ausgabebedingungen aus dem Firmware-Handbuch SOFT 968. Es wird kein ROM-Inhalt von Amstrad verwendet, der Zeichensatz ist ein gemeinfreier Ersatz. Emulator, Assembler und Debugger stammen aus VisualZ80.

Sprite:8 × 16 Pixel = 4 Bytes × 16 Zeilen = 64 Bytes

c) Maskiert (AND Maske / OR Sprite)

Zu jedem Byte gehört ein Masken-Byte (1 = Hintergrund bleibt). AND (HL) stanzt die Figur aus, OR (HL) setzt sie ein. Vorher wird der Hintergrund gesichert, beim Bewegen zurückgeschrieben.

✅ saubere Transparenz vor beliebigem Hintergrund

⚠️ doppelter Datenbedarf (Maske + Sprite) und zusätzlich Sichern/Wiederherstellen

Im Emulator gemessen

1511 µs

= 1511 NOPs für einmal Zeichnen (inkl. CALL und RET) · 7.6 % eines Bildes

Bewegen: 2901 µs – wiederherstellen 695 + sichern 695 + zeichnen 1511 µs

Daten/Code: 192 Bytes

bereit

ℹ️ Das Programm stellt Modus 0, die Tinten und ein Karomuster ein und zeichnet das Sprite an zwei Stellen. Zwischen den Labels bench_start und bench_end steht der gemessene Aufruf – „Zeitlupe“ oder Einzelschritt zeigen, wie die Figur Zeile für Zeile entsteht.

Quelltext (editierbar)

; VisualCPCSprite – Maskiert (AND Maske / OR Sprite)
; Sprite „Pixelgeist“: 8 × 16 Pixel (Modus 0) = 4 Bytes × 16 Zeilen
        org &8000          ; ab &8000: &4000–&7FFF bleibt frei (zweiter Bildschirm, Plus-ASIC)
start:  call setup
        ld hl,&C238
        ld de,buf_a
        call save_bg        ; Hintergrund bei A sichern
        di
        ld hl,sprm
        ld de,&C238
bench_start:
        call draw_mask      ; Sprite bei A
bench_end:
        ei
        ld hl,&C29E
        ld de,buf_b
        call save_bg        ; Hintergrund bei B sichern
        ld hl,sprm
        ld de,&C29E
        call draw_mask      ; Sprite bei B
        ld hl,buf_a
        ld de,&C238
        call restore_bg     ; A wiederherstellen: Sprite weg, Karomuster unversehrt
        ret

; 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: Maske, Byte, Maske, Byte, …
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_a:  ds 64             ; Hintergrundpuffer A
buf_b:  ds 64             ; Hintergrundpuffer B

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

📊 Wie viele Sprites passen in ein Bild?

Anteil der Rechenzeit für Sprites:

Ein Bild dauert bei 50 Hz 19 968 µs (312 Rasterzeilen × 64 µs). Auf dem CPC hält das Gate Array den Z80 so an, dass jeder Befehl ein Vielfaches von 1 µs dauert (4 Takte = 1 „NOP“). Die Zahlen unten sind nicht geschätzt, sondern im Emulator gemessen – mit der gemessenen Befehlstabelle von Kevin Thacker. Rechnung: ⌊19 968 µs × Anteil ÷ Kosten⌋, Interrupts nicht abgezogen.

nur zeichnenbewegen (löschen/wiederherstellen + sichern + zeichnen)

Routine	zeichnen (µs)	Sprites/Bild	bewegen (µs)	Sprites/Bild	Bytes	Bewegen heißt
a · Kopieren (LDI)	695	28	1390	14	64	alte Stelle mit Hintergrund überschreiben + neu zeichnen
b · XOR	1255	15	2510	7	64	alt wegXORen + neu zeichnen
c · Maske AND/OR	1511	13	2901	6	192	wiederherstellen 695 + sichern 695 + zeichnen 1511 µs
d · Tabelle (Tinte 0)	1722	11	3112	6	384	wiederherstellen + sichern + zeichnen
e · vorverschoben (+1 Pixel)	2042	9	3592	5	400	wie d, aber 5 statt 4 Bytes breit (auch Sichern/Wiederherstellen)
f · kompiliert	565	35	1955	10	466	wiederherstellen + sichern + Code ausführen

Bytes: a/b Sprite; c Maske+Sprite verschränkt + Hintergrundpuffer; d/e zusätzlich die 256-Byte-Tabelle (e mit beiden Fassungen); f = Größe des erzeugten Codes. Echte Spiele sparen weiter: INC E statt INC DE bei bekannter Ausrichtung, Zeilenzähler im Code, Sprites über den Stapelzeiger (POP) lesen – die Reihenfolge bleibt aber typisch.