@moonbase-machines/c64 0.0.0-stage → 0.5.0

package/numbers.js

@@ -0,0 +1,64 @@
+// Commodore BASIC's rules for numbers, held once for every layer that keeps them: the remake's
+// BASIC (basic.js, on JavaScript's numbers) and moonbase's BASIC ROM (basic-rom.js, on the ROM's
+// five-byte floats). BASIC's errors in its own words; a whole number of 16 bits; a number as FOUT
+// writes it and as VAL reads it; and RND's numbers as moonbase gives them, the same on every line.
+//
+// (FOUT and VAL are held to the ROM's.)
+
+import { Floats, CONSTANTS, pack } from './float.js';
+
+// (an error's BASIC line, where it is not the statement's own, is its `basicLine`: WebKit gives
+// every Error a `line` of its own, the line of the JavaScript it was thrown from)
+export class BasicError extends Error {}
+// BASIC's error messages, by their number in its table (the X its error routine takes, $A437, less 1)
+export const ERRORS = ['TOO MANY FILES', 'FILE OPEN', 'FILE NOT OPEN', 'FILE NOT FOUND', 'DEVICE NOT PRESENT', 'NOT INPUT FILE', 'NOT OUTPUT FILE', 'MISSING FILE NAME',
+  'ILLEGAL DEVICE NUMBER', 'NEXT WITHOUT FOR', 'SYNTAX', 'RETURN WITHOUT GOSUB', 'OUT OF DATA', 'ILLEGAL QUANTITY', 'OVERFLOW', 'OUT OF MEMORY', 'UNDEF\'D STATEMENT',
+  'BAD SUBSCRIPT', 'REDIM\'D ARRAY', 'DIVISION BY ZERO', 'ILLEGAL DIRECT', 'TYPE MISMATCH', 'STRING TOO LONG', 'FILE DATA', 'FORMULA TOO COMPLEX', 'CAN\'T CONTINUE',
+  'UNDEF\'D FUNCTION', 'VERIFY', 'LOAD', 'BREAK'];
+export const fail = what => { throw new BasicError('?' + what + ' ERROR'); };
+
+// A number as BASIC writes it (FOUT): a space for its sign when it is not negative, nine
+// significant digits, no 0 before the point, and an exponent below 0.01 or from 1E+09 on. The
+// number as BASIC's five bytes hold it, and FOUT's own steps on them (float.js, held to
+// Microsoft's and Commodore's), its last digit as theirs: JavaScript's rounding of nine digits
+// differs from it for one number in twenty.
+const page = new Uint8Array(0x10000), floats = new Floats({ read: a => page[a], write: (a, v) => { page[a] = v; } });
+for (const [at, bytes] of Object.entries(CONSTANTS)) page.set(bytes, +at);
+export function fout(x) {
+  const b = pack(x);
+  if (!b[0] || Math.abs(x) < 2 ** -128) return ' 0';
+  if (b[0] > 255) fail('OVERFLOW');
+  page[0x61] = b[0]; page[0x62] = b[1] | 0x80; page.set(b.slice(2), 0x63); page[0x66] = x < 0 ? 0xff : 0; page[0x70] = 0;
+  floats.fout();
+  let s = ''; for (let a = 0x100; page[a]; a++) s += String.fromCharCode(page[a]);
+  return s;
+}
+
+// VAL: the number at a string's start, BASIC's way: spaces skipped, a sign, digits, a point, an
+// exponent; 0 if there is none
+export function val(s) {
+  const t = s.replace(/ /g, ''), m = /^[+-]?(\d*\.?\d*)(E[+-]?\d+)?/.exec(t);
+  const n = m && m[1] && m[1] !== '.' ? Number(m[0].replace(/E$/, '')) : 0;
+  return Number.isFinite(n) ? n : 0;
+}
+
+// A number's text where INPUT reads one, as FIN reads it ($BCF3): spaces passed over anywhere,
+// as CHRGET passes them; a sign; digits; a point and digits; an E, a sign and digits. Where it
+// ends, for INPUT to look at what follows (a comma, a colon or the line's end, or the item is bad)
+export function scanNumber(s, k) {
+  let text = '';
+  const sp = () => { while (s[k] === ' ') k++; }, digits = () => { while (s[k] >= '0' && s[k] <= '9') { text += s[k++]; sp(); } };
+  sp();
+  if (s[k] === '-' || s[k] === '+') { text += s[k++]; sp(); }
+  digits();
+  if (s[k] === '.') { text += s[k++]; sp(); digits(); }
+  if (s[k] === 'E') { text += s[k++]; sp(); if (s[k] === '-' || s[k] === '+') { text += s[k++]; sp(); } digits(); }
+  return { text, end: k };
+}
+
+export const int16 = x => { const n = Math.floor(x); if (n < -32768 || n > 32767) fail('ILLEGAL QUANTITY'); return n; };
+
+// the seed's random numbers: a 32-bit state, each number its top 31 bits as a fraction, which
+// BASIC's five-byte floats hold exactly
+export const seedRandom = seed => Math.imul(seed, 2654435761) >>> 0;
+export const nextRandom = s => (((Math.imul(s, 1664525) + 1013904223) >>> 0) & 0xfffffffe) >>> 0;

package/package.json

@@ -1,6 +1,16 @@
 {
   "name": "@moonbase-machines/c64",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.5.0",
+  "description": "A Commodore 64 as far as the games use it: the VIC-II, the SID, a 1541, a printer, and Moonbase's own KERNAL and BASIC in place of Commodore's ROMs.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Mark Wharton",
+  "exports": {
+    ".": "./index.js",
+    "./*": "./*"
+  },
+  "dependencies": {
+    "@moonbase-machines/mos6502": "0.5.0",
+    "@moonbase-machines/charset": "0.5.0"
+  }
+}

package/paint.js

@@ -0,0 +1,23 @@
+// A Commodore 64's frame painted from memory and the chips' registers, by the VIC-II as the
+// emulator draws it (vic.js), for a remake: its memory, its I/O page's bytes ($D000 to
+// $DFFF as the remake keeps them: the VIC's registers, the colours, CIA 2's bank) and the
+// character ROM, which a text screen in the ROM's own characters needs. And `splits`, where a
+// game's raster interrupt changes the VIC's registers partway down (Find Me's two character
+// sets): each line's interrupt's writes, from the line after, and the last's from the top.
+import { VIC } from './vic.js';
+
+export function paint(mem, chip, chargen, vic, splits) {
+  const m = { ram: mem, chargen: chargen ?? new Uint8Array(0x1000), color: chip.subarray(0x800, 0xc00), cia2: { pra: chip[0xd00] }, line: 0 };
+  vic ??= new VIC(m);
+  vic.m = m;
+  vic.r.set(chip.subarray(0, 0x40));
+  const at = splits?.size ? [...splits].sort((a, b) => a[0] - b[0]) : [];
+  // (a split's $100 is CIA 2's first port, the VIC's bank)
+  const set = (r, v) => { if (r === 0x100) m.cia2.pra = v; else vic.r[r] = v; };
+  if (at.length) for (const [r, v] of at.at(-1)[1]) set(r, v);
+  for (let y = 0, k = 0; y < 312; y++) {
+    while (k < at.length && at[k][0] < y) { for (const [r, v] of at[k][1]) set(r, v); k++; }
+    m.line = y; vic.line(y);
+  }
+  return vic.frame;
+}

package/petscii.js

@@ -0,0 +1,54 @@
+// PETSCII as text that can be typed and read, as moonbase's listings write it: the control
+// characters by their names in braces, {CLR}, {RVS ON}, and any other byte as {$xx}; for game
+// documents and a BASIC page.
+//
+//   bytes('{CLR}HELLO', { lower })   the bytes a C64 prints: with lower, the second character
+//                                    set's (a small letter $41 to $5A, a capital $C1 to $DA);
+//                                    without, the first's (letters typed either way, $41 to $5A)
+//   text(bytes, { lower })           back again: with lower, the second character set's way
+//                                    ($41 to $5A small letters, $C1 to $DA capitals)
+
+export const CONTROLS = { WHT: 0x05, 'DISABLE SHIFT': 0x08, 'ENABLE SHIFT': 0x09, RETURN: 0x0d, LOWER: 0x0e, DOWN: 0x11, 'RVS ON': 0x12, HOME: 0x13, DEL: 0x14,
+  RED: 0x1c, RIGHT: 0x1d, GRN: 0x1e, BLU: 0x1f, ORNG: 0x81, F1: 0x85, F3: 0x86, F5: 0x87, F7: 0x88, F2: 0x89, F4: 0x8a, F6: 0x8b, F8: 0x8c,
+  UPPER: 0x8e, BLK: 0x90, UP: 0x91, 'RVS OFF': 0x92, CLR: 0x93, INST: 0x94, BRN: 0x95,
+  LRED: 0x96, GRY1: 0x97, GRY2: 0x98, LGRN: 0x99, LBLU: 0x9a, GRY3: 0x9b, PUR: 0x9c, LEFT: 0x9d, YEL: 0x9e, CYN: 0x9f, 'SHIFT SPACE': 0xa0, PI: 0xff };
+const NAMES = Object.fromEntries(Object.entries(CONTROLS).map(([n, b]) => [b, n]));
+
+export function bytes(t, { lower = false } = {}) {
+  const out = [];
+  for (let k = 0; k < t.length; k++) {
+    const c = t[k];
+    if (c === '{') {
+      const end = t.indexOf('}', k), name = t.slice(k + 1, end);
+      if (end < 0) throw new Error('a { with no }: ' + t);
+      const n = /^\$([0-9A-F]{2})$/i.exec(name) ? parseInt(name.slice(1), 16) : CONTROLS[name.toUpperCase()];
+      if (n === undefined) throw new Error(`no control character {${name}}`);
+      out.push(n); k = end; continue;
+    }
+    const v = c.charCodeAt(0);
+    if (c === '£') out.push(0x5c);
+    else if (c === '↑') out.push(0x5e);
+    else if (c === '←') out.push(0x5f);
+    else if (c === 'π') out.push(0xff);
+    else if (v >= 0x61 && v <= 0x7a) out.push(v - 0x20);
+    else if (lower && v >= 0x41 && v <= 0x5a) out.push(v + 0x80);
+    else out.push(v & 0xff);
+  }
+  return out;
+}
+
+export function text(b, { lower = false } = {}) {
+  let out = '';
+  for (const v of b) {
+    if (lower && v >= 0x41 && v <= 0x5a) out += String.fromCharCode(v + 0x20);
+    else if (lower && v >= 0xc1 && v <= 0xda) out += String.fromCharCode(v - 0x80);
+    else if (v === 0x0d) out += '\r';
+    else if (v >= 0x20 && v < 0x5b || v === 0x5d) out += String.fromCharCode(v);
+    else if (v === 0x5c) out += '£';
+    else if (v === 0x5e) out += '↑';
+    else if (v === 0x5f) out += '←';
+    else if (v === 0x5b) out += '[';
+    else out += `{${NAMES[v] ?? '$' + v.toString(16).toUpperCase().padStart(2, '0')}}`;
+  }
+  return out;
+}

package/printer.js

@@ -0,0 +1,95 @@
+// A printer on the Commodore 64's serial bus, device 4, as the games print to it: OPEN 4,4 (or
+// 4,4,7 for small letters), PRINT# and CLOSE. It keeps what it is sent as lines of characters, in
+// the mode it was in for each (capitals and graphics, or small letters and capitals), for a page
+// to show as a sheet of paper (`paper`). It is not on the bus unless it is switched on, as the
+// machines were sold: with it off, a game finds DEVICE NOT PRESENT, as Goldfields does.
+//
+// The bus (`bus`) puts it beside the drive: LISTEN, SECOND, CIOUT and UNLISTEN go to every device,
+// and each takes them only while it is the one listening; TALK and the rest, and LOAD and SAVE,
+// are the drive's alone.
+import { screenCode } from './kernal.js';
+
+export const WIDTH = 80;   // the characters a line holds, as Commodore's printers had
+
+export class Printer {
+  constructor({ on = true } = {}) {
+    this.on = on;
+    this.listening = false; this.lower = false; this.wide = false; this.reverse = false;
+    this.lines = []; this.line = [];
+    this.changed = () => {};   // called when a line is finished, for a page to draw it
+  }
+  listen(device) { this.listening = this.on && device === 4; return this.listening; }
+  talk() { return false; }
+  // the secondary address: 7 is small letters and capitals, the rest capitals and graphics
+  second(sa) { if (this.listening) this.lower = (sa & 15) === 7; }
+  tksa() {}
+  ciout(b) {
+    if (!this.listening) return;
+    switch (b) {
+      case 13: this.feed(); return;                                         // a new line
+      case 10: return;
+      case 17: this.lower = true; return;                                   // small letters and capitals
+      case 145: this.lower = false; return;                                 // capitals and graphics
+      case 14: this.wide = true; return;                                    // double width
+      case 15: this.wide = false; return;
+      case 18: this.reverse = true; return;                                 // reversed
+      case 146: this.reverse = false; return;
+      case 29: b = 32; break;                                               // (cursor right: a space)
+    }
+    if ((b & 0x7f) < 32) return;                                            // the other controls
+    if (this.line.length >= WIDTH) this.feed();
+    this.line.push({ code: b, lower: this.lower, wide: this.wide, reverse: this.reverse });
+  }
+  feed() { this.lines.push(this.line); this.line = []; this.wide = false; this.reverse = false; this.changed(); }
+  unlsn() { this.listening = false; }
+  untlk() {}
+  acptr() { return null; }
+  tear() { this.lines = []; this.line = []; this.changed(); }   // the paper torn off
+}
+
+// the drive and the printer on one bus, as the KERNAL's serial routines reach them
+export function bus(drive, printer) {
+  const all = [drive, printer];
+  return {
+    drive, printer,
+    listen: d => all.map(x => x.listen(d)).some(Boolean),
+    talk: d => drive.talk(d),
+    second: sa => all.forEach(x => x.second(sa)),
+    tksa: sa => drive.tksa(sa),
+    ciout: b => all.forEach(x => x.ciout(b)),
+    unlsn: () => all.forEach(x => x.unlsn()),
+    untlk: () => drive.untlk(),
+    acptr: () => drive.acptr(),
+    load: name => drive.load(name),
+    save: (name, raw) => drive.save(name, raw),
+    find: name => drive.find(name),
+  };
+}
+
+// The sheet: what the printer has printed, drawn on a canvas in the 64's own characters (the
+// character ROM, `chargen`), black on continuous paper with its feed holes down both sides
+export function paper(canvas, printer, chargen, { scale = 2 } = {}) {
+  // (a line a character and a half high, as a printer spaces them)
+  const margin = 24, cell = 8 * scale, line = cell * 1.5, rows = Math.max(12, printer.lines.length + 2);
+  canvas.width = (WIDTH * 8 + margin * 2) * scale / 2 * 2; canvas.height = rows * line + cell;
+  const g = canvas.getContext('2d'), w = canvas.width;
+  g.fillStyle = '#fbfaf3'; g.fillRect(0, 0, w, canvas.height);
+  for (let r = 0; r < rows; r += 6) { g.fillStyle = '#e6f0e2'; g.fillRect(margin * scale / 2, r * line + cell / 2, w - margin * scale, line * 3); }   // the green bars
+  g.fillStyle = '#d9d6c8';
+  for (let y = cell / 2; y < canvas.height; y += cell * 2) for (const x of [margin * scale / 4, w - margin * scale / 4]) { g.beginPath(); g.arc(x, y, scale * 2.5, 0, Math.PI * 2); g.fill(); }
+  const lines = [...printer.lines, printer.line], dot = scale;
+  lines.forEach((chars, r) => {
+    let x = margin * scale / 2 + cell / 2;
+    for (const c of chars) {
+      const sc = screenCode(c.code), base = (c.lower ? 0x800 : 0) + sc * 8, wide = c.wide ? 2 : 1;
+      for (let py = 0; py < 8; py++) {
+        const bits = chargen ? chargen[base + py] : 0;
+        for (let px = 0; px < 8; px++) {
+          const on = (bits >> (7 - px) & 1) ^ (c.reverse ? 1 : 0);
+          if (on) { g.fillStyle = '#26241f'; g.fillRect(x + px * dot * wide, r * line + cell / 2 + py * dot, dot * wide, dot); }
+        }
+      }
+      x += cell * wide;
+    }
+  });
+}