c64-kb 0.17.0

package/templates/platformer/src/art.c

@@ -0,0 +1,212 @@
+// art.c: every picture in the game, as text, turned into glyphs and
+// sprite shapes at start-up. Original art. tools/tearcheck.py reads the
+// glyph art and the slope rule from this file to render the level.
+#include "game.h"
+#include <string.h>
+
+// Playfield glyphs, multicolour: four double-width pixels a row.
+// '.' $D021 sky, 'b' $D022 earth, 'y' $D023 gold, 'g' colour RAM grass.
+// GLYPH-ART-BEGIN
+static const char glyph_code[] = {
+    CH_DIRT, CH_GRASS, CH_BRICK, CH_LEDGE,
+    CH_COIN_TL, CH_COIN_TR, CH_COIN_BL, CH_COIN_BR, CH_FLAG, CH_POLE
+};
+static const char glyph_art[][8][5] = {
+    { "bbbb", "bybb", "bbbb", "bbby", "bbbb", "ybbb", "bbbb", "bbyb" },   // dirt
+    { "gggg", "gggg", "bgbg", "bbbb", "bbyb", "bbbb", "ybbb", "bbbb" },   // grass
+    { "yyyy", "bbyb", "bbyb", "bbyb", "yyyy", "ybbb", "ybbb", "ybbb" },   // brick
+    { "gggg", "bbbb", "b.b.", "....", "....", "....", "....", "...." },   // ledge
+    { "....", "....", "..by", ".byy", "byyy", "byyb", "byyb", "byyb" },   // coin, top left
+    { "....", "....", "yb..", "yyb.", "yyyb", "byyb", "byyb", "byyb" },   // coin, top right
+    { "byyb", "byyb", "byyb", "byyy", ".byy", "..by", "....", "...." },   // coin, bottom left
+    { "byyb", "byyb", "byyb", "yyyb", "yyb.", "yb..", "....", "...." },   // coin, bottom right
+    { "byyy", "byyy", "byyy", "byy.", "by..", "b...", "b...", "b..." },   // flag
+    { "b...", "b...", "b...", "b...", "b...", "b...", "b...", "b..." },   // pole
+};
+// GLYPH-ART-END
+
+// Sprite art, 16 pixels wide, 'x' set. Player art is 21 rows with the feet
+// on row 20; enemy art is 16 rows with the feet on row 15.
+static const char art_shape[] = {
+    SH_STAND, SH_RUN1, SH_RUN2, SH_JUMP, SH_FALL, SH_HURT,
+    SH_WALK1, SH_WALK2, SH_SQUASH, SH_HOP_SIT, SH_HOP_UP
+};
+static const char sprite_art[][21][17] = {
+    {   // stand
+        "......xxxxx.....", ".....xxxxxxx....", ".....xx.xx.x....", ".....xxxxxxx....",
+        ".....xxxx..x....", "......xxxxx.....", ".......xxx......", ".....xxxxxxx....",
+        "....xxxxxxxxx...", "...xx.xxxxx.xx..", "...xx.xxxxx.xx..", "...xx.xxxxx.xx..",
+        "......xxxxx.....", "......xxxxx.....", "......xx.xx.....", "......xx.xx.....",
+        "......xx.xx.....", "......xx.xx.....", "......xx.xx.....", ".....xxx.xxx....",
+        ".....xxx.xxx....",
+    },
+    {   // run 1
+        "......xxxxx.....", ".....xxxxxxx....", ".....xx.xx.x....", ".....xxxxxxx....",
+        ".....xxxx..x....", "......xxxxx.....", ".......xxx......", "....xxxxxxxx....",
+        "...xxxxxxxxxx...", "..xx..xxxxx.xx..", ".xx...xxxxx..xx.", "......xxxxx.....",
+        "......xxxxx.....", ".....xxxxxx.....", ".....xx...xx....", "....xx.....xx...",
+        "....xx.....xx...", "...xx.......xx..", "...xx.......xx..", "..xxx.......xxx.",
+        "..xxx.......xxx.",
+    },
+    {   // run 2
+        "................", "......xxxxx.....", ".....xxxxxxx....", ".....xx.xx.x....",
+        ".....xxxxxxx....", ".....xxxx..x....", "......xxxxx.....", ".......xxx......",
+        ".....xxxxxxx....", "....xxxxxxxxx...", "....xx.xxxx.xx..", "....xx.xxxx.xx..",
+        "......xxxxx.....", "......xxxxx.....", "......xxxx......", ".....xx.xx......",
+        ".....xx..xx.....", "....xx...xx.....", "....xx....xx....", "...xxx....xxx...",
+        "...xxx....xxx...",
+    },
+    {   // jump
+        "..xx..xxxxx..xx.", "..xx.xxxxxxx.xx.", "..xx.xx.xx.x.xx.", "..xx.xxxxxxx.xx.",
+        "..xx.xxxx..x.xx.", "...xx.xxxxx.xx..", "....xxxxxxxxx...", ".....xxxxxxx....",
+        "......xxxxx.....", "......xxxxx.....", "......xxxxx.....", "......xxxxx.....",
+        ".....xxxxxxx....", "....xxx...xxx...", "...xxx.....xxx..", "...xx.......xx..",
+        "...xx.......xx..", "..xxx.......xxx.", "..xxx.......xxx.", "................",
+        "................",
+    },
+    {   // fall: legs down, feet first
+        "..xx..xxxxx..xx.", "..xx.xxxxxxx.xx.", "..xx.xx.xx.x.xx.", "..xx.xxxxxxx.xx.",
+        "...x.xxxx..x.x..", "...xx.xxxxx.xx..", "....xxxxxxxxx...", ".....xxxxxxx....",
+        "......xxxxx.....", "......xxxxx.....", "......xxxxx.....", "......xxxxx.....",
+        "......xxxxx.....", ".....xx...xx....", ".....xx...xx....", ".....xx...xx....",
+        ".....xx...xx....", ".....xx...xx....", "....xxx...xxx...", "....xxx...xxx...",
+        "................",
+    },
+    {   // hurt
+        "................", "..x...xxxxx...x.", "..xx.xxxxxxx.xx.", "...xxx.x.x.xxx..",
+        ".....xxxxxxx....", ".....xx...xx....", "......xxxxx.....", "....xxxxxxxxx...",
+        "...xx.xxxxx.xx..", "..xx..xxxxx..xx.", ".xx...xxxxx...xx", "......xxxxx.....",
+        ".....xx...xx....", "....xx.....xx...", "...xx.......xx..", "..xx.........xx.",
+        ".xx...........xx", "................", "................", "................",
+        "................",
+    },
+    {   // walker 1
+        "................", ".....xxxxxx.....", "...xxxxxxxxxx...", "..xxxxxxxxxxxx..",
+        ".xxx..xxxx..xxx.", ".xxx..xxxx..xxx.", ".xxxxxxxxxxxxxx.", ".xxxxxxxxxxxxxx.",
+        ".xxxx......xxxx.", "..xxxxxxxxxxxx..", "...xxxxxxxxxx...", "....xxxxxxxx....",
+        "....xx....xx....", "...xxx....xxx...", "...xxx....xxx...", "..xxxx....xxxx..",
+    },
+    {   // walker 2
+        "................", ".....xxxxxx.....", "...xxxxxxxxxx...", "..xxxxxxxxxxxx..",
+        ".xxx..xxxx..xxx.", ".xxx..xxxx..xxx.", ".xxxxxxxxxxxxxx.", ".xxxxxxxxxxxxxx.",
+        ".xxxx......xxxx.", "..xxxxxxxxxxxx..", "...xxxxxxxxxx...", "....xxxxxxxx....",
+        ".....xx..xx.....", "....xxx..xxx....", "....xxx..xxx....", "...xxxx..xxxx...",
+    },
+    {   // squashed
+        "................", "................", "................", "................",
+        "................", "................", "................", "................",
+        "................", "................", "................", "................",
+        "..xxxxxxxxxxxx..", ".xxx..xxxx..xxx.", ".xxxxxxxxxxxxxx.", "..xxxx....xxxx..",
+    },
+    {   // hopper, sitting
+        "................", "................", "................", "................",
+        "...xxx....xxx...", "..xx.xx..xx.xx..", "..xxxxxxxxxxxx..", ".xxxxxxxxxxxxxx.",
+        ".xxxxxxxxxxxxxx.", ".xx.xxxxxxxx.xx.", ".xxx........xxx.", "..xxxxxxxxxxxx..",
+        "...xxxxxxxxxx...", "..xxx......xxx..", ".xxxx......xxxx.", ".xxx........xxx.",
+    },
+    {   // hopper, in the air
+        "...xxx....xxx...", "..xx.xx..xx.xx..", "..xxxxxxxxxxxx..", "..xxxxxxxxxxxx..",
+        "..xxxxxxxxxxxx..", "..xx.xxxxxx.xx..", "..xxx......xxx..", "...xxxxxxxxxx...",
+        "....xxxxxxxx....", "....xx....xx....", "....xx....xx....", "...xx......xx...",
+        "...xx......xx...", "..xx........xx..", "..xx........xx..", ".xxx........xxx.",
+    },
+};
+
+// Hit boxes (game.h). The falling frame has two: the body, and the feet
+// in the stomp group. The hurt and squashed frames have none.
+#define PB G_PLAYER, G_ENEMY
+#define EB G_ENEMY, G_PLAYER | G_STOMP
+struct HBox hbox[16] = {
+    { 5, 1, 11, 20, PB }, { 4, 1, 12, 20, PB }, { 4, 1, 12, 20, PB }, { 4, 0, 12, 18, PB },  // 0-3
+    { 4, 0, 12, 13, PB }, { 4, 14, 12, 20, G_STOMP, G_ENEMY },                             // 4-5 fall
+    { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 },                                              // 6-11 mirrored below
+    { 2, 1, 13, 15, EB }, { 2, 1, 13, 15, EB },                                            // 12-13 walker
+    { 2, 4, 13, 15, EB }, { 3, 0, 12, 15, EB },                                            // 14-15 hopper
+};
+const char hb_first[SH_COUNT] = { 0, 1, 2, 3, 4, 6, 7, 8, 9, 10, 0, 12, 13, 0, 14, 15 };
+const char hb_count[SH_COUNT] = { 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 0, 1, 1, 0, 1, 1 };
+
+static char mc_pixel(char c)
+{
+    return c == 'b' ? 1 : c == 'y' ? 2 : c == 'g' ? 3 : 0;
+}
+
+// A slope glyph from the height table: grass on the surface row, earth
+// below. A double-width pixel takes the higher of its two columns.
+static void slope_glyph(char *g, char type)
+{
+    const char *h = heights + type * 8;
+    for (char r = 0; r < 8; r++)
+    {
+        char b = 0;
+        for (char k = 0; k < 4; k++)
+        {
+            char s = h[2 * k] < h[2 * k + 1] ? h[2 * k] : h[2 * k + 1];
+            char v = r < s ? 0 : r == s ? 3 : 1;
+            b |= v << (6 - 2 * k);
+        }
+        g[r] = b;
+    }
+}
+
+void art_build(void)
+{
+    // The ROM's upper-case glyphs 0-63, for text and the meter. Bank 3 has
+    // no ROM font (c64-kb vic_bank_visibility_collision), so copy it.
+    memset(CHARSET, 0, 2048);
+    *(volatile char *)1 = 0x33;                 // character ROM in at $D000
+    for (unsigned i = 0; i < 512; i++)
+        CHARSET[i] = ((char *)0xd000)[i];
+    *(volatile char *)1 = 0x35;                 // I/O back; BASIC and KERNAL stay out
+
+    for (char i = 0; i < sizeof(glyph_code); i++)
+    {
+        char *g = CHARSET + glyph_code[i] * 8;
+        for (char r = 0; r < 8; r++)
+        {
+            const char *row = glyph_art[i][r];
+            g[r] = (mc_pixel(row[0]) << 6) | (mc_pixel(row[1]) << 4) | (mc_pixel(row[2]) << 2) | mc_pixel(row[3]);
+        }
+    }
+    for (char t = 1; t <= 6; t++)
+        slope_glyph(CHARSET + (CH_SLOPE1 - 1 + t) * 8, t);
+
+    // Sprite shapes; the player's four also mirrored into shapes 4-7.
+    memset(SPRMEM, 0, 1024);
+    for (char i = 0; i < sizeof(art_shape); i++)
+    {
+        char s = art_shape[i];
+        char *d = SPRMEM + s * 64;
+        char *m = SPRMEM + (s + SH_MIRROR) * 64;
+        for (char r = 0; r < 21; r++)
+        {
+            const char *row = sprite_art[i][r];
+            unsigned bits = 0, mirror = 0;
+            for (char c = 0; c < 16 && row[c]; c++)
+            {
+                if (row[c] == 'x')
+                {
+                    bits |= 0x8000u >> c;
+                    mirror |= 1u << c;
+                }
+            }
+            d[r * 3] = bits >> 8;
+            d[r * 3 + 1] = bits & 0xff;
+            if (s < SH_MIRROR)
+            {
+                m[r * 3] = mirror >> 8;
+                m[r * 3 + 1] = mirror & 0xff;
+            }
+        }
+    }
+    for (char i = 0; i < 6; i++)            // the player's six boxes, mirrored
+    {
+        struct HBox *b = hbox + i, *m = hbox + i + 6;
+        m->x0 = 15 - b->x1;
+        m->x1 = 15 - b->x0;
+        m->y0 = b->y0;
+        m->y1 = b->y1;
+        m->group = b->group;
+        m->mask = b->mask;
+    }
+}

package/templates/platformer/src/autopilot.h

@@ -0,0 +1,30 @@
+// autopilot.h: the scripted joystick for AUTOPILOT builds (c64-kb
+// headless-verify's synthetic port byte). { frames, port byte }, active
+// low as $DC00 reads it. Every frame from power-on reads the next byte.
+#define AP_IDLE  0xff
+#define AP_FIRE  (0xff ^ JOY_FIRE)
+#define AP_RIGHT (0xff ^ JOY_RIGHT)
+#define AP_LEFT  (0xff ^ JOY_LEFT)
+#define AP_RJUMP (0xff ^ JOY_RIGHT ^ JOY_FIRE)
+
+static const char script[][2] = {
+    { 20, AP_IDLE },                // the title
+    {  1, AP_FIRE },                // fire: a new game
+    {  4, AP_IDLE },
+    {100, AP_RIGHT },               // over the coins and the hill
+    { 31, AP_IDLE },                // the walker comes closer
+    {  1, AP_FIRE },                // a jump straight up: down onto it
+    { 88, AP_IDLE },                // the stomp, the bounce
+    { 59, AP_RIGHT },               // to the pit's edge
+    {  1, AP_RJUMP },               // over it
+    {116, AP_RIGHT },               // the 1-in-2 hill, under the ledge
+    {  1, AP_RJUMP },               // up onto the ledge: two coins
+    {150, AP_RIGHT },               // off its end, into the hopper: a life lost
+    { 44, AP_IDLE },                // the respawn, back on the hill; the camera scrolls back
+    { 86, AP_RIGHT },
+    {  1, AP_RJUMP },               // over the hopper
+    { 60, AP_RIGHT },
+    {  1, AP_RJUMP },               // over the second pit
+    { 60, AP_RIGHT },               // into the brick wall: it stops the player at x 716
+};
+#define SCRIPT_STEPS (sizeof(script) / sizeof(script[0]))

package/templates/platformer/src/engine.asm

@@ -0,0 +1,253 @@
+// engine.asm: the KickAssembler half of the platformer. The harness
+// assembles it to build/asm.bin (raw bytes from $0900) and build/asm.h,
+// which gives C an ASM_<LABEL> for every top-level label below.
+//
+//   slice_copy                the coarse scroll: five rows of one page into
+//                             another, one column over (see "Coarse shift")
+//   irq_split, irq_blank      the HUD split at line 212, the playfield back at 251
+//   nmi_rti                   RESTORE lands here: the KERNAL is banked out
+//   music_init, music_play    an original two-voice tune (see "Tune")
+//
+// Calling convention: C calls these with `jsr` from __asm blocks. They use
+// A, X and Y and no zero page, so they cannot collide with Oscar64's
+// registers ($02-$52). The tune keeps its state in this blob.
+
+.const HUD_D016 = $08           // 40 columns, hires, XSCROLL 0
+.const HUD_D018 = $28           // screen $C800, characters $E000
+
+* = $0900 "asm"
+
+// ---- Coarse shift, a slice at a time ------------------------------------------
+// C prepares the page for the next column crossing in four slices of five
+// rows, one slice a frame, while the camera travels the 8 pixels to that
+// crossing; the crossing itself is then only a $D018 flip. The page on
+// display is only ever read. slice_copy copies 39 bytes of each of five
+// rows: dst[k * 40 + x] = src[k * 40 + x], x 38..0, k 0..4. C passes the
+// first cell of each: src one column right of dst to move the picture
+// left, one column left to move it right.
+//
+// Cost by arithmetic: the patch, about 170 cycles; each x, 5 x (lda abs,x
+// 4 or 5 + sta abs,x 5) + dex/bpl 5, about 52; 39 of them, about 2,000.
+
+.const SLICE = 5                        // rows a call
+
+slice_src: .word 0
+slice_dst: .word 0
+
+slice_copy:
+    .for (var k = 0; k < SLICE; k++) {
+        clc
+        lda slice_src
+        adc #<(k * 40)
+        sta rows[k].rd + 1
+        lda slice_src + 1
+        adc #>(k * 40)
+        sta rows[k].rd + 2
+        clc
+        lda slice_dst
+        adc #<(k * 40)
+        sta rows[k].wr + 1
+        lda slice_dst + 1
+        adc #>(k * 40)
+        sta rows[k].wr + 2
+    }
+        ldx #38
+!loop:
+rows: .for (var k = 0; k < SLICE; k++) {
+rd:     lda $ffff, x                    // patched above
+wr:     sta $ffff, x
+    }
+        dex
+        bpl !loop-
+        rts
+
+// ---- Split ----------------------------------------------------------------
+// Two raster IRQs a frame. At line 212, inside character row 20 (blank on
+// every playfield page), the HUD rows below get 40 columns, hires, XSCROLL
+// 0 and their own screen page (c64-kb xscroll_applies_to_all_rows). At
+// line 251, below the last display line, the playfield's $D016 and $D018
+// come back from pf_d016 and pf_d018, which C publishes as a pair once a
+// frame's work is done. Because the IRQ, not the main loop, puts them back,
+// a frame whose work overruns shows the previous picture again, never the
+// HUD page. Whole values are written, never a read-modify-write of $D016
+// (d016_unmasked_rmw_clobbers_csel_mcm). blank_ticks counts the blanks:
+// the main loop starts a frame when it changes (polling $D012 for 251
+// would miss the line the IRQ spends), and a count that moves during a
+// frame's work marks the frame late.
+irq_split:
+        pha
+        lda #HUD_D016
+        sta $d016
+        lda #HUD_D018
+        sta $d018
+        lda #<irq_blank
+        sta $fffe
+        lda #>irq_blank
+        sta $ffff
+        lda #251
+        sta $d012
+        lda #$01
+        sta $d019               // acknowledge the raster interrupt
+        pla
+nmi_rti:
+        rti
+
+irq_blank:
+        pha
+        lda pf_d016
+        sta $d016
+        lda pf_d018
+        sta $d018
+        lda #<irq_split
+        sta $fffe
+        lda #>irq_split
+        sta $ffff
+        lda #212
+        sta $d012
+        lda #$01
+        sta $d019
+        inc blank_ticks         // the main loop's frame start
+        pla
+        rti
+
+blank_ticks: .byte 0
+pf_d016:     .byte $17          // multicolour, 38 columns, XSCROLL 7
+pf_d018:     .byte $08          // page 0, characters $E000
+
+// ---- Tune -------------------------------------------------------------------
+// The init + play convention of c64-kb sid_play_routine_pattern: music_init
+// once, music_play once a frame. Voices 1 and 2 only; voice 3 belongs to the
+// sound effects in C (sfx_engine_beside_music). Each voice steps through a
+// sequence of patterns; a pattern is MIDI note numbers, 0 a rest, $FF its
+// end. A note lasts STEP frames and its gate drops one frame before the next
+// step, so repeated notes are heard apart.
+.const STEP = 7
+
+// SID frequency words for MIDI notes 0-107 on a PAL clock (985,248 Hz):
+// f * 2^24 / 985248 (arithmetic). NTSC plays them about 4% sharp.
+.function sidfreq(n) { .return round(440 * pow(2, (n - 69) / 12) * 16777216 / 985248) }
+freq_lo: .fill 108, <sidfreq(i)
+freq_hi: .fill 108, >sidfreq(i)
+
+// One voice's player. sid = the voice's first SID register, wave = its
+// waveform bits (gate off).
+.macro VoiceTick(sid, wave, cnt, seq, seqdata, pos) {
+        dec cnt
+        beq !step+
+        lda cnt
+        cmp #1
+        bne !done+
+        lda #wave               // the last frame of a step: gate off
+        sta sid + 4
+        jmp !done+
+!step:
+        lda #STEP
+        sta cnt
+!fetch:
+        ldy pos
+note:   lda $ffff, y            // the pattern's address is patched in
+        cmp #$ff
+        bne !play+
+        ldx seq                 // end of the pattern: the next one
+        inx
+        lda seqdata, x
+        cmp #$ff
+        bne !+
+        ldx #0                  // end of the sequence: from the top
+        lda seqdata
+!:      stx seq
+        tax
+        lda pat_lo, x
+        sta note + 1
+        lda pat_hi, x
+        sta note + 2
+        lda #0
+        sta pos
+        jmp !fetch-
+!play:
+        inc pos
+        cmp #0
+        beq !done+              // a rest: the gate is already off
+        tax
+        lda freq_lo, x
+        sta sid
+        lda freq_hi, x
+        sta sid + 1
+        lda #wave               // restart the envelope
+        sta sid + 4
+        lda #wave | 1
+        sta sid + 4
+!done:
+}
+
+// Point a voice at the first pattern of its sequence.
+.macro VoiceStart(cnt, seq, seqdata, pos, note) {
+        lda #1
+        sta cnt                 // the first play call steps at once
+        lda #0
+        sta seq
+        sta pos
+        ldx seqdata
+        lda pat_lo, x
+        sta note + 1
+        lda pat_hi, x
+        sta note + 2
+}
+
+music_init:
+        ldx #$18
+        lda #0
+!:      sta $d400, x            // SID registers are write-only: set every one
+        dex
+        bpl !-
+        lda #$0f
+        sta $d418               // volume 15, no filter
+        lda #$00
+        sta $d402
+        lda #$04
+        sta $d403               // voice 1 pulse width $400: a hollow bass
+        lda #$28
+        sta $d405               // voice 1 attack 2, decay 8
+        lda #$44
+        sta $d406               // voice 1 sustain 4, release 4
+        lda #$00
+        sta $d409
+        lda #$08
+        sta $d40a               // voice 2 pulse width $800: a square lead
+        lda #$0a
+        sta $d40c               // voice 2 attack 0, decay 10
+        lda #$63
+        sta $d40d               // voice 2 sustain 6, release 3
+        VoiceStart(cnt1, seq1, seq1_data, pos1, voice1.note)
+        VoiceStart(cnt2, seq2, seq2_data, pos2, voice2.note)
+        rts
+
+// voice1.note and voice2.note are the patched loads inside each tick.
+music_play:
+voice1: VoiceTick($d400, $40, cnt1, seq1, seq1_data, pos1)
+voice2: VoiceTick($d407, $40, cnt2, seq2, seq2_data, pos2)
+        rts
+
+cnt1: .byte 0
+seq1: .byte 0
+pos1: .byte 0
+cnt2: .byte 0
+seq2: .byte 0
+pos2: .byte 0
+
+// The tune: C major, eight patterns a pass, about 16 seconds a loop on PAL.
+// Lead (voice 2) over a bass (voice 1): C F C G C F G C.
+seq1_data: .byte 4, 5, 4, 6, 4, 5, 6, 7, $ff
+seq2_data: .byte 0, 1, 0, 2, 0, 1, 2, 3, $ff
+
+pat_lo: .byte <lead_a, <lead_b, <lead_c, <lead_d, <bass_c, <bass_f, <bass_g, <bass_end
+pat_hi: .byte >lead_a, >lead_b, >lead_c, >lead_d, >bass_c, >bass_f, >bass_g, >bass_end
+
+lead_a:   .byte 76, 0, 79, 0, 84, 0, 79, 0, 81, 0, 79, 76, 0, 74, 0, 0, $ff
+lead_b:   .byte 77, 0, 81, 0, 84, 0, 81, 0, 79, 0, 76, 0, 72, 0, 0, 0, $ff
+lead_c:   .byte 76, 76, 74, 72, 74, 0, 67, 0, 72, 74, 76, 77, 76, 0, 74, 0, $ff
+lead_d:   .byte 72, 0, 67, 0, 64, 0, 67, 0, 72, 0, 0, 0, 0, 0, 0, 0, $ff
+bass_c:   .byte 48, 0, 55, 0, 48, 0, 55, 0, 48, 0, 55, 0, 48, 0, 55, 0, $ff
+bass_f:   .byte 41, 0, 48, 0, 41, 0, 48, 0, 41, 0, 48, 0, 41, 0, 48, 0, $ff
+bass_g:   .byte 43, 0, 50, 0, 43, 0, 50, 0, 43, 0, 50, 0, 43, 0, 50, 0, $ff
+bass_end: .byte 48, 0, 43, 0, 48, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0, $ff