romdevtools 0.13.0

package/src/platforms/c64/lib/c/c64_music.c

@@ -0,0 +1,248 @@
+/* c64_music.c — per-frame 3-voice SID music driver.
+ *
+ *  Architecture
+ *  ────────────
+ *  Three voices, each walks an independent (freq, length_frames) table:
+ *
+ *    voice0 = melody   (pulse,  high register)
+ *    voice1 = bass     (pulse,  low  register, longer notes)
+ *    voice2 = harmony  (pulse,  mid  register)
+ *
+ *  On each music_update() (called once per VBlank ≈ 50 Hz PAL / 60 Hz NTSC):
+ *    - decrement the current note's frames-remaining counter for each voice
+ *    - when it hits 0, advance to the next note: write FREQ_LO/HI, retrigger
+ *      GATE (off-on transition keys the envelope) and start the new counter
+ *    - if a voice reaches end-of-table it wraps to 0 → continuous loop
+ *
+ *  ADSR shape (same for all 3 voices for simplicity):
+ *    attack=0  decay=4  sustain=8 release=4
+ *  → punchy front, ~half-volume sustain, short tail. Notes don't bleed
+ *    into each other but sound musical.
+ *
+ *  Frequency values are the standard PAL SID 16-bit dividers from any
+ *  C64 programmer reference. Hz ≈ freq * 0.0596.
+ *
+ *  The song
+ *  ────────
+ *  16-bar loop, 4/4, ~125 BPM. Each "step" is 12 frames = ~0.2s @ 50 Hz.
+ *  Melody plays mostly quarter-steps, bass holds half-steps, harmony
+ *  rides between. C major / A minor flavor — chord progression:
+ *    Am  F   C   G   (the classic four-chord loop)
+ *  repeated 4× per loop with melody variations.
+ *
+ *  A rest is encoded as freq=0 (driver gates off without retriggering).
+ */
+
+#include "c64_music.h"
+#include "c64_registers.h"
+
+#define POKE(addr, val)  (*(volatile uint8_t*)(addr) = (val))
+
+/* ── SID 16-bit frequency dividers for PAL (985248 Hz clock) ────── */
+/* Standard table — match any C64 programmer's guide. Hz ≈ f * 0.0596. */
+#define N_REST  0x0000u
+
+#define N_C3    0x1199u
+#define N_D3    0x13EEu
+#define N_E3    0x1666u
+#define N_F3    0x1798u
+#define N_G3    0x1AE6u
+#define N_A3    0x1E78u
+#define N_B3    0x2253u
+
+#define N_C4    0x2333u
+#define N_D4    0x27DDu
+#define N_E4    0x2CCCu
+#define N_F4    0x2F30u
+#define N_G4    0x35CCu
+#define N_A4    0x3CF1u
+#define N_B4    0x44A7u
+
+#define N_C5    0x4666u
+#define N_D5    0x4FBAu
+#define N_E5    0x5998u
+#define N_F5    0x5E60u
+#define N_G5    0x6B99u
+#define N_A5    0x79E1u
+#define N_B5    0x894Eu
+
+/* Step length: number of frames a "unit" note occupies. */
+#define STEP  10
+
+typedef struct {
+  uint16_t freq;
+  uint8_t  len;   /* frames */
+} Note;
+
+/* ── Voice 0: melody (lead). High register, ~quarter-note pacing. ─
+ * Chord progression spelled out as Am F C G repeated. Each chord
+ * gets 4 melody notes (one bar). 16 bars × 4 notes = 64 notes. */
+static const Note melody[] = {
+  /* Am bar */
+  { N_A4, STEP*2 }, { N_C5, STEP }, { N_E5, STEP }, { N_C5, STEP*2 }, { N_A4, STEP*2 },
+  /* F  bar */
+  { N_F4, STEP*2 }, { N_A4, STEP }, { N_C5, STEP }, { N_A4, STEP*2 }, { N_F4, STEP*2 },
+  /* C  bar */
+  { N_C5, STEP*2 }, { N_E5, STEP }, { N_G5, STEP }, { N_E5, STEP*2 }, { N_C5, STEP*2 },
+  /* G  bar */
+  { N_G4, STEP*2 }, { N_B4, STEP }, { N_D5, STEP }, { N_B4, STEP*2 }, { N_G4, STEP*2 },
+
+  /* — verse 2: same chords, ornamented — */
+  { N_A4, STEP   }, { N_C5, STEP }, { N_E5, STEP*2 }, { N_D5, STEP }, { N_C5, STEP }, { N_E5, STEP*2 },
+  { N_F4, STEP   }, { N_A4, STEP }, { N_C5, STEP*2 }, { N_B4, STEP }, { N_A4, STEP }, { N_C5, STEP*2 },
+  { N_C5, STEP   }, { N_E5, STEP }, { N_G5, STEP*2 }, { N_F5, STEP }, { N_E5, STEP }, { N_G5, STEP*2 },
+  { N_G4, STEP   }, { N_B4, STEP }, { N_D5, STEP*2 }, { N_C5, STEP }, { N_B4, STEP }, { N_D5, STEP*2 },
+
+  /* — verse 3: rising arpeggios — */
+  { N_A3, STEP }, { N_C4, STEP }, { N_E4, STEP }, { N_A4, STEP }, { N_C5, STEP }, { N_E5, STEP }, { N_A5, STEP*2 },
+  { N_F3, STEP }, { N_A3, STEP }, { N_C4, STEP }, { N_F4, STEP }, { N_A4, STEP }, { N_C5, STEP }, { N_F5, STEP*2 },
+  { N_C4, STEP }, { N_E4, STEP }, { N_G4, STEP }, { N_C5, STEP }, { N_E5, STEP }, { N_G5, STEP }, { N_C5, STEP*2 },
+  { N_G3, STEP }, { N_B3, STEP }, { N_D4, STEP }, { N_G4, STEP }, { N_B4, STEP }, { N_D5, STEP }, { N_G5, STEP*2 },
+
+  /* — verse 4: cooldown, longer notes — */
+  { N_A4, STEP*4 }, { N_E5, STEP*4 },
+  { N_F4, STEP*4 }, { N_C5, STEP*4 },
+  { N_C5, STEP*4 }, { N_G5, STEP*4 },
+  { N_G4, STEP*4 }, { N_D5, STEP*4 },
+
+  /* end-mark not needed; we wrap. */
+};
+
+/* ── Voice 1: bass. Low register, half-note pacing. ───────────── */
+static const Note bass[] = {
+  /* Am F C G — one note per bar, sustained */
+  { N_A3, STEP*8 }, { N_F3, STEP*8 }, { N_C3, STEP*8 }, { N_G3, STEP*8 },
+  /* repeat for verse 2 */
+  { N_A3, STEP*8 }, { N_F3, STEP*8 }, { N_C3, STEP*8 }, { N_G3, STEP*8 },
+  /* verse 3 — walking bass */
+  { N_A3, STEP*4 }, { N_E3, STEP*4 },
+  { N_F3, STEP*4 }, { N_C3, STEP*4 },
+  { N_C3, STEP*4 }, { N_G3, STEP*4 },
+  { N_G3, STEP*4 }, { N_D3, STEP*4 },
+  /* verse 4 — pedal */
+  { N_A3, STEP*8 }, { N_F3, STEP*8 }, { N_C3, STEP*8 }, { N_G3, STEP*8 },
+};
+
+/* ── Voice 2: harmony. Mid register, offset rhythm. ─────────── */
+static const Note harmony[] = {
+  /* Am chord tones */
+  { N_C4, STEP*2 }, { N_E4, STEP*2 }, { N_A4, STEP*2 }, { N_E4, STEP*2 },
+  /* F  chord tones */
+  { N_A3, STEP*2 }, { N_C4, STEP*2 }, { N_F4, STEP*2 }, { N_C4, STEP*2 },
+  /* C  chord tones */
+  { N_E4, STEP*2 }, { N_G4, STEP*2 }, { N_C5, STEP*2 }, { N_G4, STEP*2 },
+  /* G  chord tones */
+  { N_D4, STEP*2 }, { N_G4, STEP*2 }, { N_B4, STEP*2 }, { N_G4, STEP*2 },
+
+  /* verse 2 — same with rest accents */
+  { N_C4, STEP }, { N_E4, STEP }, { N_REST, STEP }, { N_A4, STEP*2 }, { N_E4, STEP*2 }, { N_C4, STEP },
+  { N_A3, STEP }, { N_C4, STEP }, { N_REST, STEP }, { N_F4, STEP*2 }, { N_C4, STEP*2 }, { N_A3, STEP },
+  { N_E4, STEP }, { N_G4, STEP }, { N_REST, STEP }, { N_C5, STEP*2 }, { N_G4, STEP*2 }, { N_E4, STEP },
+  { N_D4, STEP }, { N_G4, STEP }, { N_REST, STEP }, { N_B4, STEP*2 }, { N_G4, STEP*2 }, { N_D4, STEP },
+
+  /* verse 3 — long pads */
+  { N_E4, STEP*8 }, { N_F4, STEP*8 }, { N_G4, STEP*8 }, { N_B4, STEP*8 },
+
+  /* verse 4 — drop out partly */
+  { N_REST, STEP*8 }, { N_C4, STEP*8 }, { N_REST, STEP*8 }, { N_D4, STEP*8 },
+};
+
+#define ARR_LEN(a) (sizeof(a) / sizeof((a)[0]))
+
+/* Per-voice state. */
+static uint16_t v_pos[3];      /* index into the voice's note table */
+static uint8_t  v_remaining[3];/* frames left on current note */
+static uint8_t  m_tick;
+
+static uint16_t voice_len(uint8_t v) {
+  switch (v) {
+    case 0: return (uint16_t)ARR_LEN(melody);
+    case 1: return (uint16_t)ARR_LEN(bass);
+    default: return (uint16_t)ARR_LEN(harmony);
+  }
+}
+static const Note *voice_note(uint8_t v, uint16_t i) {
+  switch (v) {
+    case 0: return &melody[i];
+    case 1: return &bass[i];
+    default: return &harmony[i];
+  }
+}
+
+/* Set up the pulse-wave shape on a voice: PW = 50% duty, ADSR shape. */
+static void setup_voice(uint8_t v) {
+  POKE(SID_PW_LO(v), 0x00);
+  POKE(SID_PW_HI(v), 0x08);   /* PW = $0800 = 50% */
+  POKE(SID_AD(v), 0x04);      /* attack=0, decay=4 */
+  POKE(SID_SR(v), 0x84);      /* sustain=8, release=4 */
+  POKE(SID_CTRL(v), 0);       /* gate off until first note */
+}
+
+/* Trigger a note: write freq, gate off→on retrigger so envelope keys. */
+static void trigger(uint8_t v, uint16_t freq) {
+  if (freq == N_REST) {
+    /* Rest: gate off, no retrigger. Release tail plays. */
+    POKE(SID_CTRL(v), SID_PULSE);
+    return;
+  }
+  POKE(SID_FREQ_LO(v), (uint8_t)(freq & 0xFF));
+  POKE(SID_FREQ_HI(v), (uint8_t)(freq >> 8));
+  /* Off then on for clean envelope retrigger. */
+  POKE(SID_CTRL(v), SID_PULSE);
+  POKE(SID_CTRL(v), SID_PULSE | SID_GATE);
+}
+
+void music_init(void) {
+  uint8_t v;
+  POKE(SID_VOL_MODE, 0x0F);   /* master vol = 15, no filter */
+  for (v = 0; v < 3; v++) {
+    setup_voice(v);
+    v_pos[v] = 0;
+    v_remaining[v] = 0;
+  }
+  m_tick = 0;
+}
+
+void music_play(void) {
+  uint8_t v;
+  const Note *n;
+  for (v = 0; v < 3; v++) {
+    v_pos[v] = 0;
+    n = voice_note(v, 0);
+    v_remaining[v] = n->len;
+    trigger(v, n->freq);
+  }
+}
+
+void music_update(void) {
+  uint8_t v;
+  const Note *n;
+  m_tick++;
+  for (v = 0; v < 3; v++) {
+    if (v_remaining[v] > 0) {
+      v_remaining[v]--;
+    }
+    if (v_remaining[v] == 0) {
+      /* Advance, with wrap. */
+      v_pos[v]++;
+      if (v_pos[v] >= voice_len(v)) v_pos[v] = 0;
+      n = voice_note(v, v_pos[v]);
+      v_remaining[v] = n->len;
+      trigger(v, n->freq);
+    }
+  }
+}
+
+void music_stop(void) {
+  uint8_t v;
+  for (v = 0; v < 3; v++) {
+    POKE(SID_CTRL(v), 0);
+    v_remaining[v] = 0;
+    v_pos[v] = 0;
+  }
+  POKE(SID_VOL_MODE, 0);
+}
+
+uint8_t music_tick(void) {
+  return m_tick;
+}

package/src/platforms/c64/lib/c/c64_music.h

@@ -0,0 +1,36 @@
+/* c64_music.h — tiny per-frame SID music driver for C64 scaffolds.
+ *
+ * 3-voice continuous music player on top of the SID. The note table IS
+ * the song — open this file's .c sibling to see and edit the tune.
+ *
+ * NOT a .sid player (those need reSID-class emulation of a 6502 sub-
+ * program). This is a plain frame-tick sequencer: each voice walks a
+ * parallel array of (freq, length_frames) pairs and writes SID registers
+ * on note transitions. Lightweight, source-visible, perfect for a
+ * scaffold "music_demo".
+ *
+ * Wire it up:
+ *   music_init()       — set master vol + ADSR for all 3 voices
+ *   music_play()       — reset song position to 0 (begin playback)
+ *   music_update()     — call once per frame from your main loop
+ *   music_stop()       — clear gates + silence
+ *
+ * The track loops indefinitely; each voice can have its own length so
+ * polyphony stays interesting.
+ */
+
+#ifndef C64_MUSIC_H
+#define C64_MUSIC_H
+
+#include <stdint.h>
+
+void music_init(void);
+void music_play(void);
+void music_update(void);
+void music_stop(void);
+
+/* Returns 0..255 — a frame counter useful for sync (e.g. flash colors
+ * on the beat). Wraps freely. */
+uint8_t music_tick(void);
+
+#endif

package/src/platforms/c64/lib/c/c64_sfx.c

@@ -0,0 +1,94 @@
+/* c64_sfx.c — SID driver for C64 scaffolds.
+ *
+ * Three voices, each with:
+ *   FREQ_LO/HI   16-bit frequency divider
+ *   PW_LO/HI     12-bit pulse width (only relevant for pulse waveform)
+ *   CTRL         bit 0  = GATE (1 = note on, 0 = release)
+ *                bit 4  = triangle wave
+ *                bit 5  = sawtooth
+ *                bit 6  = pulse
+ *                bit 7  = noise
+ *   AD           attack (high nibble) / decay (low nibble), 0..15 each
+ *   SR           sustain (high) / release (low), 0..15 each
+ *
+ * SID_VOL_MODE ($D418):
+ *   bits 0..3  master volume 0..15 (15 = full)
+ *   (filter bits in 4..7 — not used here)
+ *
+ * Per-voice "frames-left" counter drives auto-key-off.
+ */
+
+#include "c64_sfx.h"
+#include "c64_registers.h"
+
+#define POKE(addr, val)  (*(volatile uint8_t*)(addr) = (val))
+
+static uint8_t sfx_remaining[3];
+static uint8_t sfx_ctrl[3];   /* the current waveform+gate bits so we can clear GATE on key-off */
+
+void sfx_init(void) {
+  uint8_t i;
+  /* Master volume = full, no filter. */
+  POKE(SID_VOL_MODE, 0x0F);
+  /* Clear all voice control registers. */
+  for (i = 0; i < 3; i++) {
+    POKE(SID_CTRL(i), 0);
+    POKE(SID_AD(i), 0);
+    POKE(SID_SR(i), 0);
+    sfx_remaining[i] = 0;
+    sfx_ctrl[i] = 0;
+  }
+}
+
+void sfx_tone(uint8_t channel, uint8_t freq_lo, uint8_t freq_hi, uint8_t length_frames) {
+  uint8_t ctrl;
+  if (channel > 2) return;
+  POKE(SID_FREQ_LO(channel), freq_lo);
+  POKE(SID_FREQ_HI(channel), freq_hi);
+  /* Pulse waveform at 50% duty (PW = 0x800). */
+  POKE(SID_PW_LO(channel), 0x00);
+  POKE(SID_PW_HI(channel), 0x08);
+  /* Attack 0, decay 9 — punchy then fades. */
+  POKE(SID_AD(channel), 0x09);
+  /* Sustain 8/15, release 5/15 — note holds then fades. */
+  POKE(SID_SR(channel), 0x85);
+  /* Pulse waveform + GATE on. */
+  ctrl = SID_PULSE | SID_GATE;
+  POKE(SID_CTRL(channel), ctrl);
+  sfx_ctrl[channel] = ctrl;
+  sfx_remaining[channel] = length_frames;
+}
+
+void sfx_noise(uint8_t length_frames) {
+  /* Use voice 2 for noise so voice 0/1 can hold tones underneath. */
+  POKE(SID_FREQ_LO(2), 0x00);
+  POKE(SID_FREQ_HI(2), 0x40);
+  POKE(SID_AD(2), 0x09);
+  POKE(SID_SR(2), 0x84);
+  POKE(SID_CTRL(2), SID_NOISE | SID_GATE);
+  sfx_ctrl[2] = SID_NOISE | SID_GATE;
+  sfx_remaining[2] = length_frames;
+}
+
+void sfx_update(void) {
+  uint8_t i;
+  for (i = 0; i < 3; i++) {
+    if (sfx_remaining[i] > 0) {
+      sfx_remaining[i]--;
+      if (sfx_remaining[i] == 0) {
+        /* Clear GATE — release phase of the ADSR envelope plays. */
+        POKE(SID_CTRL(i), sfx_ctrl[i] & ~SID_GATE);
+      }
+    }
+  }
+}
+
+void sfx_off(void) {
+  uint8_t i;
+  for (i = 0; i < 3; i++) {
+    POKE(SID_CTRL(i), 0);
+    sfx_remaining[i] = 0;
+    sfx_ctrl[i] = 0;
+  }
+  POKE(SID_VOL_MODE, 0);
+}

package/src/platforms/c64/lib/c/c64_sfx.h

@@ -0,0 +1,37 @@
+/* c64_sfx.h — minimal C64 SID sound-effects wrapper.
+ *
+ * SID = Sound Interface Device. The legendary C64 audio chip, 3 voices,
+ * 4 waveforms (triangle/sawtooth/pulse/noise), per-voice ADSR
+ * envelope, and a programmable filter. Sounds amazing when used well;
+ * this scaffold wrapper uses the basics.
+ *
+ * Same 5-function cross-platform shape:
+ *   sfx_init()
+ *   sfx_tone(channel, freq_lo, freq_hi, length_frames)   — pulse wave
+ *   sfx_noise(length_frames)                              — voice 2 noise
+ *   sfx_update()                                          — call once per frame
+ *   sfx_off()
+ *
+ * channel = 0, 1, or 2 (SID has 3 voices).
+ *
+ * Frequency is a 16-bit divider:
+ *   Hz = (freq * 0.0596) for PAL, or (freq * 0.0596) for NTSC.
+ *   Useful values: 0x1000 ≈ middle range, 0x2000 ≈ higher, 0x0800 ≈ low.
+ *
+ * The SID has REAL ADSR — sfx_tone sets a sensible default (fast attack,
+ * mid release) so the note has shape. sfx_update keys-off (clears GATE)
+ * when the countdown hits 0, letting the release tail play.
+ */
+
+#ifndef C64_SFX_H
+#define C64_SFX_H
+
+#include <stdint.h>
+
+void sfx_init(void);
+void sfx_tone(uint8_t channel, uint8_t freq_lo, uint8_t freq_hi, uint8_t length_frames);
+void sfx_noise(uint8_t length_frames);
+void sfx_update(void);
+void sfx_off(void);
+
+#endif

package/src/platforms/c64/lib/c64_registers.h

@@ -0,0 +1,108 @@
+/* ── C64 hardware register names ───────────────────────────────────
+ * Standard cc65 / ca65 symbolic names for VIC-II + SID + CIA1/2 +
+ * 6510 I/O ports. Works in both C (`(*(volatile uint8_t*)VIC_BORDER)`)
+ * and ca65 asm (`lda #$00 / sta VIC_BORDER`).
+ *
+ * Address constants follow cc65 cbm.h conventions where possible.
+ */
+#ifndef C64_REGISTERS_H
+#define C64_REGISTERS_H
+
+/* ── 6510 internal I/O ports ($00-$01) ──────────────────────────── */
+#define CPU_PORT_DIR    0x0000  /* data direction */
+#define CPU_PORT        0x0001  /* LORAM/HIRAM/CHAREN/cassette */
+#define CPU_PORT_LORAM  0x01    /* 1 = BASIC ROM visible */
+#define CPU_PORT_HIRAM  0x02    /* 1 = KERNAL ROM visible */
+#define CPU_PORT_CHAREN 0x04    /* 0 = char ROM at $D000, 1 = I/O */
+
+/* ── VIC-II ($D000-$D02E) ───────────────────────────────────────── */
+#define VIC_BASE        0xD000
+#define VIC_SPRITE_X(N) (0xD000 + (N) * 2)
+#define VIC_SPRITE_Y(N) (0xD001 + (N) * 2)
+#define VIC_SPRITES_X8  0xD010   /* sprite X high bits */
+#define VIC_CTRL1       0xD011   /* Y-scroll, 24/25 rows, on, mode bits */
+#define VIC_RASTER      0xD012
+#define VIC_LPEN_X      0xD013
+#define VIC_LPEN_Y      0xD014
+#define VIC_SPR_ENA     0xD015
+#define VIC_CTRL2       0xD016   /* X-scroll, 38/40 cols, multicolor */
+#define VIC_SPR_Y_EXP   0xD017
+#define VIC_MEMORY      0xD018   /* screen base + char base */
+#define VIC_IRQ         0xD019
+#define VIC_IRQ_ENA     0xD01A
+#define VIC_SPR_BG_PRI  0xD01B
+#define VIC_SPR_MCOLOR  0xD01C
+#define VIC_SPR_X_EXP   0xD01D
+#define VIC_SPR_SPR_COL 0xD01E
+#define VIC_SPR_BG_COL  0xD01F
+#define VIC_BORDER      0xD020
+#define VIC_BG0         0xD021
+#define VIC_BG1         0xD022
+#define VIC_BG2         0xD023
+#define VIC_BG3         0xD024
+#define VIC_SPR_MC0     0xD025
+#define VIC_SPR_MC1     0xD026
+#define VIC_SPR_COL(N)  (0xD027 + (N))
+
+/* ── SID ($D400-$D41C) ──────────────────────────────────────────── */
+#define SID_BASE         0xD400
+#define SID_VOICE(N)     (0xD400 + (N) * 7)
+#define SID_FREQ_LO(N)   (0xD400 + (N) * 7 + 0)
+#define SID_FREQ_HI(N)   (0xD400 + (N) * 7 + 1)
+#define SID_PW_LO(N)     (0xD400 + (N) * 7 + 2)
+#define SID_PW_HI(N)     (0xD400 + (N) * 7 + 3)
+#define SID_CTRL(N)      (0xD400 + (N) * 7 + 4)
+#define SID_AD(N)        (0xD400 + (N) * 7 + 5)
+#define SID_SR(N)        (0xD400 + (N) * 7 + 6)
+#define SID_FILTER_LO    0xD415
+#define SID_FILTER_HI    0xD416
+#define SID_RES_FILT     0xD417
+#define SID_VOL_MODE     0xD418
+
+/* SID waveform control bits */
+#define SID_GATE         0x01
+#define SID_SYNC         0x02
+#define SID_RING         0x04
+#define SID_TEST         0x08
+#define SID_TRIANGLE     0x10
+#define SID_SAWTOOTH     0x20
+#define SID_PULSE        0x40
+#define SID_NOISE        0x80
+
+/* ── CIA1 ($DC00-$DC0F) — keyboard / joystick / timers ──────────── */
+#define CIA1_PRA         0xDC00  /* port A (keyboard col / joystick 2) */
+#define CIA1_PRB         0xDC01  /* port B (keyboard row / joystick 1) */
+#define CIA1_DDRA        0xDC02
+#define CIA1_DDRB        0xDC03
+
+/* ── CIA2 ($DD00-$DD0F) — VIC bank select + serial bus ──────────── */
+#define CIA2_PRA         0xDD00  /* bits 0-1 = VIC bank (inverted) */
+#define CIA2_PRB         0xDD01
+#define CIA2_DDRA        0xDD02
+#define CIA2_DDRB        0xDD03
+
+/* ── Color RAM ──────────────────────────────────────────────────── */
+#define COLOR_RAM        0xD800  /* 1 KB, low nibble only */
+
+/* ── Default screen / char locations (VIC bank 0) ───────────────── */
+#define SCREEN_RAM       0x0400  /* 40×25 = 1000 bytes */
+
+/* ── Standard color codes (matches BASIC's PEEK/POKE values) ────── */
+#define COLOR_BLACK      0
+#define COLOR_WHITE      1
+#define COLOR_RED        2
+#define COLOR_CYAN       3
+#define COLOR_PURPLE     4
+#define COLOR_GREEN      5
+#define COLOR_BLUE       6
+#define COLOR_YELLOW     7
+#define COLOR_ORANGE     8
+#define COLOR_BROWN      9
+#define COLOR_LIGHT_RED  10
+#define COLOR_DARK_GRAY  11
+#define COLOR_MED_GRAY   12
+#define COLOR_LIGHT_GREEN 13
+#define COLOR_LIGHT_BLUE 14
+#define COLOR_LIGHT_GRAY 15
+
+#endif /* C64_REGISTERS_H */

package/src/platforms/c64/lib/cc65-src/_scrsize.s

@@ -0,0 +1,12 @@
+;
+; Ullrich von Bassewitz, 26.10.2000
+;
+; Screen size variables
+;
+
+        .export         screensize
+        .import         SCREEN
+
+screensize      = SCREEN
+
+

package/src/platforms/c64/lib/cc65-src/acc_c128_speed.s

@@ -0,0 +1,5 @@
+;
+; Marco van den Heuvel, 2018-04-23
+;
+
+.include "../c128/acc_c128_speed.s"

package/src/platforms/c64/lib/cc65-src/acc_c64dtv_speed.s

@@ -0,0 +1,64 @@
+;
+; Marco van den Heuvel, 2018-04-14
+;
+
+; unsigned char __fastcall__ set_c64dtv_speed (unsigned char speed);
+;
+;/* Set the speed of the C64DTV, using SPEED_SLOW will switch to
+; * slow mode, SPEED_2X or SPEED_FAST will switch to fast mode.
+; *
+; * Note that any value higher or equal to SPEED_2X will switch to fast mode.
+; *
+; * This function will return the actual speed the CPU is at after trying
+; * to set the requested speed, to my knowledge the switching should not fail.
+; *
+; * This function does not check for the presence of the C64DTV,
+; * make sure you use 'detect_c64dtv();' before using.
+; */
+
+; unsigned char get_c64dtv_speed (void);
+;
+;/* Get the speed of the C64DTV.
+; *
+; * Possible return values:
+; * SPEED_1X    : slow mode
+; * SPEED_2X    : fast mode
+; *
+; * This function does not check for the presence of the C64DTV,
+; * make sure you use 'detect_c64dtv();' before using.
+; */
+
+        .export         _set_c64dtv_speed
+        .export         _get_c64dtv_speed
+
+        .include        "accelerator.inc"
+
+_set_c64dtv_speed:
+        cmp     #SPEED_2X
+        bcs     high_speed
+low_speed:
+        ldx     #C64DTV_Slow
+set_speed:
+        .byte   $32,$99               ; SAC #$99   set accumulator to reg 9 (cpu control)
+        txa                           ; (re)set skip and burst bits
+        .byte   $32,$00               ; SAC #$00   set accumulator back to reg 0
+        jmp     _get_c64dtv_speed
+
+high_speed:
+        ldx     #C64DTV_Fast
+        bne     set_speed
+
+
+_get_c64dtv_speed:
+        .byte   $32,$99               ; SAC #$99   set accumulator to reg 9 (cpu control)
+        tax
+        .byte   $32,$00               ; SAC #$00   set accumulator back to reg 0
+        txa
+        and     #C64DTV_Fast
+        bne     in_fast_mode
+        lda     #$00
+        .byte   $2C
+in_fast_mode:
+        lda     #$01
+        ldx     #$00
+        rts

package/src/platforms/c64/lib/cc65-src/acc_c65_speed.s

@@ -0,0 +1,69 @@
+;
+; Marco van den Heuvel, 2018-04-27
+;
+
+; unsigned char __fastcall__ set_c65_speed (unsigned char speed);
+;
+;/* Set the speed of the C65 CPU, using SPEED_SLOW will switch to
+; * 1 Mhz mode, SPEED_3X or SPEED_FAST will switch to 3.5 Mhz (fast) mode.
+; *
+; * Note that any value higher or equal to SPEED_3X will switch to fast mode.
+; *
+; * This function will return the actual speed the CPU is at after trying
+; * to set the requested speed, to my knowledge the switching should not fail.
+; *
+; * This function does not check for the presence of a C65/C64DX in C64 mode,
+; * make sure you use 'detect_c65();' before using.
+; */
+
+; unsigned char get_c65_speed (void);
+;
+;/* Get the speed of the C65 CPU.
+; *
+; * Possible return values:
+; * SPEED_SLOW  : 1 Mhz mode
+; * SPEED_3X    : 3.5 Mhz mode
+; *
+; * This function does not check for the presence of a C65/C64DX in C64 mode,
+; * make sure you use 'detect_c65();' before using.
+; */
+
+        .export         _set_c65_speed
+        .export         _get_c65_speed
+
+        .include        "accelerator.inc"
+
+_set_c65_speed:
+        tay
+        jsr     activate_new_vic_mode
+        cpy     #SPEED_3X
+        bcs     high_speed
+low_speed:
+        and     #$BF
+store_speed:
+        sta     C65_VICIII_CTRL_B
+        lda     C65_VICIII_CTRL_B
+        jmp     return_c65_speed
+
+high_speed:
+        ora     #$40
+        bne     store_speed
+
+_get_c65_speed:
+        jsr     activate_new_vic_mode
+return_c65_speed:
+        sta     C65_VICIII_KEY
+        and     #$40
+        beq     speed_is_slow              ; when this branch is taken then register A is already set to SPEED_SLOW
+        lda     #SPEED_3X
+speed_is_slow:
+        ldx     #$00
+        rts
+
+activate_new_vic_mode:
+        lda     #C65_VICIII_UNLOCK_1
+        sta     C65_VICIII_KEY
+        lda     #C65_VICIII_UNLOCK_2
+        sta     C65_VICIII_KEY
+        lda     C65_VICIII_CTRL_B
+        rts