👾Mehrere Sprites – flimmerfrei und steuerbar

Eine kleine Spielszene: zehn Figuren in vier Größen fliegen über den Hintergrund, prallen an den Rändern ab und überlappen sich. Alles läuft als Z80-Programm im Emulator – und die gemessene Rechenzeit zeigt ehrlich, wann ein 50-Hz-Bild nicht mehr reicht.

🧪

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. Die Szene ist ein echtes Z80-Programm; Tastenabfrage und Rand-Farbe gehen über die (nachgebildete) Firmware.

🎮Die Szene im Emulator

Anzahl Sprites: 10

Spieler steuern (Objekt 0, Geist)

Im Emulator gemessen: Rechenzeit je Bild (10 Sprites, Mittel über 20 Bilder)

messe …

bereit

ℹ️ Die Szene läuft endlos. Mit „Pause“ und „Schritt“ lässt sie sich wie auf den anderen Seiten anhalten; das Label work_end markiert das Ende der Arbeit eines Bildes. Hinweis: Die Bildschirmanzeige springt zwischen &4000 und &C000 – im Speicher-Fenster lassen sich beide Bilder ansehen.

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

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

; VisualCPCSprite – Mehrere Sprites (10), flimmerfrei: Strahlrücklauf + Double Buffering
N       equ 10               ; Anzahl der Sprites
        org &8000
start:  call setup            ; Modus 0, Tinten, Karomuster auf &C000
        ld hl,&c000
        ld de,&4000
        ld bc,&4000
        ldir                  ; dasselbe Muster auf den zweiten Bildschirm &4000

; ================= Hauptschleife: ein Durchlauf = ein Bild =================
frame:
        call restore_all      ; 1. Hintergrund zurück (umgekehrte Zeichenreihenfolge)
        ; (kein Spieler – alle Sprites bewegen sich selbst)
        call move_all         ; 2. Positionen: x += dx, y += dy, an den Rändern abprallen
        call collide          ; 3. Kollision Objekt 0 ↔ andere (Rechtecke)
        call sort_y           ; 4. nach y sortieren (Maleralgorithmus)
        call draw_all         ; 5. Hintergrund sichern + maskiert zeichnen
work_end:
        call wait_frame       ; 6. auf den Beginn des nächsten Strahlrücklaufs warten
        call flip             ; 7. unsichtbares Bild zeigen (CRTC R12), Puffer tauschen
        ld hl,(frames)
        inc hl
        ld (frames),hl        ; Bildzähler
        jp frame

; ---- 1. Hintergrund wiederherstellen: letzter gezeichneter Eintrag zuerst ----
restore_all:
        ld hl,(cur_cnt)
        ld a,(hl)             ; wie viele Sprites wurden in DIESES Bild gezeichnet?
        or a
        ret z
        ld b,a
ra_loop: push bc
        ld a,b
        dec a                 ; Platz k = b − 1 (rückwärts)
        call restore_one
        pop bc
        djnz ra_loop
        ret
restore_one:                  ; A = Platz k in der Zeichenliste
        push af
        call rl_entry         ; HL = Eintrag k (Adresse, Typ)
        ld e,(hl)
        inc hl
        ld d,(hl)             ; DE = Bildschirmadresse
        inc hl
        ld a,(hl)             ; Typ
        push de
        call load_type
        pop de
        pop af
        call bg_slot          ; HL = gesicherter Hintergrund
        jp restore_g
rl_entry:                     ; A = k → HL = (cur_rl) + 3·k
        ld l,a
        ld h,0
        ld e,l
        ld d,h
        add hl,hl
        add hl,de
        ld de,(cur_rl)
        add hl,de
        ret
bg_slot:                      ; A = k → HL = (cur_bg) + 64·k (DE bleibt erhalten)
        ld l,a
        ld h,0
        add hl,hl
        add hl,hl
        add hl,hl
        add hl,hl
        add hl,hl
        add hl,hl
        push de
        ld de,(cur_bg)
        add hl,de
        pop de
        ret

; ---- 2. Bewegen und an den Rändern abprallen ----
move_all:
        ld ix,ent+0
        ld b,10
mv_loop: push bc
        ld a,(ix+4)
        call load_type
        ld a,(ix+0)
        add a,(ix+2)          ; x + dx
        ld c,a
        ld a,(cur_mx)
        cp c                  ; außerhalb 0 … 80 − Breite? (negativ = ab &80 ist auch „zu groß“)
        jr nc,mv_xok
        ld a,(ix+2)
        neg                   ; abprallen: Richtung umkehren
        ld (ix+2),a
        ld a,(ix+0)
        add a,(ix+2)
        ld c,a
mv_xok: ld (ix+0),c
        ld a,(ix+1)
        add a,(ix+3)          ; y + dy
        ld c,a
        ld a,(cur_my)
        cp c
        jr nc,mv_yok
        ld a,(ix+3)
        neg
        ld (ix+3),a
        ld a,(ix+1)
        add a,(ix+3)
        ld c,a
mv_yok: ld (ix+1),c
        ld de,8
        add ix,de
        pop bc
        djnz mv_loop
        ret

; ---- 3. Kollision: Rechteck von Objekt 0 gegen alle anderen ----
collide:
        ld ix,ent
        ld a,(ix+4)
        call load_type
        ld a,(cur_w)
        add a,(ix+0)
        ld (p_r),a            ; rechter Rand (exklusiv)
        ld a,(cur_h)
        add a,(ix+1)
        ld (p_b),a            ; unterer Rand (exklusiv)
        xor a
        ld (touch),a
        ld ix,ent+8
        ld b,N-1
co_loop: push bc
        ld a,(ix+4)
        call load_type
        ld hl,p_r
        ld a,(ix+0)
        cp (hl)               ; x_i ≥ rechter Rand von 0 → keine Berührung
        jr nc,co_no
        ld a,(cur_w)
        add a,(ix+0)
        ld c,a
        ld a,(ent+0)
        cp c                  ; x_0 ≥ rechter Rand von i → keine Berührung
        jr nc,co_no
        ld hl,p_b
        ld a,(ix+1)
        cp (hl)
        jr nc,co_no
        ld a,(cur_h)
        add a,(ix+1)
        ld c,a
        ld a,(ent+1)
        cp c
        jr nc,co_no
        ld a,1
        ld (touch),a          ; Rechtecke überlappen
co_no:  ld de,8
        add ix,de
        pop bc
        djnz co_loop
        ld a,(touch)
        ld hl,was_touch
        cp (hl)
        ret z                 ; nichts geändert
        ld (hl),a
        or a
        jr z,co_off
        ld hl,(hits)
        inc hl
        ld (hits),hl          ; neue Berührung zählen
        ld bc,&0606           ; Rand hellrot
        jp &bc38              ; SCR SET BORDER
co_off: ld bc,&0101           ; Rand wieder normal
        jp &bc38

; ---- 4. Y-Sortierung (Bubble Sort – die Liste ist vom letzten Bild fast sortiert) ----
sort_y:
sy_pass: xor a
        ld (swapped),a
        ld hl,ord
        ld b,N-1
sy_cmp: ld a,(hl)
        call get_y
        ld c,a                ; C = y links
        inc hl
        ld a,(hl)
        call get_y            ; A = y rechts
        cp c
        jr nc,sy_ok           ; schon in Ordnung
        ld d,(hl)             ; tauschen
        dec hl
        ld a,(hl)
        ld (hl),d
        inc hl
        ld (hl),a
        ld a,1
        ld (swapped),a
sy_ok:  djnz sy_cmp
        ld a,(swapped)
        or a
        jr nz,sy_pass
        ret
get_y:                        ; A = Objektnummer → A = y (BC, HL bleiben erhalten)
        push hl
        add a,a
        add a,a
        add a,a
        ld e,a
        ld d,0
        ld hl,ent+1
        add hl,de
        ld a,(hl)
        pop hl
        ret

; ---- 5. In y-Reihenfolge sichern und zeichnen (weiter unten = später = vorn) ----
draw_all:
        ld hl,(cur_cnt)
        ld (hl),N             ; so viele Einträge bekommt die Liste
        ld b,0                ; B = Platz k
da_loop: push bc
        ld hl,ord
        ld e,b
        ld d,0
        add hl,de
        ld a,(hl)             ; Objektnummer an Platz k
        add a,a
        add a,a
        add a,a
        ld e,a
        ld ix,ent
        add ix,de             ; IX = Objekt
        ld a,(ix+4)
        call load_type
        ld l,(ix+1)
        ld h,0
        add hl,hl
        ld de,lines
        add hl,de
        ld e,(hl)
        inc hl
        ld d,(hl)             ; DE = Versatz der Zeile y im Bild
        ld l,(ix+0)
        ld h,0
        add hl,de             ; + x
        ld a,(hidden)
        add a,h
        ld h,a                ; + Bildanfang (&40 bzw. &C0 im High-Byte)
        pop bc
        push bc
        push hl
        ld a,b
        call rl_entry         ; Eintrag k der Wiederherstellungsliste
        pop de                ; DE = Bildschirmadresse
        ld (hl),e
        inc hl
        ld (hl),d
        inc hl
        ld a,(ix+4)
        ld (hl),a
        pop bc
        push bc
        ld a,b
        call bg_slot          ; HL = Puffer für Platz k
        push de
        ex de,hl              ; HL = Bildschirm, DE = Puffer
        call save_g           ; Hintergrund sichern
        pop de
        ld hl,(cur_dat)
        call draw_m           ; maskiert zeichnen
        pop bc
        inc b
        ld a,b
        cp N
        jr c,da_loop
        ret

; ---- 6. Warten: erst ein laufendes VSYNC enden lassen, dann auf das nächste warten (PPI Port B, Bit 0) ----
wait_frame:
        ld b,&f5
wf_1:   in a,(c)
        rra
        jr c,wf_1
wf_2:   in a,(c)
        rra
        jr nc,wf_2
        ret

; ---- 7. Bild umschalten: CRTC-Register 12 (&10 → &4000, &30 → &C000), Verwaltung tauschen ----
flip:   ld a,(hidden)
        rrca
        rrca
        ld bc,&bc0c
        out (c),c             ; Register 12 wählen
        inc b
        out (c),a             ; Bildanfang setzen
        ld a,(hidden)
        xor &80
        ld (hidden),a
        ld hl,(cur_rl)
        ld de,(oth_rl)
        ld (cur_rl),de
        ld (oth_rl),hl
        ld hl,(cur_bg)
        ld de,(oth_bg)
        ld (cur_bg),de
        ld (oth_bg),hl
        ld hl,(cur_cnt)
        ld de,(oth_cnt)
        ld (cur_cnt),de
        ld (oth_cnt),hl
        ret

; ---- Typ laden: Breite, Höhe, max. x, max. y, Datenadresse ----
load_type:                    ; A = Typ
        ld l,a
        ld h,0
        ld e,l
        ld d,h
        add hl,hl
        add hl,de
        add hl,hl             ; 6·Typ
        ld de,types
        add hl,de
        ld de,cur_type
        ld bc,6
        ldir
        ret

; HL = Puffer, DE = Bildschirm – (cur_w) × (cur_h) Bytes zurückschreiben
restore_g:
        ld a,(cur_h)
        ld c,a
rg_row: push de
        ld a,(cur_w)
        ld b,a
rg_b:   ld a,(hl)
        ld (de),a
        inc hl
        inc de
        djnz rg_b
        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,rg_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
rg_nx:
        dec c
        jr nz,rg_row
        ret

; HL = Bildschirm, DE = Puffer – Hintergrund sichern
save_g:
        ld a,(cur_h)
        ld c,a
sg_row: push hl
        ld a,(cur_w)
        ld b,a
sg_b:   ld a,(hl)
        ld (de),a
        inc hl
        inc de
        djnz sg_b
        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,sg_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
sg_nx:
        dec c
        jr nz,sg_row
        ret

; HL = Maske/Sprite verschränkt, DE = Bildschirm – maskiert zeichnen
draw_m:
        ld a,(cur_h)
        ld c,a
dm_row: push de
        ld a,(cur_w)
        ld b,a
dm_b:   ld a,(de)
        and (hl)
        inc hl
        or (hl)
        inc hl
        ld (de),a
        inc de
        djnz dm_b
        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

; 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

; ================= Daten =================
frames:    dw 0
hits:      dw 0
touch:     db 0
was_touch: db 0
swapped:   db 0
p_r:       db 0
p_b:       db 0
hidden:    db &40             ; High-Byte des Bildes, in das gezeichnet wird
cur_type:
cur_w:     db 0
cur_h:     db 0
cur_mx:    db 0
cur_my:    db 0
cur_dat:   dw 0
cur_rl:    dw rl0
cur_bg:    dw bg0
cur_cnt:   dw cnt0
oth_rl:    dw rl1
oth_bg:    dw bg1
oth_cnt:   dw cnt1
cnt0:      db 0
cnt1:      db 0
; Typen: Breite (Bytes), Höhe, max. x = 80 − Breite, max. y = 200 − Höhe, Datenadresse
types:
        db 4,16,76,184
        dw typ0             ; Pixelgeist
        db 4,16,76,184
        dw typ1             ; Rakete
        db 2,8,78,192
        dw typ2             ; Münze
        db 3,12,77,188
        dw typ3             ; Käfer
; Objekte: x (Byte), y (Zeile), dx, dy, Typ, 3 Bytes frei
ent:
        db 4,8,1,2,0,0,0,0     ; 0: Pixelgeist
        db 27,55,255,1,1,0,0,0     ; 1: Rakete
        db 50,102,2,253,2,0,0,0     ; 2: Münze
        db 73,149,255,2,3,0,0,0     ; 3: Käfer
        db 26,26,1,255,2,0,0,0     ; 4: Münze
        db 49,73,254,3,3,0,0,0     ; 5: Käfer
        db 72,120,1,254,1,0,0,0     ; 6: Rakete
        db 25,167,255,1,2,0,0,0     ; 7: Münze
        db 48,44,2,2,3,0,0,0     ; 8: Käfer
        db 71,91,255,253,0,0,0,0     ; 9: Pixelgeist
ord:    db 0,1,2,3,4,5,6,7,8,9       ; Zeichenreihenfolge (wird nach y sortiert)
rl0:    ds 30             ; Wiederherstellungsliste Bild 1
rl1:    ds 30             ; … Bild 2
bg0:    ds 640            ; gesicherter Hintergrund (64 Bytes je Platz)
bg1:    ds 640
typ0:
        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
typ1:
        db &FF,&00,&AA,&14,&55,&28,&FF,&00
        db &FF,&00,&00,&3C,&00,&3C,&FF,&00
        db &FF,&00,&00,&0C,&00,&0C,&FF,&00
        db &AA,&04,&00,&0C,&00,&0C,&55,&08
        db &AA,&04,&00,&09,&00,&06,&55,&08
        db &AA,&04,&00,&03,&00,&03,&55,&08
        db &AA,&04,&00,&09,&00,&06,&55,&08
        db &AA,&04,&00,&0C,&00,&0C,&55,&08
        db &AA,&04,&00,&0C,&00,&0C,&55,&08
        db &AA,&04,&00,&0C,&00,&0C,&55,&08
        db &00,&2C,&00,&0C,&00,&0C,&00,&1C
        db &00,&3C,&00,&0C,&00,&0C,&00,&3C
        db &00,&3C,&AA,&50,&55,&A0,&00,&3C
        db &55,&28,&AA,&50,&55,&A0,&AA,&14
        db &FF,&00,&55,&A0,&AA,&50,&FF,&00
        db &FF,&00,&AA,&11,&55,&22,&FF,&00
typ2:
        db &AA,&50,&55,&A0
        db &00,&F0,&00,&F0
        db &00,&A4,&00,&F0
        db &00,&F0,&00,&F0
        db &00,&F0,&00,&F0
        db &00,&72,&00,&B1
        db &AA,&11,&55,&22
        db &FF,&00,&FF,&00
typ3:
        db &FF,&00,&00,&FC,&FF,&00
        db &AA,&54,&00,&FC,&55,&A8
        db &00,&FC,&00,&03,&00,&FC
        db &00,&A9,&00,&CC,&00,&56
        db &00,&FC,&00,&FC,&00,&FC
        db &55,&A8,&00,&FC,&AA,&54
        db &00,&FC,&00,&FC,&00,&FC
        db &AA,&54,&00,&FC,&55,&A8
        db &55,&A8,&00,&FC,&AA,&54
        db &00,&FC,&00,&FC,&00,&FC
        db &AA,&54,&FF,&00,&55,&A8
        db &55,&A8,&FF,&00,&AA,&54
; Versatz jeder Pixelzeile relativ zum Bildanfang: (y MOD 8)·&800 + (y DIV 8)·80
lines:
        dw &0000,&0800,&1000,&1800,&2000,&2800,&3000,&3800
        dw &0050,&0850,&1050,&1850,&2050,&2850,&3050,&3850
        dw &00A0,&08A0,&10A0,&18A0,&20A0,&28A0,&30A0,&38A0
        dw &00F0,&08F0,&10F0,&18F0,&20F0,&28F0,&30F0,&38F0
        dw &0140,&0940,&1140,&1940,&2140,&2940,&3140,&3940
        dw &0190,&0990,&1190,&1990,&2190,&2990,&3190,&3990
        dw &01E0,&09E0,&11E0,&19E0,&21E0,&29E0,&31E0,&39E0
        dw &0230,&0A30,&1230,&1A30,&2230,&2A30,&3230,&3A30
        dw &0280,&0A80,&1280,&1A80,&2280,&2A80,&3280,&3A80
        dw &02D0,&0AD0,&12D0,&1AD0,&22D0,&2AD0,&32D0,&3AD0
        dw &0320,&0B20,&1320,&1B20,&2320,&2B20,&3320,&3B20
        dw &0370,&0B70,&1370,&1B70,&2370,&2B70,&3370,&3B70
        dw &03C0,&0BC0,&13C0,&1BC0,&23C0,&2BC0,&33C0,&3BC0
        dw &0410,&0C10,&1410,&1C10,&2410,&2C10,&3410,&3C10
        dw &0460,&0C60,&1460,&1C60,&2460,&2C60,&3460,&3C60
        dw &04B0,&0CB0,&14B0,&1CB0,&24B0,&2CB0,&34B0,&3CB0
        dw &0500,&0D00,&1500,&1D00,&2500,&2D00,&3500,&3D00
        dw &0550,&0D50,&1550,&1D50,&2550,&2D50,&3550,&3D50
        dw &05A0,&0DA0,&15A0,&1DA0,&25A0,&2DA0,&35A0,&3DA0
        dw &05F0,&0DF0,&15F0,&1DF0,&25F0,&2DF0,&35F0,&3DF0
        dw &0640,&0E40,&1640,&1E40,&2640,&2E40,&3640,&3E40
        dw &0690,&0E90,&1690,&1E90,&2690,&2E90,&3690,&3E90
        dw &06E0,&0EE0,&16E0,&1EE0,&26E0,&2EE0,&36E0,&3EE0
        dw &0730,&0F30,&1730,&1F30,&2730,&2F30,&3730,&3F30
        dw &0780,&0F80,&1780,&1F80,&2780,&2F80,&3780,&3F80

Assembler-Liste · Klick auf ● = Haltepunkt

Bilder

Bilder/s

…

Emulatorzeit

Berührungen

Objekt 0 frei

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 Hauptschleife

Ein Durchlauf erzeugt ein Bild. Im flimmerfreien Modus wird immer in das Bild gezeichnet, das der Monitor gerade NICHT zeigt.

          ┌──────────────────────────────────────────────┐
          │ frame:                                       │
          ▼                                              │
  1. Hintergrund zurück  (Liste des unsichtbaren Bildes, │
     letzter Eintrag zuerst)                             │
          ▼                                              │
  2. Tasten lesen (KM TEST KEY) · bewegen · abprallen    │
          ▼                                              │
  3. Kollision Objekt 0 ↔ andere → Rand rot, Zähler      │
          ▼                                              │
  4. nach y sortieren (Maleralgorithmus)                 │
          ▼                                              │
  5. je Sprite: Hintergrund sichern, maskiert zeichnen   │
          ▼   ── work_end ──                             │
  6. warten: VSYNC-Ende, dann VSYNC-Beginn (PPI Port B)  │
          ▼                                              │
  7. CRTC R12 umschalten (&10 ↔ &30), Listen tauschen ───┘

; ================= Hauptschleife: ein Durchlauf = ein Bild =================
frame:
        call restore_all      ; 1. Hintergrund zurück (umgekehrte Zeichenreihenfolge)
        ; (kein Spieler – alle Sprites bewegen sich selbst)
        call move_all         ; 2. Positionen: x += dx, y += dy, an den Rändern abprallen
        call collide          ; 3. Kollision Objekt 0 ↔ andere (Rechtecke)
        call sort_y           ; 4. nach y sortieren (Maleralgorithmus)
        call draw_all         ; 5. Hintergrund sichern + maskiert zeichnen
work_end:
        call wait_frame       ; 6. auf den Beginn des nächsten Strahlrücklaufs warten
        call flip             ; 7. unsichtbares Bild zeigen (CRTC R12), Puffer tauschen
        ld hl,(frames)
        inc hl
        ld (frames),hl        ; Bildzähler
        jp frame

🖌️Zeichenreihenfolge: der Maleralgorithmus

Wo sich Sprites überlappen, gewinnt das zuletzt gezeichnete – wie beim Malen auf Leinwand.

💡 Nach y sortieren

Die Figuren werden vor dem Zeichnen nach ihrer y-Position sortiert: weiter oben zuerst, weiter unten zuletzt. Weiter unten wirkt „näher“ – so entsteht ohne Z-Puffer eine glaubwürdige Überdeckung. Die Liste ist vom letzten Bild fast sortiert, deshalb reicht ein Bubble Sort, der meist nach einem Durchgang fertig ist.

⚠️ Rückwärts wiederherstellen

Jede Figur sichert beim Zeichnen den Hintergrund – der kann schon eine andere Figur enthalten. Deshalb wird in umgekehrter Reihenfolge wiederhergestellt: das zuletzt gezeichnete Sprite zuerst. Sonst bleiben Reste stehen.

✅ Zwei Listen bei zwei Bildern

Mit Double Buffering hat jedes Bild seine eigene Liste (Adressen, Typen) und eigene Hintergrundpuffer – ein Bild wird ja erst zwei Durchläufe später wieder bearbeitet.

⏱️Warum es ohne Double Buffering flackert

Ohne zweites Bild fehlt jedes Sprite eine Weile: vom Wiederherstellen des Hintergrunds bis zum Neuzeichnen. Trifft der Strahl genau diese Lücke, sieht man es.

Sprites: 10Schleife beginnt 6.000 µs nach dem VSYNC

Strahl gibt die Zeilen dieses Sprites ausSprite fehlt oder ist halb gezeichnet (wiederhergestellt, noch nicht neu gezeichnet)… und der Strahl liest genau dann → sichtbares Flackern/Zerreißen

Ohne Double Buffering: 6 von 10 Sprites werden in diesem Durchlauf gelesen, während sie fehlen oder halb fertig sind.
Mit Double Buffering: 0 – gezeichnet wird ausschließlich im unsichtbaren Bild, umgeschaltet wird im Strahlrücklauf.

Berechnet aus den im Emulator gemessenen Einzelkosten je Typ (wiederherstellen / sichern / zeichnen) und den Startpositionen; die Verwaltung (Bewegen, Sortieren, Kollision) ist hier weggelassen. Der Emulator selbst zeichnet sein Bild einmal je Browser-Bild vollständig – das Zerreißen ist dort nicht zu sehen, deshalb diese Zeitachse.

vollständig

zerrissen

Simulation: oben schon 2 Pixel weiter, unten noch an der alten Stelle – so sieht ein Sprite aus, das der Strahl mitten im Umzeichnen erwischt.

📊Das Zeitbudget: wie viele Sprites passen in 19 968 µs?

Sprites	Rechenzeit je Bild (µs)	Anteil	Bilder/s	Budget

messe … (0/16) Messung im Emulator: Mittel über 10 Bilder, Balken bis 3 Bildzeiten. Die Sprite-Mischung ist fest (Geist, Rakete, Münze, Käfer …).

🚀Wie man mehr Sprites schafft

Pixelgeist (4 × 16 Bytes)	Szene (µs)	schneller (µs)	wie
Hintergrund wiederherstellen	1.178	695	Schleife mit DJNZ → LDI entrollt (Routine a)
Hintergrund sichern	1.178	695	ebenso mit LDI
maskiert zeichnen	1.562	565	Breite aus Variable → kompiliertes Sprite (Routine f)
Summe je Bild	3.918	1.955	5 bzw. 10 Geister passen rechnerisch in 19 968 µs (ohne Verwaltung)

Alle Werte sind im Emulator gemessene Routinen (inkl. CALL/RET). Die Szene selbst verwendet bewusst die einfachen, allgemeinen Schleifen (Breite und Höhe aus Variablen), damit ein Programm alle Größen zeichnen kann – das kostet. Zum Vergleich die einfache Maskenroutine mit festen Maßen (Routine c): 1.511 µs.

✅ Schnellere Routinen

LDI statt Schleifen, kompilierte Sprites statt Masken-Schleife – die Tabelle oben zeigt die gemessene Ersparnis für einen Geist.

✅ Kleinere Sprites

Die Kosten wachsen mit Breite × Höhe: eine Münze (2 × 8 Bytes) kostet in der Szene nur rund ein Drittel eines Geists (4 × 16).

✅ Nur Geändertes restaurieren

Wer nur die Streifen wiederherstellt, die ein Sprite beim Bewegen wirklich freigibt, spart den Großteil der Restaurierung – bei 1 Byte Bewegung je Bild ist das nur eine schmale Spalte.

✅ Auf zwei Bilder verteilen

Die Hälfte der Figuren in geraden, die andere in ungeraden Bildern bewegen: die Arbeit je Bild halbiert sich, jede Figur bewegt sich dann mit 25 statt 50 Schritten je Sekunde.

⌨️Tastatur: vom Browser zur CPC-Tastennummer

Die Firmware-Routine KM TEST KEY (&BB1E) erwartet in A eine Tastennummer 0–79 und meldet mit dem Zero-Flag, ob die Taste gedrückt ist (SOFT 968). Achtung: in C liefert sie den Zustand von Shift und Control – C ist danach verändert.

Taste	Nummer	Matrix
Cursor hoch	0	Zeile 0, Bit 0
Cursor rechts	1	Zeile 0, Bit 1
Cursor runter	2	Zeile 0, Bit 2
Cursor links	8	Zeile 1, Bit 0
P	27	Zeile 3, Bit 3
O	34	Zeile 4, Bit 2
Leertaste	47	Zeile 5, Bit 7
W	59	Zeile 7, Bit 3
S	60	Zeile 7, Bit 4
D	61	Zeile 7, Bit 5
Q	67	Zeile 8, Bit 3
A	69	Zeile 8, Bit 5
Joystick 0 hoch / runter / links / rechts	72	Zeile 9, Bits 0–3 → 72–75

Tastennummer = 8 × Matrixzeile + Bit. Matrix nach K. Thacker, „Reading the keyboard and Joysticks“ (cpctech); SOFT 968: gültige Tastennummern 0–79.

💡 Was die Firmware dafür tut

Die Tastatur ist eine Matrix aus 10 Zeilen × 8 Bits. Über Bits 3–0 von PPI-Port C wird eine Zeile gewählt; ihr Zustand liegt am Ein-/Ausgabeport A des Soundchips AY-3-8912 (PSG-Register 14) und wird über PPI-Port A gelesen – ein gedrücktes Bit ist 0. Die Firmware tastet die Matrix regelmäßig ab (normalerweise 50-mal je Sekunde) und legt das Ergebnis in einer Tabelle ab, die KM TEST KEY liest.

⚠️ Im Browser

Nur wenn der CPC-Bildschirm den Fokus hat, werden Tasten an den Emulator gegeben – dann (und nur dann) scrollen Pfeiltasten die Seite nicht. Jede Browser-Taste wird die gleichnamige CPC-Taste; bei QAOP ist A „runter“, bei WASD „links“ – deshalb die Auswahl der Belegung. Echte Tastatur-Geisterbilder („keyboard clash“) bei mehreren gedrückten Tasten bildet der Simulator nicht nach.