@moonbase-machines/player 0.9.1 → 0.11.0

package/engines/original.js

@@ -0,0 +1,155 @@
+// The Original's engine (play.js hands it the game): the game's disk in the machine it was made for, its screen on a
+// canvas on the stage, and each picture the engine draws also given as SVG over the canvas. Each game's machine is
+// loaded when its game asks for it, the Commodore 64 (@moonbase-machines/c64) or the Apple IIe
+// (@moonbase-machines/apple2e), and not the other; on moonbase's own ROMs, which need nothing of the makers'.
+//
+// Of the player's `game` it reads: the game's data (`game`), its saves (`saves`), the stage, the status, and what only
+// a workshop has (play.js): `roms`, the makers' ROMs this machine has, an Apple game's line 1, Apple's own booting its
+// disks, { apple: { system, disk2 }, image: async name => its disk image's bytes }, a Commodore 64 game's Commodore's,
+// { choice ('commodore' or 'moonbase-petscii', @moonbase-machines/c64/start.js), load: async name => a ROM's bytes };
+// and `studies`, files of its own for a Commodore 64 game's disk, a name to its bytes in base64, in the drive, not kept.
+import { Speaker } from '../audio.js';
+
+// the setting the Apple's engine acts on (play.js `setting`): its pictures drawn as vectors over the screen
+const VECTORS = { name: 'vectors', type: 'boolean', default: false, owner: 'person', words: 'Draw the pictures as vectors' };
+
+export async function play(g) {
+  g.stage.innerHTML = '<svg id="vector" viewBox="0 0 140 192" preserveAspectRatio="none"></svg><canvas id="screen" width="560" height="384" tabindex="0"></canvas>';
+  const canvas = g.stage.querySelector('canvas'), ctx = canvas.getContext('2d'), layer = g.stage.querySelector('#vector');
+  return g.game.kind === 'c64' ? c64(g, { canvas, layer, speaker: new Speaker() }) : apple(g, { canvas, ctx, layer, speaker: new Speaker() });
+}
+
+// An Apple II game: the machine, the canvas, the keys, and the hooks for the vectors. With Apple's
+// ROMs and the game's disk images, where the page gives them (`roms`), it is line 1, the Apple itself booting the
+// disks; without them, moonbase's (line 2), the game started at once.
+async function apple({ game, saves, roms: makers, status, setting }, { canvas, ctx, layer, speaker }) {
+const [{ Machine }, { placed }, { screen }, { shapes }, { elements }] = await Promise.all([
+  import('@moonbase-machines/apple2e/machine.js'), import('@moonbase-machines/apple2e/prodos.js'),
+  import('@moonbase-machines/apple2e/screen.js'), import('@moonbase-machines/vector/pictures.js'), import('@moonbase-machines/vector/svg.js')]);
+const vectors = setting(VECTORS);
+// the title's saves on its own volume, the player's disk's (play.js `saves`): on line 2 the machine's files; on line 1
+// written onto that volume's disk before it boots, and kept as the title's DOS writes it
+const saving = saves.data;
+let roms = null, disks = null;
+if (makers?.apple) try {
+  roms = makers.apple;
+  disks = saves.disks(placed(saving, new Map(await Promise.all(game.images.map(async n => [n, await makers.image(n)])))));
+} catch { roms = null; }
+const m = new Machine(saving, { log: (...a) => console.log(...a), ...roms ? { roms, disks } : {} });
+console.log(roms ? "line 1: Apple's ROMs, the disks booted" : "line 2: moonbase's machine");
+saves.keep(roms ? saves.driveFiles(m, disks) : m.disk);
+m.diskTime = true;   // reads from the disk take the time a disk took, as the games' loading screens expect
+
+// Where the engine is hooked, found in PART0 once it is loaded, in whichever bank the game runs
+// in. The picture routine's loop draws the shapes the loader has put at $E000 one by one, so on
+// its first shape the whole picture is read for the SVG, and from there to the routine's exit,
+// which sets X to 0 and Y to $E0, the machine marks every screen byte written as the picture's.
+// The box routine, which clears the picture window, starts by keeping its three colors, and
+// there the SVG and the marks are cleared, and the window's color, in A, is kept to go under
+// the next pictures' polygons.
+let hooked = false, window_ = 0;
+function hook() {
+  const find = (bytes, code) => { outer: for (let a = 0x4000; a < 0x8000 - bytes.length; a++) { for (let i = 0; i < bytes.length; i++) if (bytes[i] !== null && code[a + i] !== bytes[i]) continue outer; return a; } return -1; };
+  for (const code of [m.aux, m.main]) {
+    const shape = find([0x20, null, null, 0x20, null, null, 0xee, null, null, 0x4c], code);   // JSR fill; JSR outline; INC count; JMP loop
+    const exit = find([0xa2, 0x00, 0xa0, 0xe0, 0x18, 0x60], code);   // LDX #0; LDY #$E0; CLC; RTS
+    const box = find([0x8d, null, null, 0x8e, null, null, 0x8c, null, null, 0xad, null, null, 0xc9, 0x80, 0xf0], code);
+    if (shape < 0 || exit < 0 || box < 0) continue;
+    m.cpu.hooks.set(shape, c => { if (c.read16(0x60) === 0xe000) { layer.insertAdjacentHTML('beforeend', elements(shapes(a => m.read(a), 0xe000), { background: window_ })); m.marking = 1; } return false; });
+    m.cpu.hooks.set(exit, () => { m.marking = 0; return false; });
+    m.cpu.hooks.set(box, c => { if (c.a !== 0x80) window_ = c.a & 15; layer.innerHTML = ''; m.owner.fill(0); return false; });
+    hooked = true;
+    return;
+  }
+}
+
+
+const rgba = new Uint8ClampedArray(560 * 384 * 4);
+const image = new ImageData(rgba, 560, 384);
+const cols = new Uint8Array(140 * 192);
+let mode = '';
+function frame() {
+  if (!m.halted) m.runCycles(17030);   // a frame's worth of the Apple's clock, at 60 a second
+  const now = `text ${m.sw.text} page2 ${m.sw.page2} hires ${m.sw.hires} dhires ${m.sw.dhires}`;
+  if (now !== mode) { console.log('screen:', now, 'at pc $' + m.cpu.pc.toString(16), 'cycles', m.cpu.cycles); mode = now; }
+  speaker.feed(sound ? m.clicks : [], m.cpu.cycles); m.clicks.length = 0;
+  if (!hooked) hook();
+  const text = m.sw.text;
+  screen(m, rgba, { cols, owner: vectors.value && layer.innerHTML ? m.owner : null });
+  ctx.putImageData(image, 0, 0);
+  layer.style.visibility = vectors.value && !text ? 'visible' : 'hidden';
+  status.textContent = m.halted ? 'The game has stopped: ' + m.halted + '.' : (m.idle > 2000 ? 'Waiting for a key.' : 'Running.');
+  requestAnimationFrame(frame);
+}
+canvas.addEventListener('pointerdown', () => canvas.focus());
+// (the keys, the Apple's codes, given by the player: play.js, keys.js)
+let sound = true;
+return {
+  run() { canvas.focus(); frame(); },
+  press(k) { console.log('key', k, 'at pc $' + m.cpu.pc.toString(16)); m.press(k); },
+  start() { speaker.start(); },
+  sound(on) { sound = on; },
+  engine: m,
+};
+}
+
+// A C64 game: on moonbase's own ROMs (@moonbase-machines/c64/rom.js), as the site has it everywhere, or on
+// Commodore's where the page gives them (`roms`) and asks for them; the machine autostarted
+// with LOAD"name",8,1, and RUN for a BASIC program, typed into the KERNAL's buffer, the frame on a canvas of
+// 384 by 272 doubled, the keys as the matrix and the arrows as the joystick.
+async function c64(g, { canvas, layer, speaker }) {
+  const { game, saves, roms: makers, studies, status, printer } = g;
+  const [{ C64 }, { keyboard, painter }, { SID }, { c64Roms, typed: startTyped }, { add }] = await Promise.all([
+    import('@moonbase-machines/c64/machine.js'), import('@moonbase-machines/c64/browser.js'),
+    import('@moonbase-machines/c64/sid.js'), import('@moonbase-machines/c64/start.js'), import('@moonbase-machines/c64/d64.js')]);
+  const roms = await c64Roms(makers?.choice ?? null, makers?.load);
+  if (!roms) { status.textContent = 'Commodore\'s ROMs, asked for, are not here.'; return null; }
+  g.chargen = roms.chargen;   // (the printer's paper in the machine's characters: play.js)
+  const m = new C64(game, roms, { log: (...a) => console.log(...a), printer });
+  // What the game SAVEs to its disk, kept on the player's disk and given back to the drive the next time (play.js
+  // `saves`)
+  saves.drive(m.drive);
+  // (and, where the page gives them, `studies`, files of its own for the disk, a name to a file: in the drive, not
+  // kept)
+  const raw = t => Uint8Array.from(atob(t), c => c.charCodeAt(0));
+  for (const [file, data] of Object.entries(studies ?? {})) m.drive.saved.set(file, raw(data));
+  layer.style.display = 'none';
+  const draw = painter(canvas);
+  let typing = null, typed = 0, sound = true;
+  // the keys as the 64's matrix (@moonbase-machines/c64/browser.js), given them by the player (play.js)
+  const listeners = { keydown: [], keyup: [] };
+  const keys = keyboard(m, { log: true, listen: (type, f) => listeners[type].push(f) });
+  // once BASIC is ready, the start typed in; the KERNAL's buffer takes ten characters at a time.
+  // The C64 runs 50 frames a second, so frames are run to keep up with the clock, two at most.
+  let frames = 0, sid = null, started = performance.now();
+  function frame() {
+    const due = Math.min(2, Math.floor((performance.now() - started) / 20) - frames);
+    for (let i = 0; i < due; i++) {
+      m.runFrame(); frames++; keys.frame();
+      if (speaker.node && sound) {
+        if (!sid) sid = new SID(speaker.rate);
+        const n = Math.round(19656 / 985248 * speaker.rate), first = m.cpu.cycles - 19656;
+        const wave = sid.render(n, m.sidWrites.map(([c, r, v]) => [Math.floor((c - first) / 19656 * n), r, v]));
+        speaker.node.port.postMessage(wave, [wave.buffer]);
+      }
+      m.sidWrites.length = 0;
+    }
+    // (LOAD, and RUN for a BASIC program: @moonbase-machines/c64/start.js)
+    if (frames >= 120 && typing === null && !typed) { typing = startTyped(m, game); typed = 1; }
+    if (typing !== null && !m.ram[0xc6]) { typing = m.type(typing); if (!typing.length) typing = null; }
+    draw(m.vic.frame);
+    status.textContent = m.halted ? 'The game has stopped: ' + m.halted + '.' : 'Running.';
+    requestAnimationFrame(frame);
+  }
+  return {
+    run() { canvas.focus(); frame(); },
+    press(k) { m.type(String.fromCharCode(k)); },   // (into the KERNAL's buffer, as typed)
+    key(e) { for (const f of listeners[e.type]) f(e); },
+    start() { speaker.start(); },
+    sound(on) { sound = on; },
+    engine: m,
+    // the disk as it now stands, its own files and those saved: a .d64 that VICE or a real 64 can use
+    // (@moonbase-machines/c64/d64.js `add`)
+    diskImage: () => add(m.drive.image, [...m.drive.saved].map(([name, data]) => ({ name, data }))),
+  };
+}

package/engines/scenes.js

@@ -0,0 +1,213 @@
+// The Remake's engine for a title of scenes, 'card' or 'vector' (play.js hands it the game): its scripts on the
+// remake's engine (remake/engine.js), its events drawn by the view on the stage, the view the machine's (an Apple's
+// hi-res page for a card title, CardView; a Commodore 64's, C64View; a vector title's pictures and text, View); the
+// settings it acts on (play.js `game.setting`): the old style text, where its view draws text of its own (View); the
+// mini view, where the page gives one and the title has a place for it. A run's events are drawn one after another, with a moment for each sound and flash, so that what the
+// original took time over takes time here too.
+import { makeEngine } from '../remake/load.js';
+
+// the settings this engine acts on (play.js `setting`): the old style text, a vector title's; the mini view
+const OLD_STYLE = { name: 'old-style', type: 'boolean', default: false, owner: 'person', words: 'Old style text' };
+const MINI = { name: 'mini', type: ['', 'live', 'pictures'], default: '', owner: 'person', words: 'Mini view', labels: ['Off', 'Live', 'Pictures'] };
+import { Speaker } from '../audio.js';
+import { SID } from '@moonbase-machines/c64/sid.js';
+import { matrixOf } from '@moonbase-machines/c64/kernal.js';
+import { standIn } from '@moonbase-machines/c64/rom.js';
+import { Drive } from '@moonbase-machines/c64/drive.js';
+import { View } from '../remake/view.js';
+import { CardView } from '../remake/card-view.js';
+import { C64View } from '../remake/c64-view.js';
+
+export async function play(g) {
+  const { title, scripts, game: disk, stage, status, fail, saves, $ } = g;
+  const c64 = disk.kind === 'c64';
+  stage.innerHTML = `<svg id="screen" preserveAspectRatio="xMidYMid meet" tabindex="0" aria-label="The game's screen"></svg>`;
+  const svg = $('screen'), drawn = c64 ? 'c64' : title.engine === 'card' ? 'card' : 'vector';
+
+  // its view's own drawing, for a title that has one (its title.js `view`, load.js)
+  const extra = title.viewSteps ?? {};
+  // a Commodore 64's character ROM, for its view and the printer's paper: Commodore's where the page gives them
+  // (`roms`), else moonbase's own
+  const chargen = g.chargen = c64 ? g.roms?.chargen ?? standIn().chargen : null;
+  // a Commodore 64 title's printer on device 4, the player's (play.js), on the bus card.js makes
+  if (g.printer) title.printer = g.printer;
+  // what the game saves, on the player's disk (play.js `saves`): an Apple title's data disk, a Commodore 64 title's
+  // drive (the drive card.js puts on the bus)
+  title.disk = saves.data;
+  if (c64) saves.drive(title.drive = new Drive(Uint8Array.from(atob(disk.image), ch => ch.charCodeAt(0))));
+  const engine = makeEngine(title, scripts);
+  if (title.files) saves.keep(title.files);
+  const queue = [];
+  // The view, and every event it has drawn, so that it can be drawn again from the start when the old style text is
+  // turned on or off: a setting only where the view draws text of its own, a vector title's (View), the others drawing
+  // the machine's own screen
+  const history = [];
+  const oldStyle = drawn === 'vector' ? g.setting(OLD_STYLE) : { value: false, on() { return this; } };
+  let onView = null;   // (the mini view's, given each view made)
+  const makeView = () => { svg.replaceChildren(); const v = drawn === 'c64' ? new C64View(svg, { engine, chargen }) : drawn === 'card' ? new CardView(svg, { engine, inset: g.mini ? title.inset : null }) : new View(svg, { disk, volume: Object.keys(disk.volumes)[0], engine, extra }); v.oldStyle = oldStyle.value; onView?.(v); return v; };
+  let view = makeView();
+  engine.on(e => queue.push(view.snapshot({ ...e })));
+  // The mini view, where the page gives one (`mini`) and the title has a place for it (its title.js `inset`): Off,
+  // Live or Pictures, a setting; shown in the band at the top of the screen while the band is there. A picture only:
+  // the game's screen otherwise as it is
+  if (title.inset && g.mini) {
+    const choice = g.setting(MINI);
+    const { top, bottom, view: [left, right] } = title.inset, at = document.createElement('div');
+    at.className = 'mini'; at.hidden = true;
+    Object.assign(at.style, { left: `${left / 5.6}%`, top: `${top / 3.84}%`, width: `${(right - left) / 5.6}%`, height: `${(bottom - top + 1) / 3.84}%` });
+    svg.parentElement.append(at);
+    const mini = await g.mini(at, { memory: () => engine.mem });
+    // (each view's painting followed by the mini view shown or not, as the band is there or not)
+    onView = v => { v.insetOn = !!choice.value; const prompts = v.prompts.bind(v); v.prompts = () => { prompts(); at.hidden = !(choice.value && v.banded); }; };
+    onView(view);
+    const show = () => { view.insetOn = !!choice.value; mini.mode(choice.value); view.prompts(); };
+    choice.on(show);
+    show();
+  }
+  oldStyle.on(() => {
+    view = makeView();
+    for (const e of history) view.apply(e);
+    view.prompts();
+  });
+
+  // the sound: a title that keeps the original's time (a card title's, Engine.time) clicks the speaker as the original
+  // did, and the clicks are played as the emulator plays them (audio.js); a vector title's tones play where its own
+  // sound flag is on, the teacher's setting in the game, as on the original. The player's Sound setting (play.js) is
+  // the speaker, on or off, for both.
+  const speaker = engine.timed ? new Speaker() : null;
+  let sounding = true;
+  const hear = () => { if (!c64) speaker?.feed(sounding ? engine.clicks : [], engine.cycles); engine.clicks.length = 0; };
+  const V = title.map?.vars ?? { sound: 0, soundOn: 0 };
+  let audio = null;
+  const tone = (from, to, ms) => {
+    if (!sounding || !(engine.mem[V.sound] & V.soundOn)) return;
+    audio ??= new AudioContext();
+    const o = audio.createOscillator(), gain = audio.createGain(), t = audio.currentTime;
+    o.type = 'square'; o.frequency.setValueAtTime(from, t); o.frequency.linearRampToValueAtTime(to, t + ms / 1000);
+    gain.gain.setValueAtTime(0.06, t); gain.gain.linearRampToValueAtTime(0, t + ms / 1000);
+    o.connect(gain).connect(audio.destination); o.start(t); o.stop(t + ms / 1000);
+  };
+  const pitch = p => 16000 / (p + 8);
+
+  // how long each step takes to be seen or heard, in milliseconds
+  const PACE = { sound: 220, beep: 60, 'flash-box': 60, flash: 250, object: 30, 'object-keep': 30 };
+  let drawing = false, quick = false;
+  const sleep = ms => new Promise(r => setTimeout(r, ms));
+  async function runs() {
+    if (drawing) return;
+    drawing = true;
+    try {
+      for (;;) {
+        const r = engine.run();
+        hear();
+        // the original took time here, a disk's read or a wait it counted out: the screen as it
+        // is, for that long (card.js)
+        if (r === 'pace') {
+          for (const e of queue.splice(0)) { history.push(e); view.apply(e); }
+          view.prompts(); if (!quick && g.pace()) await sleep(engine.delay * g.pace()); engine.delay = 0;
+          continue;
+        }
+        engine.delay = 0;
+        while (queue.length) {
+          const e = queue.shift();
+          history.push(e);
+          view.apply(e);
+          if (quick) continue;   // (at full speed: no sound, no wait)
+          if (e.step === 'sound') { const [end, start] = e.words.split(' ').map(h => parseInt(h, 16)); tone(pitch(start), pitch(end), 180); }
+          if (e.step === 'beep') tone(pitch(e.a & 31) * 2, pitch(e.a & 31) * 2, 50);
+          if (!g.pace()) continue;   // (none of the original's waits: its sounds still)
+          if (PACE[e.step]) await sleep(PACE[e.step] * g.pace());
+          if (e.step === 'pause') await sleep(e.ms * g.pace());   // a delay the original counted out
+        }
+        view.prompts();
+        status.textContent = r === 'end' ? 'The end.' : 'Waiting for a key.';
+        if (!engine.keys.length || r === 'end') break;
+      }
+    } catch (err) { fail(err); }
+    drawing = false;
+  }
+
+  const press = k => { engine.press(k); audio?.resume(); speaker?.start(); if (!c64) runs(); };
+  // A game that goes on without waiting for keys, as Nature Park's truck: each turn of its loop is
+  // a step `tick`, which takes a key or none. A turn passes every 100 milliseconds, as the
+  // original's took, with the key pressed since the last or still held, as the Apple's keyboard
+  // told the game a key was down.
+  const ticking = () => engine.waitingOn?.words?.[0] === 'tick';
+  let held = null, tapped = null;
+  svg.addEventListener('click', e => { const key = e.target.closest('.key')?.dataset.key; if (key) press(+key); });
+
+  // A Commodore 64 title runs on the clock, as the original did, waiting for a key or not: a
+  // sixtieth of a second of the original's cycles at a time (the engine's run stops at each 16 ms of
+  // them), its raster and its interrupt at the time they come (card.js), and the screen
+  // painted after each. And the SID, its writes played a sixtieth of a second at a time, as the
+  // emulator plays a frame's (engines/original.js).
+  function clock() {
+    engine.sid = []; engine.clock = { irq: 0, ahead: [], since: 0 };
+    let sid = null, from = null, sent = 0, stopped = false;
+    status.textContent = 'Playing.';
+    setInterval(() => {
+      engine.delay -= 1000 / 60;   // a load's time, or the last run's
+      if (!stopped && !engine.ended && engine.delay < 16) {
+        engine.delay = Math.max(0, engine.delay);
+        // a key of ?keys when the game is waiting for one, two seconds at least after the last, as
+        // a player would press them (a wait the game counts out goes on by itself on the clock)
+        if (engine.clock.ahead.length && engine.idle > (engine.routines.polls ?? 200) && !engine.keys.length && ++engine.clock.since > 120) { engine.press(engine.clock.ahead.shift()); engine.clock.since = 0; }
+        try { engine.run(); queue.length = 0; view.prompts(); } catch (err) { stopped = true; fail(err); }
+        if (engine.ended) status.textContent = 'The end.';
+      }
+      if (speaker?.node && sounding) {
+        sid ??= new SID(speaker.rate); from ??= performance.now();
+        const n = Math.floor((performance.now() - from) / 1000 * speaker.rate) - sent;
+        if (n > 0) { const wave = sid.render(n, engine.sid.map(([, r, v]) => [0, r, v])); sent += n; speaker.node.port.postMessage(wave, [wave.buffer]); }
+      }
+      engine.sid.length = 0;
+    }, 1000 / 60);
+  }
+  setInterval(() => {
+    if (!ticking() || drawing || engine.keys.length) return;
+    const k = tapped ?? held ?? -1; tapped = null;
+    press(k);
+  }, 100);
+
+  return {
+    engine, press,
+    run() { svg.focus(); if (c64) clock(); else runs(); },
+    // the keys the player gives (play.js): a turn's key while the game ticks; a Commodore 64's held in its keyboard's
+    // matrix, which its KERNAL scans and repeats as long as it is held, as the original's did
+    // (@moonbase-machines/c64/kernal.js), a character typed only with shift into the buffer; else pressed
+    key(e, k) {
+      if (e.type === 'keyup') {
+        held = null;
+        const h = engine.clock?.held;
+        if (h?.key === e.key) { if (h.seen) engine.clock.held = null; else h.up = true; }
+        return;
+      }
+      if (k === undefined) return;
+      e.preventDefault();
+      if (ticking()) { tapped = held = k; return; }
+      const m = c64 && !e.ctrlKey && matrixOf(k);
+      if (m) { if (!e.repeat) { engine.clock.held = { ...m, key: e.key }; audio?.resume(); speaker?.start(); } return; }
+      if (!e.repeat) press(k);
+    },
+    // ?keys at the start: a Commodore 64's into the KERNAL's buffer on the clock, as a player would press them; else
+    // pressed
+    keys(list) { if (c64) engine.clock.ahead.push(...list); else for (const k of list) press(k); },
+    start() { audio?.resume(); speaker?.start(); },
+    sound(on) { sounding = on; },   // (the player's speaker: play.js)
+    quick(on) { quick = on; },
+    // A route the page gives (`route`, a workshop's pilots' route), played first as the pilots play it, each key when
+    // the game waits for one, off the clock, so that it goes where it went on both sides; then the game goes on as
+    // usual
+    route({ route, name, keys: { expand, give, petscii, pollsAt } }) {
+      title.seed = route.seed;   // (the random numbers from the route's seed, as the pilots have them)
+      if (route.printer && title.printer) { title.printer.on = true; const box = $('printer'); if (box) box.checked = true; }
+      status.textContent = 'Playing the route ' + name + '.';
+      // (on a Commodore 64 a key behind the one pressed goes into the KERNAL's buffer, as the pilots hold a key)
+      const side = { press: k => engine.press(k), also: k => { const m = engine.mem, put = v => { if (m[0xc6] < 10) { m[0x277 + m[0xc6]] = v; m[0xc6]++; } }; if (engine.keys.length) put(engine.keys.shift()); put(k); } };
+      const go = () => { let r; do { engine.delay = 0; r = engine.run(); } while (r === 'pace'); if (c64) queue.length = 0; else for (const e of queue.splice(0)) { history.push(e); view.apply(e); } };
+      go();
+      for (const [i, [k]] of expand(route.keys).entries()) { give(side, k, c64 ? petscii : undefined); engine.polls = pollsAt(route, i + 1) ?? undefined; go(); }
+      engine.polls = undefined; view.prompts();
+    },
+  };
+}

package/index.js

@@ -1,7 +1,14 @@
 // @moonbase-machines/player: every module by name, for one bundled file or to take the whole package at once:
-// import { remakeMain } from '@moonbase-machines/player'. Each module can be imported on its own too:
-// '@moonbase-machines/player/<module>.js' (remake/main.js, original.js, disk/disk.js).
-export * as original from './original.js';
+// import { play } from '@moonbase-machines/player', its modules each a namespace named by its path (play, diskDisk,
+// enginesOriginal). Each module can be imported on its own too: '@moonbase-machines/player/<module>.js' (play.js,
+// disk/disk.js).
+export * as play from './play.js';
+export * as keys from './keys.js';
+export * as saves from './saves.js';
+export * as settings from './settings.js';
+export * as provider from './provider.js';
+export * as enginesOriginal from './engines/original.js';
+export * as enginesScenes from './engines/scenes.js';
 export * as audio from './audio.js';
 export * as modal from './modal.js';
 export * as parts from './parts.js';
@@ -19,10 +26,8 @@ export * as remakeEvents from './remake/events.js';
 export * as remakeLayout from './remake/layout.js';
 export * as remakeLift from './remake/lift.js';
 export * as remakeLoad from './remake/load.js';
-export * as remakeMain from './remake/main.js';
 export * as remakeProblems from './remake/problems.js';
 export * as remakeRaster from './remake/raster.js';
-export * as remakeScenes from './remake/scenes.js';
 export * as remakeScript from './remake/script.js';
 export * as remakeVector from './remake/vector.js';
 export * as remakeView from './remake/view.js';

package/keys.js

@@ -0,0 +1,28 @@
+// The keys a page's keyboard gives, as the machine a game was made for takes them: the one table of each, for every
+// way to play (play.js reads them; an engine that reads the keyboard itself, a Commodore 64's matrix, Aztlan's menus'
+// shortcuts, is handed the event as well).
+//
+//   code(event, kind)     the key's code for the machine of that kind ('prodos', 'dos33' or 'c64'; none for a title
+//                         of its own engine), or undefined for a key it has none for
+//   named(name, kind)     a key by its name in a route or ?keys= (space, return, left...), as the machine's code
+
+// the Apple II's keyboard: the arrows as its control keys, DELETE, ESC, TAB
+const APPLE = { ArrowLeft: 8, ArrowRight: 21, ArrowDown: 10, ArrowUp: 11, Enter: 13, Backspace: 127, Delete: 127, Escape: 27, Tab: 9, ' ': 32 };
+// a Commodore 64's, in PETSCII: its cursor keys, DEL and RUN/STOP, and its letters capitals
+const C64 = { ArrowLeft: 157, ArrowRight: 29, ArrowDown: 17, ArrowUp: 145, Enter: 13, Backspace: 20, Delete: 20, Escape: 3, ' ': 32 };
+// the names a route's keys and ?keys= use, as the Apple's codes, and those a Commodore 64 has in their place
+const NAMES = { space: 32, return: 13, escape: 27, delete: 127, left: 8, right: 21, down: 10, up: 11, 'control-e': 5, 'control-t': 20, none: -1 };
+const PETSCII = { 8: 157, 21: 29, 10: 17, 11: 145, 127: 20, 27: 3 };
+
+export function code(e, kind) {
+  if (!kind || e.metaKey || e.altKey) return undefined;
+  const c64 = kind === 'c64';
+  // control with a letter is the machine's control character (control-E opens a vector title's main menu)
+  if (e.ctrlKey) return /^[a-z]$/i.test(e.key) ? e.key.toUpperCase().charCodeAt(0) & 0x1f : undefined;
+  return (c64 ? C64 : APPLE)[e.key] ?? (e.key.length === 1 ? (c64 ? e.key.toUpperCase() : e.key).charCodeAt(0) : undefined);
+}
+
+export function named(name, kind) {
+  const k = NAMES[name] ?? name.charCodeAt(0);
+  return kind === 'c64' ? PETSCII[k] ?? k : k;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moonbase-machines/player",
-  "version": "0.9.1",
+  "version": "0.11.0",
   "description": "The player for Mark Wharton's titles of 1985 to 1995: the Original, a game's own disk on Moonbase's machines, and the Remake, its scenes on an engine; the player's own disk of saves in the browser.",
   "type": "module",
   "license": "MIT",
@@ -14,11 +14,11 @@
     "moonbase-play": "./bin/moonbase-play.mjs"
   },
   "dependencies": {
-    "@moonbase-machines/apple2e": "0.9.1",
-    "@moonbase-machines/c64": "0.9.1",
-    "@moonbase-machines/charset": "0.9.1",
-    "@moonbase-machines/mos6502": "0.9.1",
-    "@moonbase-machines/vector": "0.9.1"
+    "@moonbase-machines/apple2e": "0.11.0",
+    "@moonbase-machines/c64": "0.11.0",
+    "@moonbase-machines/charset": "0.11.0",
+    "@moonbase-machines/mos6502": "0.11.0",
+    "@moonbase-machines/vector": "0.11.0"
   },
   "scripts": {
     "test": "node --test test/*.test.js",