@moonbase-machines/c64 0.0.0-stage → 0.5.1

package/basic.js

@@ -0,0 +1,275 @@
+// What Commodore BASIC does for a program, for a remake whose BASIC (or Blitz!'s code) is
+// compiled to JavaScript (basic-compile.js): its variables and arrays, its numbers printed as it
+// prints them, its strings as their bytes, its FOR and GOSUB on one stack, its DATA, and its
+// statements' calls into the KERNAL, made as the original makes them, through the engine, so
+// that they are the same events.
+//
+//   const b = new Basic(engine, { data, quiet })
+//     data    where the program's DATA is in memory (Blitz!'s: each item its length and its text,
+//             $FF at the end)
+//     quiet   BASIC's own interpreter, in the ROM, ran the program: its calls into the KERNAL are
+//             the ROM's, and no events (GOLDFIELDS, the boot)
+//
+// Numbers are JavaScript's; a whole-number variable (%) floors what is stored, as BASIC does, and
+// BASIC's errors stop the remake with BASIC's own words. The rules for numbers (FOUT, VAL, RND,
+// the errors) are BASIC's, kept once for every layer in numbers.js.
+
+import { fail, int16, fout, val, scanNumber, seedRandom, nextRandom, BasicError } from './numbers.js';
+
+export class Basic {
+  constructor(e, { data = 0, quiet = false } = {}) {
+    this.e = e; this.data = this.dataStart = data; this.quiet = quiet;
+    this.v = Object.create(null); this.arrays = Object.create(null); this.stack = [];
+    this.channel = 0;
+  }
+  // where the operation is that may fail next, as Blitz!'s program counter has it then: BASIC's
+  // error gives it as its line (the engine's `error`)
+  here(at) { this.at = at; }
+  // a variable's value, 0 or "" until it is set
+  get(n) { return this.v[n] ?? (n.endsWith('$') ? '' : 0); }
+  set(n, x) {
+    if (n.endsWith('$')) { if (typeof x !== 'string') fail('TYPE MISMATCH'); if (x.length > 255) fail('STRING TOO LONG'); this.v[n] = x; return; }
+    if (typeof x !== 'number') fail('TYPE MISMATCH');
+    this.v[n] = n.endsWith('%') ? int16(x) : x;
+  }
+  clr() { this.v = Object.create(null); this.arrays = Object.create(null); this.stack = []; this.fns = null; }
+  // RUN: every file closed (the KERNAL's CLALL), the variables cleared and DATA from its start,
+  // the program run again to its DIMs and on from `back`
+  run(back) { const m = this.e.mem; m[0x98] = 0; m[0x99] = 0; m[0x9a] = 3; this.clr(); this.data = this.dataStart; this.datum = 0; this.resume = back; }
+
+  // arrays: DIM's sizes are the last index of each dimension
+  dim(n, sizes) { if (this.arrays[n]) fail('REDIM\'D ARRAY'); const dims = sizes.map(s => int16(s) + 1), size = dims.reduce((a, b) => a * b, 1); this.arrays[n] = { dims, data: new Array(size).fill(n.endsWith('$') ? '' : 0) }; }
+  place(n, i) {
+    const a = this.arrays[n] ?? (this.dim(n, i.map(() => 10)), this.arrays[n]);
+    if (i.length !== a.dims.length) fail('BAD SUBSCRIPT');
+    let k = 0; for (let d = 0; d < i.length; d++) { const x = int16(i[d]); if (x < 0 || x >= a.dims[d]) fail('BAD SUBSCRIPT'); k = k * a.dims[d] + x; }
+    return [a, k];
+  }
+  elem(n, i) { const [a, k] = this.place(n, i); return a.data[k]; }
+  setElem(n, i, x) {
+    const [a, k] = this.place(n, i);
+    if (n.endsWith('$') !== (typeof x === 'string')) fail('TYPE MISMATCH');
+    a.data[k] = n.endsWith('%') ? int16(x) : x;
+  }
+
+  // operators: comparisons give -1 or 0, AND, OR and NOT work on whole numbers of 16 bits
+  add(a, b) { if (typeof a !== typeof b) fail('TYPE MISMATCH'); if (typeof a === 'string' && a.length + b.length > 255) fail('STRING TOO LONG'); return a + b; }
+  num(a) { if (typeof a !== 'number') fail('TYPE MISMATCH'); return a; }
+  cmp(a, b, o) {
+    if (typeof a !== typeof b) fail('TYPE MISMATCH');
+    const c = a < b ? -1 : a > b ? 1 : 0;
+    return ({ '=': c === 0, '<>': c !== 0, '<': c < 0, '>': c > 0, '<=': c <= 0, '>=': c >= 0 })[o] ? -1 : 0;
+  }
+  and(a, b) { return int16(this.num(a)) & int16(this.num(b)); }
+  or(a, b) { return int16(this.num(a)) | int16(this.num(b)); }
+  not(a) { return ~int16(this.num(a)); }
+  div(a, b) { if (this.num(b) === 0) fail('DIVISION BY ZERO'); return this.num(a) / b; }
+
+  pow(a, b) { a = this.num(a); b = this.num(b); if (a < 0 && b !== Math.floor(b)) fail('ILLEGAL QUANTITY'); return a ** b; }
+
+  // functions
+  int(x) { return Math.floor(this.num(x)); }
+  abs(x) { return Math.abs(this.num(x)); }
+  sqr(x) { if (this.num(x) < 0) fail('ILLEGAL QUANTITY'); return Math.sqrt(x); }
+  log(x) { if (this.num(x) <= 0) fail('ILLEGAL QUANTITY'); return Math.log(x); }
+  exp(x) { return Math.exp(this.num(x)); }
+  sin(x) { return Math.sin(this.num(x)); }
+  cos(x) { return Math.cos(this.num(x)); }
+  tan(x) { return Math.tan(this.num(x)); }
+  atn(x) { return Math.atan(this.num(x)); }
+  len(s) { if (typeof s !== 'string') fail('TYPE MISMATCH'); return s.length; }
+  val(s) { if (typeof s !== 'string') fail('TYPE MISMATCH'); return val(s); }
+  rnd() { return this.random(); }
+  fre() { return 0; }
+  usr() { fail('UNDEF\'D FUNCTION'); }
+  sgn(x) { return Math.sign(this.num(x)); }
+  chr(x) { const n = int16(x); if (n < 0 || n > 255) fail('ILLEGAL QUANTITY'); return String.fromCharCode(n); }
+  asc(s) { if (!s.length) fail('ILLEGAL QUANTITY'); return s.charCodeAt(0); }
+  str(x) { return fout(this.num(x)); }
+  left(s, n) { n = int16(n); if (n < 0 || n > 255) fail('ILLEGAL QUANTITY'); return s.slice(0, n); }
+  right(s, n) { n = int16(n); if (n < 0 || n > 255) fail('ILLEGAL QUANTITY'); return n ? s.slice(-n) : ''; }
+  mid(s, from, n = 255) { from = int16(from); n = int16(n); if (from < 1 || from > 255 || n < 0 || n > 255) fail('ILLEGAL QUANTITY'); return s.substr(from - 1, n); }
+  peek(a) { a = Math.floor(this.num(a)); if (a < 0 || a > 0xffff) fail('ILLEGAL QUANTITY'); return this.e.read(a); }
+  // RND: the seed's numbers, the same on the original (basic-rom.js's RND draws them too)
+  // (kept on the engine, one run of them for the boot and the game, as the ROM's is one)
+  random() { const e = this.e; e.randomState = nextRandom(e.randomState ?? seedRandom(e.title.seed ?? 0x11)); return e.randomState / 2 ** 32; }
+  // TI, the clock at $A0 to $A2; TI$ as its hours, minutes and seconds
+  // (a program's read of the clock takes the interrupts first, as a poll of GETIN does, so that a
+  // wait it counts out moves on, the same on the original)
+  // (but only every so many reads, the title's `reads`, and not after a poll of GETIN has taken
+  // them since the last read)
+  ti() {
+    const e = this.e, m = e.mem;
+    if (!e.clock && !this.quiet) {
+      if (e.polledSince) { e.polledSince = false; e.reads = 0; }
+      else if ((e.reads = (e.reads ?? 0) + 1) >= (e.routines.reads ?? 1)) { e.reads = 0; e.routines.poll(e); }
+    }
+    return m[0xa0] * 65536 + m[0xa1] * 256 + m[0xa2];
+  }
+  tis() { const t = Math.floor(this.ti() / 60); return [Math.floor(t / 3600) % 24, Math.floor(t / 60) % 60, t % 60].map(n => String(n).padStart(2, '0')).join(''); }
+  // TI$ set: through the KERNAL's SETTIM, as the original sets it (A the clock's low byte, Y its high)
+  setTis(s) { if (!/^\d{6}$/.test(s)) fail('ILLEGAL QUANTITY'); const t = ((+s.slice(0, 2) * 60 + +s.slice(2, 4)) * 60 + +s.slice(4)) * 60, e = this.e; e.a = t & 0xff; e.x = t >> 8 & 0xff; e.y = t >> 16 & 0xff; this.call('settim'); }
+  st() { return this.e.mem[0x90]; }
+  poke(a, v) { a = Math.floor(this.num(a)); v = Math.floor(this.num(v)); if (a < 0 || a > 0xffff || v < 0 || v > 255) fail('ILLEGAL QUANTITY'); this.e.write(a, v); }
+
+  // the time a statement took on the original, in its cycles, for the page's clock
+  cost(n) { const e = this.e; e.cycles += n; e.delay += n / 1022.727; }
+  // SYS, and the statements that go through the KERNAL's files: the engine's
+  sys(at, text, step) { return this.e.routines.sys(this.e, Math.floor(this.num(at)), text, step); }
+  undef() { fail('UNDEF\'D STATEMENT'); }
+  // READ from DATA in BASIC's own text (`items`, basic-lang.js `dataItems`): the next item, a
+  // string as it is, a number as FIN reads it, anything else in it a SYNTAX ERROR IN the DATA's
+  // line, as BASIC gives it; RESTORE, from the first again
+  readText(string) {
+    const item = this.items[this.datum ?? 0];
+    if (!item) fail('OUT OF DATA');
+    this.datum = (this.datum ?? 0) + 1;
+    if (string) return item.text;
+    const t = item.text.replace(/ /g, '');
+    if (item.quoted || !/^[+-]?(\d+\.?\d*|\.\d*)?(E[+-]?\d*)?$/.test(t)) { const err = new BasicError('?SYNTAX ERROR'); err.basicLine = item.line; throw err; }
+    return val(t);
+  }
+  restore() { this.datum = 0; this.data = this.dataStart; }
+  // DEF FN and FN: a function of one variable, which while it is worked out holds the argument,
+  // and then its own value again, as BASIC's FN does; one not defined, UNDEF'D FUNCTION; DEF only
+  // in a program, not typed at once (ILLEGAL DIRECT)
+  def(n, p, f) { if (this.e.mem[0x3a] === 0xff) fail('ILLEGAL DIRECT'); (this.fns ??= Object.create(null))[n] = { p, f }; }
+  fn(n, x) {
+    const d = this.fns?.[n];
+    if (!d) fail('UNDEF\'D FUNCTION');
+    const was = this.v[d.p], arg = this.num(x);
+    this.set(d.p, arg);
+    try { return d.f(this); } finally { if (was === undefined) delete this.v[d.p]; else this.v[d.p] = was; }
+  }
+  failWith(what) { fail(what); }
+  statement(k, args, into, step) {
+    const f = this.e.routines['basic-' + k];
+    if (!f) throw new Error(k.toUpperCase() + ' is not handled');
+    return f(this.e, args, into, step);
+  }
+  pos() { return this.e.mem[0xd3] % 40; }
+
+  // FOR and GOSUB on one stack, as BASIC keeps them: a FOR of a variable already looping drops
+  // that loop and what is above it; NEXT drops the loops above its own; RETURN, everything above
+  // its GOSUB
+  for(n, to, step, next) {
+    const k = this.stack.findLastIndex(f => f.for === n);
+    if (k >= 0) this.stack.length = k;
+    this.stack.push({ for: n, to: this.num(to), step: this.num(step), next });
+  }
+  next(n) {
+    const k = n ? this.stack.findLastIndex(f => f.for === n) : this.stack.findLastIndex(f => f.for !== undefined);
+    if (k < 0 || (n === null && this.stack.slice(k + 1).some(f => f.gosub !== undefined))) fail('NEXT WITHOUT FOR');
+    this.stack.length = k + 1;
+    const f = this.stack[k], x = this.get(f.for) + f.step;
+    this.set(f.for, x);
+    if (f.step >= 0 ? x <= f.to : x >= f.to) return f.next;
+    this.stack.length = k;
+    return null;
+  }
+  gosub(back) { this.stack.push({ gosub: back }); }
+  ret() { const k = this.stack.findLastIndex(f => f.gosub !== undefined); if (k < 0) fail('RETURN WITHOUT GOSUB'); const back = this.stack[k].gosub; this.stack.length = k; return back; }
+  on(x) { const k = Math.floor(this.num(x)); if (k < 0 || k > 255) fail('ILLEGAL QUANTITY'); return k; }
+
+  // READ, from DATA as Blitz! keeps it
+  read(string) {
+    if (this.items) return this.readText(string);
+    const m = this.e.mem, n = m[this.data];
+    if (n & 0x80) fail('OUT OF DATA');
+    const s = String.fromCharCode(...m.subarray(this.data + 1, this.data + 1 + n));
+    this.data += 1 + n;
+    return string ? s : val(s);
+  }
+
+  // the KERNAL's calls, through the engine: CHROUT a byte at a time, GETIN
+  out(ch) { const e = this.e; e.a = ch; this.call('chrout'); }
+  call(name) { const e = this.e; if (this.quiet) e.inside++; try { e.routines[name](e, [], null); } finally { if (this.quiet) e.inside--; } }
+  // PRINT: a number written as FOUT writes it, then a step right on the screen or a space to a
+  // file; a string as it is
+  print(x) {
+    if (typeof x === 'number') { for (const c of fout(x)) this.out(c.charCodeAt(0)); this.out(this.e.mem[0x13] ? 0x20 : 0x1d); }
+    else for (let k = 0; k < x.length; k++) this.out(x.charCodeAt(k));
+  }
+  // a new line: a carriage return, and a line feed after it to a file numbered from 128
+  newline() { this.out(0x0d); if (this.e.mem[0x13] & 0x80) this.out(0x0a); }
+
+  // files, through the KERNAL: OPEN's parameters (the file, the device, 1 if not given, the
+  // secondary address, 0, or 255 below device 3, and the name) as BASIC sets them, then OPEN;
+  // CLOSE; PRINT# and INPUT#, the output's or the input's file, which $13 notes for PRINT
+  open([la, fa = 1, sa, name = '']) {
+    const m = this.e.mem;
+    m[0xb8] = int16(la) & 0xff; m[0xba] = int16(fa) & 0xff; m[0xb9] = sa === undefined ? (m[0xba] < 3 ? 0xff : 0) : int16(sa) & 0xff;
+    // (a name through SETNAM, as Blitz!'s OPEN gives it, from a place of the remake's own)
+    for (let k = 0; k < name.length; k++) m[0x200 + k] = name.charCodeAt(k);
+    if (name.length) { Object.assign(this.e, { a: name.length, x: 0x00, y: 0x02 }); this.call('setnam'); }
+    else m[0xb7] = 0;
+    this.call('open');
+    if (this.e.c) fail(['', 'TOO MANY FILES', 'FILE OPEN', 'FILE NOT OPEN'][this.e.a] ?? 'DEVICE NOT PRESENT');
+  }
+  close(la) { this.e.a = int16(la) & 0xff; this.call('close'); }
+  output(n) { this.e.mem[0x13] = int16(n) & 0xff; this.e.x = this.e.mem[0x13]; this.call('chkout'); }
+  input(n) { this.e.mem[0x13] = int16(n) & 0xff; this.e.x = this.e.mem[0x13]; this.call('chkin'); this.line = null; }
+  clrchn() { this.call('clrchn'); this.e.mem[0x13] = 0; }
+  // WAIT: whether the place's bits, flipped by `xor`, meet the mask yet, as the ROM's loop reads
+  // them ($B840); a key pressed on the page goes into the KERNAL's buffer meanwhile, as the
+  // keyboard puts it there
+  wait(at, mask, xor = 0) {
+    const e = this.e, m = e.mem;
+    if (!m[0xc6] && e.keys.length) { const k = e.keys.shift(); if (k >= 0) { m[0x277] = k; m[0xc6] = 1; } }
+    return ((this.peek(at) ^ int16(xor)) & int16(mask)) !== 0;
+  }
+  // INPUT from a file (Microsoft's GETAGN and INLOOP): a line read with CHRIN to its carriage
+  // return, the first an INPUT# reads read again while it is empty, a later one empty its items
+  // empty; a read timed out (ST bit 1), the INPUT given up, its variables as they were
+  // (`given up`); then its items, each to a comma: a string quoted to its quote, or to a comma
+  // or a colon; a number as FIN reads it, a comma, a colon or the line's end after it, or
+  // ?FILE DATA ERROR
+  readLine(first) {
+    for (;;) {
+      let s = '';
+      for (;;) { this.call('chrin'); if (this.e.a === 0x0d) break; s += String.fromCharCode(this.e.a); if (s.length > 88) fail('STRING TOO LONG'); }
+      if (this.e.mem[0x90] & 2) { this.givenUp = true; return ''; }
+      if (s.length || !first) return s;
+    }
+  }
+  item(string, first) {
+    if (first) this.givenUp = false;
+    if (first || this.line === null || this.linePos >= this.line.length) { this.line = this.readLine(first); this.linePos = 0; }
+    if (this.givenUp) return undefined;
+    const s = this.line; let k = this.linePos;
+    while (s[k] === ' ') k++;
+    let v;
+    if (string && s[k] === '"') { const end = s.indexOf('"', k + 1); v = s.slice(k + 1, end < 0 ? s.length : end); k = end < 0 ? s.length : end + 1; while (s[k] === ' ') k++; }
+    else if (string) { let end = k; while (end < s.length && s[end] !== ',' && s[end] !== ':') end++; v = s.slice(k, end); k = end; }
+    else { const n = scanNumber(s, k); v = n.text; k = n.end; }
+    if (k < s.length && s[k] !== ',' && s[k] !== ':') fail('FILE DATA');
+    if (s[k] === ',') k++;
+    this.linePos = k;
+    return string ? v : val(v);
+  }
+  // the end of an INPUT: from a file, the input back to the keyboard (Blitz!'s $1AAA)
+  inputDone() {
+    if (this.e.mem[0x13]) { this.call('clrchn'); this.e.mem[0x13] = 0; return; }
+    throw new Error('INPUT from the keyboard is not handled');
+  }
+  // GET#'s character: GETIN from the file CHKIN chose, "" for none
+  getFrom() { this.call('getin'); return this.e.a ? String.fromCharCode(this.e.a) : ''; }
+  // `,`: on to the next column of ten
+  comma() { const c = this.e.mem[0xd3] % 40; let n = 10 - c % 10; while (n--) this.out(this.e.mem[0x13] ? 0x20 : 0x1d); }
+  spc(n) { n = int16(n); if (n < 0 || n > 255) fail('ILLEGAL QUANTITY'); while (n-- > 0) this.out(this.e.mem[0x13] ? 0x20 : 0x1d); }
+  tab(n) { n = int16(n); if (n < 0 || n > 255) fail('ILLEGAL QUANTITY'); let k = n - this.e.mem[0xd3] % 40; while (k-- > 0) this.out(0x1d); }
+  // GET: the key from GETIN, or "" with none; Blitz!'s calls CLRCHN after each, as its handler
+  // does ($16CD), and BASIC's, in the ROM, does not
+  // (the run stops for a key as GETIN returns, as the original does, its CLRCHN still to come:
+  // null, and the step runs again for the rest)
+  key() {
+    if (this.got === undefined) {
+      this.e.mem[0x13] = 0; this.call('getin'); this.got = this.e.a;
+      if (this.e.polled && !this.quiet) return null;
+    }
+    const k = this.got; this.got = undefined;
+    if (!this.quiet) this.call('clrchn');
+    return k ? String.fromCharCode(k) : '';
+  }
+}
+

package/browser.js

@@ -0,0 +1,116 @@
+// A Commodore 64 (machine.js) in a browser page: the keys as the C64's matrix, the arrows as the
+// joystick and the cursor keys, Escape as RUN/STOP, Control the Commodore key (and fire), Tab
+// CTRL; a gamepad (an 8BitDo, or any in the browser's standard mapping) as the joystick too; the
+// frame painted on a canvas doubled; and the machine run 50 frames a second, keeping up with the
+// clock, two frames at most at a time.
+//
+//   const keys = keyboard(m, { ignore, onKey, log })   ignore(e): a key the page keeps (a pane's)
+//   keys.press(column, row, frames)                    a key held for so many frames (RUN/STOP)
+//   const draw = painter(canvas)                       draw(m.vic.frame)
+//   pace(m, after)                                     the frames run; after() each animation frame
+import { MATRIX, SHIFTED, JOYSTICK, CURSOR, MODIFIERS } from './keys.js';
+import { PALETTE, WIDTH, HEIGHT } from './vic.js';
+
+const PAD_DEAD = 0.4;   // a stick pushed less far than this is at rest (the dead zone)
+
+export function keyboard(m, { ignore = () => false, onKey = () => {}, log = false } = {}) {
+  // (a letter by the key it is, not the character the browser makes of it: in the C64's first
+  // character set, capitals and graphics, a letter is a letter, Shift or Caps Lock or not, and
+  // Option with it is its graphic, the C64's shifted letter; in the second, small letters and
+  // capitals, Shift is a capital, as on the C64)
+  const upper = () => !((m.vic?.r[0x18] ?? 0x15) & 2);
+  // (a key let go within two frames of going down is held to the end of them: the KERNAL scans
+  // the keyboard once a frame, and a tap shorter than that, which a real key never is, would
+  // never be seen)
+  const down = new Map(), held = [], pressed = new Map(), withCbm = new Set();
+  let frame = 0;
+  const release = (key, shift) => {
+    const since = frame - (pressed.get(key) ?? -9);
+    if (since >= 2) { m.key(key[0], key[1], false); if (shift) m.key(1, 7, false); return; }
+    held.push([key[0], key[1], 2 - since]); if (shift) held.push([1, 7, 2 - since]);
+  };
+  window.addEventListener('keydown', e => {
+    if (ignore(e)) return;
+    onKey(e);
+    if (e.metaKey || e.repeat) return;
+    if (MODIFIERS[e.key]) { m.key(...MODIFIERS[e.key], true); e.preventDefault(); }
+    if (JOYSTICK[e.key]) { m.joystick |= JOYSTICK[e.key]; const cur = CURSOR[e.key]; if (cur) { if (cur[2]) m.key(1, 7, true); m.key(cur[0], cur[1], true); } e.preventDefault(); return; }
+    const letter = /^Key([A-Z])$/.exec(e.code)?.[1]?.toLowerCase();
+    const shifted = letter ? null : SHIFTED[e.key], key = letter ? MATRIX[letter] : shifted ? MATRIX[shifted] : MATRIX[e.key] || MATRIX[e.key.toLowerCase()];
+    if (!key) { if (MODIFIERS[e.key]) e.preventDefault(); return; }
+    // (the left shift: a letter's graphic, a shifted sign, and shift with a function key, F2, F4, F6
+    // and F8 being shift with F1, F3, F5 and F7 on the 64)
+    if (letter ? (upper() ? e.altKey : e.shiftKey) : shifted || (e.key.length === 1 && e.key !== e.key.toLowerCase() && !/[0-9]/.test(e.key)) || (e.shiftKey && /^F[1357]$/.test(e.key))) m.key(1, 7, true);
+    // (Control held, as the event says, the Commodore key down with the key, if Control's own
+    // keydown has not put it there, and let go with it)
+    const [cc, cr] = MODIFIERS.Control, cbm = e.ctrlKey && !(m.keys[cc] & 1 << cr) ? MODIFIERS.Control : null;
+    if (cbm) { m.key(...cbm, true); pressed.set(cbm, frame); }
+    m.key(key[0], key[1], true); down.set(e.code, key); pressed.set(key, frame); if (cbm) withCbm.add(e.code);
+    if (log) console.log('key', JSON.stringify(e.key), '-> column', key[0], 'row', key[1]);
+    e.preventDefault();
+  });
+  window.addEventListener('keyup', e => {
+    if (MODIFIERS[e.key]) m.key(...MODIFIERS[e.key], false);
+    if (JOYSTICK[e.key]) { m.joystick &= ~JOYSTICK[e.key]; const cur = CURSOR[e.key]; if (cur) { m.key(cur[0], cur[1], false); if (cur[2]) m.key(1, 7, false); } return; }
+    const key = down.get(e.code);
+    if (key) { release(key, true); if (withCbm.delete(e.code)) release(MODIFIERS.Control, false); down.delete(e.code); } else m.key(1, 7, false);
+  });
+  // the page left (another window, another tab, Cmd-Tab): the browser sends no keyup for what was
+  // held, so everything is let go, the keys, the joystick and fire, or a key (CTRL by Tab, Shift's
+  // fire) would stay down and every key after it be read wrongly
+  const letGo = () => { m.keys.fill(0); m.joystick = 0; down.clear(); held.length = 0; pressed.clear(); withCbm.clear(); padBits = 0; padStop = false; };
+  // a gamepad, read each frame in the browser's standard mapping: the D-pad or the left stick
+  // (pushed past PAD_DEAD) the joystick in port 2, A or B its fire, Start RUN/STOP; added to what
+  // the keys hold, and let go with the pad
+  let padBits = 0, padStop = false;
+  const readPads = () => {
+    if (typeof navigator === 'undefined' || typeof navigator.getGamepads !== 'function') return;
+    let bits = 0, stop = false;
+    for (const p of navigator.getGamepads()) {
+      if (!p || !p.connected) continue;
+      const b = i => !!p.buttons[i]?.pressed, x = p.axes[0] ?? 0, y = p.axes[1] ?? 0;
+      if (b(12) || y < -PAD_DEAD) bits |= 1;
+      if (b(13) || y > PAD_DEAD) bits |= 2;
+      if (b(14) || x < -PAD_DEAD) bits |= 4;
+      if (b(15) || x > PAD_DEAD) bits |= 8;
+      if (b(0) || b(1)) bits |= 16;
+      if (b(9)) stop = true;
+    }
+    m.joystick = (m.joystick & ~padBits) | bits; padBits = bits;
+    if (stop !== padStop) { m.key(7, 7, stop); padStop = stop; }
+  };
+  window.addEventListener('blur', letGo);
+  document.addEventListener('visibilitychange', () => { if (document.hidden) letGo(); });
+  return {
+    // a key held for so many frames, then let go (frame() lets them go)
+    press(column, row, frames = 3) { m.key(column, row, true); held.push([column, row, frames]); },
+    frame() { frame++; readPads(); for (let i = held.length - 1; i >= 0; i--) if (--held[i][2] <= 0) { m.key(held[i][0], held[i][1], false); held.splice(i, 1); } },
+  };
+}
+
+export function painter(canvas) {
+  const ctx = canvas.getContext('2d');
+  canvas.width = WIDTH * 2; canvas.height = HEIGHT * 2;
+  const rgba = new Uint8ClampedArray(WIDTH * 2 * HEIGHT * 2 * 4), image = new ImageData(rgba, WIDTH * 2, HEIGHT * 2);
+  return f => {
+    for (let y = 0; y < HEIGHT; y++) for (let x = 0; x < WIDTH; x++) {
+      const [r, g, b] = PALETTE[f[y * WIDTH + x]];
+      for (let dy = 0; dy < 2; dy++) { let o = (((y * 2 + dy) * WIDTH * 2) + x * 2) * 4; for (let dx = 0; dx < 2; dx++) { rgba[o++] = r; rgba[o++] = g; rgba[o++] = b; rgba[o++] = 255; } }
+    }
+    ctx.putImageData(image, 0, 0);
+  };
+}
+
+// the C64's 50 frames a second, kept up with the clock (two at most at a time, so a tab left in
+// the background does not run on and on when it comes back); each(frame) after each one run
+export function pace(m, after, each = () => {}) {
+  let frames = 0;
+  const started = performance.now();
+  function tick() {
+    const due = Math.min(2, Math.floor((performance.now() - started) / 20) - frames);
+    for (let i = 0; i < due; i++) { m.runFrame(); frames++; each(frames); }
+    after(frames);
+    requestAnimationFrame(tick);
+  }
+  tick();
+}

package/d64.js

@@ -0,0 +1,191 @@
+// Writing a Commodore 1541 disk image, a .d64, as the 1541 itself would leave it, so that it loads
+// on Moonbase's C64, in VICE and on a real 64 (by an SD2IEC or the like). 35 tracks of 256-byte
+// sectors, 21 a track on the outer tracks and fewer further in, 174,848 bytes. Track 18 holds the
+// BAM and the disk's name in sector 0 and the directory from sector 1; each file is a chain of
+// sectors, each starting with the track and sector of the next, or 0 and the index of its last
+// byte. Files are laid down from track 17 outward and from 19 inward, as the 1541 does, ten
+// sectors apart on a track, the directory three apart.
+//
+//   make({ name: 'CRAYON', id: 'MB', files: [{ name: 'CRAYON', data, type: 'PRG' }] })
+//     data   the file's bytes; for a program, its load address first, as a .prg has it
+//     a Uint8Array of 174,848 bytes
+//   add(image, files)   files added to a disk that has some, theirs left where they are (below)
+//   read(image)         a disk read: { name, id, files: [{ name, type, locked, closed, blocks, body, address and raw
+//                       (a program: its load address, and its bytes with it) }] }; each body a Uint8Array
+//   petsciiName(bytes)  a name as the 1541 keeps it, as text: shifted letters $C1 to $DA as capitals, the $A0
+//                       padding gone
+export const SECTORS = [...Array(17).fill(21), ...Array(7).fill(19), ...Array(6).fill(18), ...Array(5).fill(17)];
+const TYPES = { DEL: 0, SEQ: 1, PRG: 2, USR: 3, REL: 4 };
+const offset = (t, s) => (SECTORS.slice(0, t - 1).reduce((a, b) => a + b, 0) + s) * 256;
+
+// a name as the 1541 keeps it: 16 bytes of PETSCII, the letters as capitals, padded with $A0
+const name16 = text => {
+  const out = new Uint8Array(16).fill(0xa0);
+  [...String(text).toUpperCase()].slice(0, 16).forEach((c, i) => { out[i] = c.charCodeAt(0) & 0xff; });
+  return out;
+};
+
+export function make({ name = 'MOONBASE', id = 'MB', files = [] } = {}) {
+  const image = new Uint8Array(174848), used = SECTORS.map(n => new Array(n).fill(false));
+  const take = (t, s) => { used[t - 1][s] = true; return offset(t, s); };
+  take(18, 0);
+
+  // the sectors for a file: the tracks nearest the directory first, ten sectors apart on each
+  const ORDER = [];
+  for (let d = 1; d <= 17; d++) { if (18 - d >= 1) ORDER.push(18 - d); if (18 + d <= 35) ORDER.push(18 + d); }
+  const free = () => {
+    for (const t of ORDER) {
+      const n = SECTORS[t - 1], start = used[t - 1].lastTaken ?? -10;
+      for (let k = 0; k < n; k++) { const s = (start + 10 + k) % n; if (!used[t - 1][s]) { used[t - 1][s] = true; used[t - 1].lastTaken = s; return [t, s]; } }
+    }
+    throw new Error('the disk is full');
+  };
+
+  // the files' bodies, sector by sector
+  const entries = files.map(f => {
+    const data = f.data instanceof Uint8Array ? f.data : Uint8Array.from(f.data);
+    const chunks = Math.max(1, Math.ceil(data.length / 254)), places = Array.from({ length: chunks }, free);
+    places.forEach(([t, s], i) => {
+      const at = take(t, s), part = data.subarray(i * 254, (i + 1) * 254);
+      if (i + 1 < chunks) { image[at] = places[i + 1][0]; image[at + 1] = places[i + 1][1]; }
+      else { image[at] = 0; image[at + 1] = part.length + 1; }
+      image.set(part, at + 2);
+    });
+    return { name: name16(f.name), type: 0x80 | (TYPES[f.type ?? 'PRG'] ?? 2), first: places[0], blocks: chunks };
+  });
+
+  // the directory: eight entries a sector, on track 18 from sector 1, three apart
+  const dirSectors = [];
+  for (let i = 0, s = 1; i < Math.max(1, Math.ceil(entries.length / 8)); i++, s = (s + 3) % 19) {
+    while (used[17][s]) s = (s + 1) % 19;
+    if (dirSectors.length >= 18) throw new Error('the directory is full: 144 files');
+    take(18, s); dirSectors.push(s);
+  }
+  dirSectors.forEach((s, i) => {
+    const at = offset(18, s);
+    if (i + 1 < dirSectors.length) { image[at] = 18; image[at + 1] = dirSectors[i + 1]; } else { image[at] = 0; image[at + 1] = 0xff; }
+    entries.slice(i * 8, i * 8 + 8).forEach((e, k) => {
+      const p = at + k * 32;
+      image[p + 2] = e.type; image[p + 3] = e.first[0]; image[p + 4] = e.first[1];
+      image.set(e.name, p + 5);
+      image[p + 30] = e.blocks & 0xff; image[p + 31] = e.blocks >> 8;
+    });
+  });
+
+  // the BAM: the directory's first sector, the format's mark, each track's free count and map
+  const bam = offset(18, 0);
+  image[bam] = 18; image[bam + 1] = dirSectors[0]; image[bam + 2] = 0x41;
+  for (let t = 1; t <= 35; t++) {
+    const map = used[t - 1].map(u => !u), at = bam + 4 * t;
+    image[at] = map.filter(Boolean).length;
+    for (let s = 0; s < map.length; s++) if (map[s]) image[at + 1 + (s >> 3)] |= 1 << (s & 7);
+  }
+  image.set(name16(name), bam + 0x90);
+  image[bam + 0xa0] = image[bam + 0xa1] = 0xa0;
+  image[bam + 0xa2] = String(id).charCodeAt(0) || 0x30; image[bam + 0xa3] = String(id).charCodeAt(1) || 0x30;
+  image[bam + 0xa4] = 0xa0; image[bam + 0xa5] = 0x32; image[bam + 0xa6] = 0x41;
+  image.fill(0xa0, bam + 0xa7, bam + 0xab);
+  return image;
+}
+
+// Files added to a disk that already has some, as a 1541 SAVEs them: the disk's own files left in
+// their sectors (a game may read them by track and sector), a file of the same name replaced and
+// its sectors freed, the new ones laid in free sectors as the BAM has them and entered in the
+// directory's first empty entry (a new directory sector where none is empty).
+//
+//   add(image, [{ name, data }])   a new image; the one given is not changed
+export function add(image, files) {
+  const out = Uint8Array.from(image), bam = offset(18, 0);
+  const isFree = (t, s) => !!(out[bam + 4 * t + 1 + (s >> 3)] & 1 << (s & 7));
+  const mark = (t, s, free) => {
+    const at = bam + 4 * t + 1 + (s >> 3), was = isFree(t, s);
+    if (free) out[at] |= 1 << (s & 7); else out[at] &= ~(1 << (s & 7));
+    out[bam + 4 * t] += free && !was ? 1 : !free && was ? -1 : 0;
+  };
+  const ORDER = [];
+  for (let d = 1; d <= 17; d++) { if (18 - d >= 1) ORDER.push(18 - d); if (18 + d <= 35) ORDER.push(18 + d); }
+  const last = {};
+  const take = () => {
+    for (const t of ORDER) {
+      const n = SECTORS[t - 1];
+      for (let k = 0; k < n; k++) { const s = ((last[t] ?? -10) + 10 + k) % n; if (isFree(t, s)) { mark(t, s, false); last[t] = s; return [t, s]; } }
+    }
+    throw new Error('the disk is full');
+  };
+  // the directory's entries, by where each is
+  const entries = () => {
+    const list = [];
+    for (let [t, s] = [out[bam], out[bam + 1]], n = 0; t && n < 18; n++) {
+      const at = offset(t, s);
+      for (let k = 0; k < 8; k++) list.push(at + k * 32);
+      [t, s] = [out[at], out[at + 1]];
+    }
+    return list;
+  };
+  for (const f of files) {
+    const name = name16(f.name), data = f.data instanceof Uint8Array ? f.data : Uint8Array.from(f.data);
+    // (one of the same name: its sectors freed, its entry emptied)
+    for (const e of entries()) {
+      if (!(out[e + 2] & 7) || !name.every((b, i) => out[e + 5 + i] === b)) continue;
+      for (let [t, s] = [out[e + 3], out[e + 4]], n = 0; t && n < 683; n++) { const at = offset(t, s); mark(t, s, true); [t, s] = [out[at], out[at + 1]]; }
+      out[e + 2] = 0;
+    }
+    const chunks = Math.max(1, Math.ceil(data.length / 254)), places = Array.from({ length: chunks }, take);
+    places.forEach(([t, s], i) => {
+      const at = offset(t, s), part = data.subarray(i * 254, (i + 1) * 254);
+      out.fill(0, at, at + 256);
+      if (i + 1 < chunks) { out[at] = places[i + 1][0]; out[at + 1] = places[i + 1][1]; } else { out[at] = 0; out[at + 1] = part.length + 1; }
+      out.set(part, at + 2);
+    });
+    let e = entries().find(e => !(out[e + 2] & 7) && !out[e + 2]);
+    if (e === undefined) {
+      // (a new directory sector, on track 18, linked after the last)
+      const list = entries(), lastSector = list[list.length - 1] - 7 * 32;
+      let s = 1; while (s < 19 && !isFree(18, s)) s++;
+      if (s >= 19) throw new Error('the directory is full');
+      mark(18, s, false);
+      const at = offset(18, s); out.fill(0, at, at + 256); out[at + 1] = 0xff;
+      out[lastSector] = 18; out[lastSector + 1] = s;
+      e = at;
+    }
+    out.fill(0, e + 2, e + 32);
+    out[e + 2] = 0x80 | (TYPES[f.type ?? 'PRG'] ?? 2); out[e + 3] = places[0][0]; out[e + 4] = places[0][1];
+    out.set(name, e + 5);
+    out[e + 30] = chunks & 0xff; out[e + 31] = chunks >> 8;
+  }
+  return out;
+}
+
+// Reading a disk: the BAM's sector names the disk, and the directory's chain from track 18, sector 1, eight
+// 32-byte entries a sector, each a file's type, its first sector and its name; a file's sectors follow each
+// other by their first two bytes, the last one's second byte the index of its last byte.
+const NAMES = ['DEL', 'SEQ', 'PRG', 'USR', 'REL'];
+export const petsciiName = bytes => String.fromCharCode(...[...bytes].filter(b => b !== 0xa0).map(b => (b >= 0xc1 && b <= 0xda ? b - 0x80 : b))).trim();
+
+export function read(image) {
+  if (image.length !== 174848 && image.length !== 175531) throw new Error('a .d64 is 174,848 bytes, and this one is ' + image.length);
+  const sector = (t, s) => image.subarray(offset(t, s), offset(t, s) + 256);
+  const chain = (t, s) => {
+    const parts = [];
+    while (t) { const b = sector(t, s); [t, s] = [b[0], b[1]]; parts.push(b.subarray(2, t ? 256 : s + 1)); }
+    const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+    parts.reduce((at, p) => (out.set(p, at), at + p.length), 0);
+    return out;
+  };
+  const bam = sector(18, 0);
+  const name = petsciiName(bam.subarray(0x90, 0xa0)), id = String.fromCharCode(bam[0xa2], bam[0xa3]);
+  const files = [];
+  for (let [t, s] = [bam[0], bam[1]]; t; ) {
+    const b = sector(t, s);
+    for (let i = 0; i < 8; i++) {
+      const e = b.subarray(i * 32, (i + 1) * 32);
+      if (!e[2]) continue;
+      const type = NAMES[e[2] & 7] || '?', body = chain(e[3], e[4]);
+      const file = { name: petsciiName(e.subarray(5, 21)), type, locked: !!(e[2] & 0x40), closed: !!(e[2] & 0x80), blocks: e[30] | e[31] << 8, body };
+      if (type === 'PRG' && body.length >= 2) { file.address = body[0] | body[1] << 8; file.body = body.subarray(2); file.raw = body; }
+      files.push(file);
+    }
+    [t, s] = [b[0], b[1]];
+  }
+  return { name, id, files };
+}