@moonbase-machines/player 0.9.0 → 0.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moonbase-machines/player",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "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.0",
-    "@moonbase-machines/c64": "0.9.0",
-    "@moonbase-machines/charset": "0.9.0",
-    "@moonbase-machines/mos6502": "0.9.0",
-    "@moonbase-machines/vector": "0.9.0"
+    "@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"
   },
   "scripts": {
     "test": "node --test test/*.test.js",

package/remake/card.js

@@ -139,7 +139,8 @@ export function cardRoutines(title) {
     if (!f && c64 && at >= 0xa000 && at < 0xc000) throw new Error('a BASIC program (Zoopak\'s NOTEBOOK or ZOOTIME): not written yet in the remake');
     if (!f) throw new Error('no ROM routine at $' + hex4(at));
     engine = e;
-    Object.assign(cpu, { a: e.a, x: e.x, y: e.y, c: e.c, z: e.z, n: e.n, v: e.v });
+    // (the stack pointer as the call to the routine left it: the frames' place, less the call's two bytes)
+    Object.assign(cpu, { a: e.a, x: e.x, y: e.y, c: e.c, z: e.z, n: e.n, v: e.v, pc: at, sp: e.sp() - 2 & 0xff });
     // a routine that reads the keyboard (RDKEY) waits, with no key, and the step runs again
     const start = romFrom = cpu.cycles;
     const r = f(cpu);
@@ -150,6 +151,9 @@ export function cardRoutines(title) {
     e.delay += (cpu.cycles - start + 6) / CLOCK * 1000; e.cycles += cpu.cycles - start + 6;
     Object.assign(e, { a: cpu.a & 0xff, x: cpu.x & 0xff, y: cpu.y & 0xff, c: cpu.c, z: cpu.z, n: cpu.n });
     if (r === 'return') return r;   // (a routine that returns from its caller too: $E206 at a statement's end)
+    // a routine that goes on elsewhere, not back: DOS 3.3's error exit, from a command printed through COUT, to where
+    // DOS goes on (rom.js `dosError`)
+    if (r === false && cpu.pc !== at) return { to: cpu.pc };
   };
 
   // Where an address of the lifted code is: a label in a script. The scenes all run at $AD00,
@@ -199,10 +203,11 @@ export function cardRoutines(title) {
     return [name, 'L' + hex4(at)];
   };
   // an address the ROM's routine answers: above $D000, unless the card is read there and a script
-  // has its code there (Pieces of Eight's PO8:BLINK, over HPOSN and DRAW); on a Commodore 64, where
+  // has its code there (Pieces of Eight's PO8:BLINK, over HPOSN and DRAW), or below where rom.js answers DOS's own
+  // (INITIOHK, $A851) and no script has code; on a Commodore 64, where
   // the 6510's port shows the KERNAL ($E000 on) or BASIC ($A000 to $BFFF: Tell-A-Tale's numbers,
   // over MENU's code in the RAM under it)
-  const romAt = (e, a) => c64 ? (a >= 0xe000 ? (e.mem[1] & 2) !== 0 : a >= 0xa000 && a < 0xc000 ? (e.mem[1] & 3) === 3 : a === 0x73 || a === 0x79) : a >= 0xd000 && !(lc.read && labelled(e, a).length);
+  const romAt = (e, a) => c64 ? (a >= 0xe000 ? (e.mem[1] & 2) !== 0 : a >= 0xa000 && a < 0xc000 ? (e.mem[1] & 3) === 3 : a === 0x73 || a === 0x79) : a >= 0xd000 ? !(lc.read && labelled(e, a).length) : cpu.hooks.has(a) && !labelled(e, a).length;
   // the stir of START.SYSTEM's wait: its calls are no steps
   const stirring = step => toolkit.stir && step?.at >= toolkit.stir.from && step.at <= toolkit.stir.to;
   const emit = (e, ev, quiet) => { if (quiet) e.inside++; e.emit(ev); if (quiet) e.inside--; };
@@ -235,7 +240,16 @@ export function cardRoutines(title) {
     inputs(e, name, args); emit(e, unplaced(describe(name, [], e, undefined, undefined, a => e.mem[a])), stirring(step));
     const v = c64 && VECTORED[name], to = v && (e.mem[v[0]] | e.mem[v[0] + 1] << 8);
     if (v && to !== v[1]) { const [script, label] = find(e, to); e.callInside(script, label, x => { if (GIVES[name]) x.emit(result(name, { a: x.a, x: x.x, y: x.y, c: x.c })); }, step?.at == null ? undefined : (step.at + 2) & 0xffff); return; }
-    if (rom(e, at) === 'wait') return 'wait';
+    const r = rom(e, at);
+    if (r === 'wait') return 'wait';
+    // (gone on elsewhere: the code there run inside the step, the routine's return still on the stack, as the
+    // original's is, until that code drops it, as Pieces of Eight's handler ($93F0) does with a TXS to the frames
+    // under it, kept at their place for it (Engine.stackPage))
+    if (r?.to !== undefined) {
+      e.stackPage();
+      e.stack.push({ name: e.name, pc: e.pc, inside: true, ret: step?.at == null ? undefined : (step.at + 2) & 0xffff }); e.inside++;
+      return routines['goto-engine'](e, ['$' + hex4(r.to)], step);
+    }
     if (GIVES[name] && c64) e.emit(result(name, { a: e.a, x: e.x, y: e.y, c: e.c }));
   };
 
@@ -301,6 +315,8 @@ export function cardRoutines(title) {
         if (c64 && ENDS.has(a)) pullRegisters(e);   // the end of an interrupt: the registers back, then its RTI
         back(e); return;   // as its RTS: out of a routine it ends
       }
+      // (code the game has written since, a JMP: on through it, as Pieces of Eight's at $A6D8, into DOS's error exit)
+      if (!c64 && e.mem[a] === 0x4c && !labelled(e, a).length) return routines['goto-engine'](e, ['$' + hex4(e.mem[a + 1] | e.mem[a + 2] << 8)], step);
       e.enter(...find(e, a));
     },
   };

package/remake/engine.js

@@ -324,19 +324,32 @@ export class Engine {
     }
     const f = this.stack.pop(); if (a) this.a = this.flags(f.a); else [this.n, this.z, this.c, this.v] = f.flags;
   }
-  // the machine's own instructions a scene keeps. TSX gives the stack's place, as the
-  // original's stack pointer would be with these frames on it, and keeps the frames under
-  // it; TXS goes back to the frames kept at the place it is given (Detect-A-Pet's save and
+  // the stack's place, as the original's stack pointer would be with these frames on it: each
+  // frame its bytes, a call's two (its return address) and a push's one
+  sp() { return 0xff - this.stack.reduce((n, f) => n + (f.name === undefined ? 1 : f.half ? 1 : 2), 0) & 0xff; }
+  // the frames kept at their place, for a TXS to go back to, and their bytes in the stack page as
+  // the original's are there: a call's return address, high byte first from the bottom, as JSR
+  // pushes it (half of one pulled, its high byte), and a push's byte, PHP's as the 6502's (Pieces of Eight's DOS error
+  // handler, $93F0, reads the return address under its own to see who called)
+  stackPage() {
+    const sp = this.sp();
+    (this.stacks ??= new Map()).set(sp, this.stack.map(f => ({ ...f })));
+    let at = 0xff;
+    for (const f of this.stack) {
+      const r = f.ret ?? 0;
+      if (f.name === undefined) this.mem[0x100 + at--] = f.a ?? (f.flags ? f.flags[0] << 7 | f.flags[3] << 6 | 0x30 | f.flags[1] << 1 | f.flags[2] : 0);
+      else { this.mem[0x100 + at--] = r >> 8; if (!f.half) this.mem[0x100 + at--] = r & 0xff; }
+    }
+    return sp;
+  }
+  // the machine's own instructions a scene keeps. TSX gives the stack's place (`stackPage`); TXS
+  // goes back to the frames kept at the place it is given (Detect-A-Pet's save and
   // load keep the stack page and its pointer), and to none at any other, as the town's
   // resets the stack and drops every script called. SED and CLD set decimal mode, and SEI and
   // CLI the mask a Commodore 64's interrupt waits on (card.js). The rest (a byte that
   // is no instruction) change nothing the remake holds.
   asm(op) {
-    if (op === 'TSX') {
-      const sp = 0xff - this.stack.reduce((n, f) => n + (f.name === undefined ? 1 : f.half ? 1 : 2), 0) & 0xff;
-      (this.stacks ??= new Map()).set(sp, this.stack.map(f => ({ ...f })));
-      this.x = this.flags(sp);
-    }
+    if (op === 'TSX') this.x = this.flags(this.stackPage());
     if (op === 'TXS') {
       const kept = this.stacks?.get(this.x);
       this.stack = kept ? kept.map(f => ({ ...f })) : []; this.visited = null; this.inside = this.stack.filter(f => f.inside).length;