Carry a pixel into the next byte

Our ship needs to move less than one character at a time. First, move two pixels one place to the right without losing either of them.

This is a fresh project for a 48K PAL ZX Spectrum. We will use registers, memory addresses, calls and branches from Meet Assembly. You do not need BASIC. Each editor contains a complete program; Assemble and run starts a fresh machine without a tape wait. Save your edits before using Revert.

A row that crosses a boundary

The byte %10000001, hexadecimal $81, lights its leftmost and rightmost pixels. Put an empty byte after it and we have sixteen possible pixel positions:

Before: 10000001 00000000
After:  01000000 10000000

The rightmost 1 of the first byte must become the leftmost bit of the second. Throw it away and one of our pixels vanishes every time it crosses a byte boundary.

Run the program. Most of the screen will stay black: these two rows are tiny. The magnified view reads the actual screen bytes. Its first row is the original pair; its second is the shifted pair.

Run to read the bytes.

Follow the carry

The program sets A to $81 and B to zero. srl a shifts A right, puts zero into its leftmost bit, and puts the bit that fell off the right into the carry flag. Carry is one bit in the flags register; here it remembers the displaced pixel.

rr b rotates B right through carry. The previous carry enters B’s leftmost bit. B’s former rightmost bit becomes the new carry. After these two instructions A is $40 and B is $80.

 ld a,%10000001
 ld ($480C),a
 ; Shift right once, carrying the lost bit into the next byte.
 ; RR starts with the carry from SRL: $81,0 becomes $40,$80.
 ld a,%10000001
 ld b,0
 srl a
 rr b
 ld ($490C),a
 ld a,b
 ld ($490D),a

The writes to $480C, $490C and $490D choose two neighbouring bytes on neighbouring pixel rows. We will derive those addresses shortly. ld (address),a copies the value; it does not move the value out of A.

Change one thing

Replace both occurrences of %10000001 with %11111111. Predict both rows, then assemble again.

clear prepares black bitmap memory and white ink. It uses LDIR: copy the byte at HL to DE, advance both pointers, decrement BC and repeat until BC is zero. The source and destination are one byte apart, so the first value propagates through the range. Bitmap and attribute memory are cleared separately. The hold loop keeps execution away from the following helper code.

Use Download source for meteor-storm.asm. For local work, Asm198x is the primary tool; upstream Pasmo accepts the same source:

asm198x --dialect pasmo --cpu z80 --tapbas meteor-storm.asm -o meteor-storm.tap
# Or:
pasmo --tapbas meteor-storm.asm meteor-storm.tap

To run the tape on the desktop, use Emu198x, the recommended emulator; getting started covers downloading it and the 48K ROM it needs. From its folder:

./emu198x-spectrum --rom "path/to/48.rom" --tape meteor-storm.tap --autoload-tape

Reassembling reloads the whole experiment. Use the magnified bitmap reading to inspect the two rows.