c64-kb 0.17.0

package/templates/demo/src/music.asm

@@ -0,0 +1,197 @@
+// music.asm: an original three-voice tune and the player that plays it,
+// behind the init/play convention most tracker exports use
+// (sid_play_routine_pattern): JSR $1000 once with A = subtune, JSR $1003
+// once a frame. To use a GoatTracker or other export instead, replace this
+// file with the tune's binary at $1000 (`.import binary`, header stripped)
+// and keep the two calls; the NTSC tempo skip lives in the framework.
+//
+// This player's one extension of the convention: X = 0 (PAL) or 1 (NTSC) at
+// init picks the frequency table, so the pitch is right on both clocks.
+//
+// The tune: A minor, F, C, G; a sawtooth bass, a pulse arpeggio that steps
+// through the chord every frame, and noise and triangle drums on voice 3.
+// 32 steps of 7 frames: 224 frames a loop, 4.48 s on PAL.
+
+* = $1000 "music"
+MUSIC_INIT: jmp m_init
+MUSIC_PLAY: jmp m_play
+
+.const STEP_FRAMES = 7
+.const STEPS       = 32
+.const NOTE0       = 24                // the frequency tables start at C1 (MIDI 24)
+.const NOTES       = 73                // to C7
+
+m_init:
+        ldy #NOTES - 1                 // X = model: copy that clock's table
+!:      cpx #0
+        bne !ntsc+
+        lda freq_lo_pal,y
+        sta freq_lo,y
+        lda freq_hi_pal,y
+        sta freq_hi,y
+        jmp !next+
+!ntsc:  lda freq_lo_ntsc,y
+        sta freq_lo,y
+        lda freq_hi_ntsc,y
+        sta freq_hi,y
+!next:  dey
+        bpl !-
+        lda #0
+        ldx #$18
+!:      sta $d400,x                    // silence every register first
+        dex
+        bpl !-
+        sta m_step
+        sta m_tick
+        sta m_arp
+        sta m_drum_left
+        lda #$09                       // bass: attack 0, decay 9, sustain 10, release 9
+        sta $d405
+        lda #$a9
+        sta $d406
+        lda #$00                       // arpeggio: pulse width 50 %, sustain 10
+        sta $d409
+        lda #$08
+        sta $d40a
+        lda #$00
+        sta $d40c
+        lda #$a6
+        sta $d40d
+        lda #$41                       // pulse, gate on: held for the whole tune
+        sta $d40b
+        lda #$0f                       // volume 15, no filter
+        sta $d418
+        rts
+
+m_play:
+        // Voice 2: the next tone of the current chord, every frame.
+        lda m_step
+        lsr
+        lsr
+        lsr                            // chord = step / 8
+        sta m_tmp
+        asl
+        adc m_tmp                      // x 3 tones
+        adc m_arp
+        tax
+        ldy chord_tones,x
+        lda freq_lo - NOTE0,y
+        sta $d407
+        lda freq_hi - NOTE0,y
+        sta $d408
+        inc m_arp
+        lda m_arp
+        cmp #3
+        bne !+
+        lda #0
+        sta m_arp
+!:
+        // Voice 3: the running drum's pitch slide, then its gate off.
+        lda m_drum_left
+        beq !+
+        lda m_drum_hi
+        clc
+        adc m_drum_step
+        sta m_drum_hi
+        sta $d40f
+        dec m_drum_left
+        bne !+
+        lda m_drum_wave
+        sta $d412                      // gate off: the release runs
+!:
+        // A new step on tick 0.
+        lda m_tick
+        bne !later+
+        ldx m_step
+        ldy bass,x
+        beq !+
+        lda freq_lo - NOTE0,y
+        sta $d400
+        lda freq_hi - NOTE0,y
+        sta $d401
+        lda #$21                       // sawtooth, gate on
+        sta $d404
+!:      ldy drums,x
+        beq !advance+
+        lda drum_ad - 1,y
+        sta $d413
+        lda drum_sr - 1,y
+        sta $d414
+        lda drum_hi - 1,y
+        sta m_drum_hi
+        sta $d40f
+        lda drum_step - 1,y
+        sta m_drum_step
+        lda drum_frames - 1,y
+        sta m_drum_left
+        lda drum_wave - 1,y
+        sta m_drum_wave
+        ora #$01
+        sta $d412                      // gate on
+        jmp !advance+
+!later: cmp #STEP_FRAMES - 1           // last frame of a step: gate the bass off
+        bne !advance+                  // if the next step plays a note, so its
+        ldx m_step                     // envelope restarts cleanly
+        inx
+        txa
+        and #STEPS - 1
+        tax
+        lda bass,x
+        beq !advance+
+        lda #$20
+        sta $d404
+!advance:
+        inc m_tick
+        lda m_tick
+        cmp #STEP_FRAMES
+        bne !+
+        lda #0
+        sta m_tick
+        lda m_step
+        clc
+        adc #1
+        and #STEPS - 1
+        sta m_step
+!:      rts
+
+// ---- the tune ---------------------------------------------------------------
+.function BassBar(root) {
+    .return List().add(root, 0, root + 12, root, 0, root, root + 12, root + 7)
+}
+bass:
+        .for (var c = 0; c < 4; c++) {
+            .var bar = BassBar(List().add(33, 29, 36, 31).get(c))
+            .for (var i = 0; i < 8; i++) { .byte bar.get(i) }
+        }
+chord_tones:                           // Am, F, C, G: three tones each
+        .byte 57, 60, 64,  53, 57, 60,  55, 60, 64,  55, 59, 62
+drums:                                 // 1 kick, 2 snare, 3 hat
+        .for (var c = 0; c < 4; c++) {
+            .byte 1, 0, 3, 0, 2, 0, 3, 3
+        }
+//                   kick  snare  hat
+drum_wave:   .byte   $10,  $80,   $80
+drum_ad:     .byte   $00,  $00,   $00
+drum_sr:     .byte   $a0,  $a8,   $80
+drum_hi:     .byte   $18,  $20,   $50
+drum_step:   .byte   $f9,  $00,   $00  // kick: $18, $11, $0a, $03
+drum_frames: .byte   3,    2,     1
+
+// SID frequency = Hz * 2^24 / clock; A4 = 440 Hz. PAL 985,248 Hz, NTSC
+// 1,022,727 Hz (docs/hardware/pal-ntsc-reference.md; the tables are arithmetic).
+.function NoteHz(n) { .return 440 * pow(2, (n - 69) / 12) }
+freq_lo_pal:  .fill NOTES, <round(NoteHz(NOTE0 + i) * 16777216 / 985248)
+freq_hi_pal:  .fill NOTES, >round(NoteHz(NOTE0 + i) * 16777216 / 985248)
+freq_lo_ntsc: .fill NOTES, <round(NoteHz(NOTE0 + i) * 16777216 / 1022727)
+freq_hi_ntsc: .fill NOTES, >round(NoteHz(NOTE0 + i) * 16777216 / 1022727)
+freq_lo:      .fill NOTES, 0
+freq_hi:      .fill NOTES, 0
+
+m_step:      .byte 0
+m_tick:      .byte 0
+m_arp:       .byte 0
+m_tmp:       .byte 0
+m_drum_left: .byte 0
+m_drum_hi:   .byte 0
+m_drum_step: .byte 0
+m_drum_wave: .byte 0

package/templates/demo/src/part_main.asm

@@ -0,0 +1,279 @@
+// part_main.asm: part 1. A character logo, eight sprites on a sine chain,
+// four raster bars from a stable raster kernel, a 1x1 scroller on row 22.
+//
+//   lines  51-98   logo, rows 0-4, and the subtitle, row 5
+//   lines 101-145  the sprite chain (Y 100-124): no sprite on a bar line
+//   lines 155-210  the bars, one colour per line, border and background
+//   lines 227-234  the scroller, row 22, 38 columns and XSCROLL
+//
+// Its chain (parts.asm): bars_slot at 148, scroll_slot at 224, frame_slot.
+// update runs in the frame slot, below the picture: every register and
+// table it writes is used by the next frame, so nothing tears.
+
+.const MSG_START = 40                  // the row starts full: message cells 0-39
+
+main_init:
+        lda #0
+        sta $d020
+        sta $d021
+        sta border_colour
+        sta $d017                      // every sprite register this part relies on,
+        sta $d01b                      // not only the ones it changes (pitfall
+        sta $d01c                      // sprite_registers_persist_across_state_change)
+        sta $d01d
+        ldx #7
+!:      lda #SPRITE_BLOCK
+        sta SCREEN + $3f8,x
+        lda chain_colour,x
+        sta $d027,x
+        dex
+        bpl !-
+        lda #$20                       // a blank screen first: the part before may
+        ldx #0                         // have ended on a hard cut, not a wipe
+!:      sta SCREEN,x                   // (colour RAM is left: the meter tints its cells)
+        sta SCREEN+$100,x
+        sta SCREEN+$200,x
+        sta SCREEN+$2e8,x
+        inx
+        bne !-
+        ldx #5 * 40 - 1                // the logo and the subtitle, rows 0-5
+!:      lda logo_cells,x
+        sta SCREEN,x
+        lda logo_colours,x
+        sta COLOUR,x
+        dex
+        cpx #$ff
+        bne !-
+        ldx #39
+!:      lda subtitle,x
+        sta SCREEN + 5 * 40,x
+        lda #15
+        sta COLOUR + 5 * 40,x
+        lda message,x                  // the scroller's row starts full
+        sta SCREEN + SCROLL_ROW * 40,x
+        lda scroll_colours,x
+        sta COLOUR + SCROLL_ROW * 40,x
+        dex
+        bpl !-
+        lda #<(message + MSG_START)
+        sta msg_read+1
+        lda #>(message + MSG_START)
+        sta msg_read+2
+        lda #7
+        sta xscroll
+        lda #CHAIN_FAULT
+        sta ph_x
+        lda #0
+        sta ph_y
+        sta ph_b
+        sta updates
+        sta updates+1
+        sta frozen
+        jsr place_sprites
+        jsr fill_bars
+        lda #$ff
+        sta $d015
+        rts
+
+// Frame slot. Advance, then compute: after k updates the picture shows
+// phase k * speed, which is what the verdict and gen_expect.py predict.
+main_update:
+        lda frozen
+        bne !+
+        lda ph_x
+        clc
+        adc #CHAIN_SX
+        sta ph_x
+        lda ph_y
+        clc
+        adc #CHAIN_SY
+        sta ph_y
+        lda ph_b
+        clc
+        adc #BAR_SPEED
+        sta ph_b
+        jsr place_sprites
+        jsr fill_bars
+        jsr scroll_step
+        inc updates
+        bne !freeze+
+        inc updates+1
+!freeze:
+#if AUTOPILOT
+        lda updates+1                  // the autopilot's fixed frame: hold still
+        bne !+
+        lda updates
+        cmp #FREEZE_UPDATES
+        bne !+
+        lda #1
+        sta frozen
+#endif
+!:      rts
+
+main_teardown:
+        lda #0
+        sta $d015
+        lda #$c8
+        sta $d016
+        rts
+
+// ---- sprite chain -------------------------------------------------------------
+// Sprite n: X = base_n + chain_sinx[ph_x + n * CHAIN_PX], Y = chain_siny[ph_y +
+// n * CHAIN_PY]. X passes 255, so the ninth bits are gathered into $D010
+// every frame (pitfall sprite_x_high_bit_wrong_register).
+place_sprites:
+        .for (var n = 0; n < 8; n++) {
+            .var base = CHAIN_X0 + n * CHAIN_DX - CHAIN_AX
+            lda ph_x
+            clc
+            adc #<(n * CHAIN_PX)
+            tay
+            lda #<base
+            clc
+            adc chain_sinx,y
+            sta $d000 + 2 * n
+            lda #>base
+            adc #0
+            lsr                        // the ninth bit into carry, then into msb
+            ror msb
+            lda ph_y
+            clc
+            adc #<(n * CHAIN_PY)
+            tay
+            lda chain_siny,y
+            sta $d001 + 2 * n
+        }
+        lda msb                        // eight RORs: sprite 0's bit is bit 0
+        sta $d010
+        rts
+
+// ---- bars -----------------------------------------------------------------------
+// bar_colours[i] is the colour of line BARS_TOP + i. Cleared, then four
+// 12-line ramps at sine positions; the later bar is drawn over the earlier.
+fill_bars:
+        lda #0
+        ldx #BARS_LINES - 1
+!:      sta bar_colours,x
+        dex
+        bpl !-
+        .for (var b = 0; b < 4; b++) {
+            lda ph_b
+            clc
+            adc #<(b * BAR_STEP)
+            tay
+            ldx bar_top,y
+            ldy #0
+        !:  lda ramps + b * BAR_H,y
+            sta bar_colours,x
+            inx
+            iny
+            cpy #BAR_H
+            bne !-
+        }
+        rts
+
+// ---- the 1x1 scroller -------------------------------------------------------------
+// XSCROLL 7 down to 0, a pixel a frame; past 0 the row moves one cell left,
+// the next message cell comes in on the right and XSCROLL is 7 again.
+scroll_step:
+        dec xscroll
+        bpl !done+
+        lda #7
+        sta xscroll
+        ldx #0
+!:      lda SCREEN + SCROLL_ROW * 40 + 1,x
+        sta SCREEN + SCROLL_ROW * 40,x
+        inx
+        cpx #39
+        bne !-
+msg_read:
+        lda message                    // the operand is the read pointer
+        bne !+
+        lda #<message                  // 0 ends the message: start again
+        sta msg_read+1
+        lda #>message
+        sta msg_read+2
+        lda message
+!:      sta SCREEN + SCROLL_ROW * 40 + 39
+        inc msg_read+1
+        bne !done+
+        inc msg_read+2
+!done:  rts
+
+// ---- the slots ----------------------------------------------------------------------
+// Line 148: stabilise returns on cycle 51 of line 153 (both models, the
+// monitor's numbering), then the kernel for this model (patched at start)
+// draws lines 155 to 210.
+bars_slot:
+        jsr stabilise
+kernel_call:
+        jsr kernel_pal                 // start: kernel_ntsc on a 6567
+        rts
+
+// Line 224: row 22 in 38-column mode with this frame's XSCROLL. The frame
+// slot writes $C8 back at line 236, so no other row moves (pitfall
+// xscroll_applies_to_all_rows).
+scroll_slot:
+        lda xscroll
+        ora #$c0                       // CSEL 0: 38 columns hide the column coming in
+        sta $d016
+        rts
+
+// ---- the bar kernel -----------------------------------------------------------------
+// One chunk a line: load the line's colour, store it to $D020 and $D021 in
+// the horizontal blank, then wait for the next line. Measured with the VICE
+// monitor (README, "The stable entry and the bars"): each chunk's STA $D020 starts on
+// cycle 60 (PAL) or 62 (NTSC) of the line above, so the stores write on
+// cycles 0 and 4 of the bar line, in the monitor's numbering (0 to 62 or 64),
+// and the next chunk starts exactly one line later, badline or not.
+// A normal line gives the CPU all its cycles. A badline ((line & 7) == 3
+// with YSCROLL 3) takes the bus from the CPU for 43 cycles, so its chunk
+// has only NOPs after the stores: all read cycles, which the VIC holds, and
+// the stall is the rest of the line (pitfall badline_cycle_loss). No sprite
+// may be on lines 148-211: each chunk is a fixed length, so sprite DMA on
+// one line delays that chunk and every later one until a badline resyncs
+// them (config.asm refuses a sprite chain that reaches these lines).
+//   cycles  line length, 63 (6569) or 65 (6567R8)
+//   lead    cycles from the kernel's first instruction to the first chunk
+.macro BarKernel(cycles, lead) {
+    Delay(lead)
+    .for (var i = 0; i < BARS_LINES; i++) {
+        .var line = BARS_TOP + i
+        lda bar_colours + i            // 4
+        sta $d020                      // 4: writes on cycle 0 of `line`
+        sta $d021                      // 4: writes on cycle 4
+        .if ((line & 7) == 3) {
+            Pad(cycles - 55)           // 20 (22) cycles a badline leaves: 12 + 8 (10)
+        } else {
+            Delay(cycles - 12)
+        }
+    }
+    lda border_colour                  // after the last bar: the part's border
+    sta $d020                          // writes on cycle 0
+    lda #0
+    sta $d021                          // writes on cycle 6
+    rts
+}
+
+#if PROBE
+.const PROBE_SHIFT = 20                // the probe build moves every store 20 cycles right
+#else
+.const PROBE_SHIFT = 0
+#endif
+// The leads put the stores mid-blank: measured with the PROBE build and the
+// monitor (README, "The stable entry and the bars").
+.const LEAD_PAL  = 62 + PROBE_SHIFT
+.const LEAD_NTSC = 66 + PROBE_SHIFT
+
+kernel_pal:  BarKernel(63, LEAD_PAL)
+kernel_ntsc: BarKernel(65, LEAD_NTSC)
+
+// ---- the part's state ---------------------------------------------------------------
+ph_x:          .byte 0
+ph_y:          .byte 0
+ph_b:          .byte 0
+msb:           .byte 0
+xscroll:       .byte 7
+updates:       .word 0
+border_colour: .byte 0
+bar_colours:   .fill BARS_LINES, 0

package/templates/demo/src/part_title.asm

@@ -0,0 +1,79 @@
+// part_title.asm: part 0, the title card. Three lines of text, the first
+// one colour-cycled, on a black screen; the wipe takes it off. The smallest
+// complete part: copy it to start a new one.
+//
+// The text sits on rows 13, 15 and 17, inside the main part's bar lines
+// (155-210), so the bar checks in expect.json also prove it is gone.
+
+.const TITLE_ROW = 13
+
+title_init:
+        lda #0
+        sta $d015                      // no sprites
+        sta $d020
+        sta $d021
+        lda #$c8
+        sta $d016
+        lda #$15                       // screen $0400, the ROM's upper-case set
+        sta $d018
+        ldx #0
+!:      lda #$20                       // the whole screen blank, white ink
+        sta SCREEN,x
+        sta SCREEN+$100,x
+        sta SCREEN+$200,x
+        sta SCREEN+$2e8,x
+        lda #1
+        sta COLOUR,x
+        sta COLOUR+$100,x
+        sta COLOUR+$200,x
+        sta COLOUR+$2e8,x
+        inx
+        bne !-
+        ldx #39
+!:      lda title_text,x
+        sta SCREEN + TITLE_ROW * 40,x
+        lda title_text+40,x
+        sta SCREEN + (TITLE_ROW + 2) * 40,x
+        lda title_text+80,x
+        sta SCREEN + (TITLE_ROW + 4) * 40,x
+        lda #14                        // light blue under the second and third lines
+        sta COLOUR + (TITLE_ROW + 2) * 40,x
+        sta COLOUR + (TITLE_ROW + 4) * 40,x
+        dex
+        bpl !-
+        lda #0
+        sta title_phase
+        rts
+
+// Each frame the first line's colours step one place along a 16-entry cycle.
+title_update:
+        inc title_phase
+        lda title_phase
+        lsr                            // one step every second frame
+        sta title_tmp
+        ldx #39
+!:      lda title_tmp
+        and #$0f
+        tay
+        lda title_cycle,y
+        sta COLOUR + TITLE_ROW * 40,x
+        inc title_tmp
+        dex
+        bpl !-
+        rts
+
+title_teardown:
+        lda #1
+        sta title_done                 // the verdict reads it
+        rts
+
+.encoding "screencode_upper"
+title_text:
+        .text "            A C64-KB STARTER            "
+        .text "                PRESENTS                "
+        .text "        A DEMO FOR YOU TO FINISH        "
+title_cycle:
+        .byte 6, 6, 14, 14, 3, 3, 1, 1, 1, 1, 3, 3, 14, 14, 6, 6
+title_phase: .byte 0
+title_tmp:   .byte 0
+title_done:  .byte 0

package/templates/demo/src/parts.asm

@@ -0,0 +1,43 @@
+// parts.asm: the demo's running order and every part's IRQ chain. To add a
+// part: write its file (part_title.asm is the smallest model), give it a
+// chain below, add a column to the part table, and import the file in
+// main.asm.
+//
+// A part is six things:
+//   init      main loop, once, with the idle chain playing the music. May be
+//             slow: decrunch, generate speedcode, draw the screen.
+//   update    frame slot (IRQ), once a frame while the part plays and while
+//             its out-transition runs.
+//   out       frame slot, once a frame after its frames run out, until it
+//             returns carry set. wipe_columns, or hard_cut for a cut.
+//   teardown  main loop, once, before the next part's init: put back what
+//             the next part must not inherit (sprites, $D016, $D018 ...).
+//   frames    how long it plays; 0 plays forever.
+//   chain     its rows in the slot table: rising lines, the frame slot last.
+
+// PART_COUNT and LOOP_PART are in config.asm.
+//                    part 0 (title)       part 1 (main)
+part_init_lo:     .byte <title_init,     <main_init
+part_init_hi:     .byte >title_init,     >main_init
+part_update_lo:   .byte <title_update,   <main_update
+part_update_hi:   .byte >title_update,   >main_update
+part_out_lo:      .byte <wipe_columns,   <wipe_columns
+part_out_hi:      .byte >wipe_columns,   >wipe_columns
+part_teardown_lo: .byte <title_teardown, <main_teardown
+part_teardown_hi: .byte >title_teardown, >main_teardown
+part_frames_lo:   .byte <TITLE_FRAMES,   0
+part_frames_hi:   .byte >TITLE_FRAMES,   0
+part_chain:       .byte chain_title - slots, chain_main - slots
+
+// The slot table: every chain's rows, five bytes each (Slot in framework.asm).
+slots:
+chain_title:
+        Slot(FRAME_LINE, frame_slot, true)
+chain_main:
+        StableSlot(BARS_SLOT_LINE, bars_slot, false)
+        Slot(SCROLL_LINE, scroll_slot, false)
+        Slot(FRAME_LINE, frame_slot, true)
+chain_idle:                            // between parts: the music and nothing else
+        Slot(FRAME_LINE, frame_slot, true)
+slots_end:
+.errorif (slots_end - slots > 255), "the slot table is longer than 255 bytes"

package/templates/demo/src/tables.asm

@@ -0,0 +1,73 @@
+// tables.asm: the main part's data, built by the assembler. The sine tables
+// round with KickAssembler's round(); tools/gen_expect.py recomputes them.
+
+.align $100
+// X swing, 0 to 2 * CHAIN_AX: added to base_n = CHAIN_X0 + n * CHAIN_DX - CHAIN_AX.
+chain_sinx:
+        .fill 256, CHAIN_AX + round(CHAIN_AX * sin(toRadians(i * 360 / 256)))
+// The Y register, CHAIN_Y0 +- CHAIN_AY.
+chain_siny:
+        .fill 256, CHAIN_Y0 + round(CHAIN_AY * sin(toRadians(i * 360 / 256)))
+// A bar's top line, 0 to BARS_LINES - BAR_H, as an index into bar_colours.
+bar_top:
+        .fill 256, BARS_CENTRE + round(BARS_AMP * sin(toRadians(i * 360 / 256)))
+.errorif (BARS_CENTRE + BARS_AMP + BAR_H > BARS_LINES), "a bar would run past the kernel"
+
+// Four ramps, dark to light to dark (luminance order as in colour-fade.md).
+// bar_ramps is in config.asm, so the verdict can draw the same bars.
+ramps:
+        .for (var b = 0; b < 4; b++) {
+            .for (var i = 0; i < BAR_H; i++) .byte bar_ramps.get(b).get(i)
+        }
+
+chain_colour:
+        .fill 8, (i & 1) == 0 ? CHAIN_COL_A : CHAIN_COL_B
+
+// A filled ellipse, 24 x 21, touching all four edges of the sprite box.
+sprite_image:
+        .for (var r = 0; r < 21; r++) {
+            .var dy = (r - 10) / 10.5
+            .var hw = 12 * sqrt(1 - dy * dy)
+            .var bits = 0
+            .for (var c = 0; c < 24; c++) {
+                .var dx = c + 0.5 - 12
+                .eval bits = bits * 2 + (abs(dx) <= hw + 0.5 ? 1 : 0)
+            }
+            .byte (bits >> 16) & $ff, (bits >> 8) & $ff, bits & $ff
+        }
+        .byte 0
+
+// The logo: "DEMO" in a 5 x 5 cell font, reverse spaces, rows 0-4.
+.var logo_font = List().add(
+    "####.  #####  #...#  .###.",
+    "#...#  #....  ##.##  #...#",
+    "#...#  ####.  #.#.#  #...#",
+    "#...#  #....  #...#  #...#",
+    "####.  #####  #...#  .###.")
+.const LOGO_COL = 7
+logo_cells:
+        .for (var r = 0; r < 5; r++) {
+            .var s = logo_font.get(r)
+            .for (var c = 0; c < 40; c++) {
+                .var k = c - LOGO_COL
+                .byte (k >= 0 && k < s.size() && s.charAt(k) == '#') ? $a0 : $20
+            }
+        }
+logo_colours:
+        .for (var r = 0; r < 5; r++) {
+            .fill 40, List().add(4, 10, 7, 10, 4).get(r)
+        }
+
+scroll_colours:
+        .byte 11, 12, 15
+        .fill 34, 1
+        .byte 15, 12, 11
+
+.encoding "screencode_upper"
+subtitle:
+        .text "     C64-KB DEMO STARTER * PART ONE     "
+message:
+        .text "HELLO FROM THE C64-KB DEMO STARTER. A PART TABLE, A TABLE-DRIVEN IRQ CHAIN, "
+        .text "A STABLE RASTER KERNEL, EIGHT SPRITES ON A SINE, FOUR BARS AND THIS SCROLLER, "
+        .text "ALL IN ONE MEASURED FRAME. ADD A PART, CHANGE THE TUNE, MAKE IT YOURS...     "
+        .byte 0