Auto-load using typing into the emulator (should work better)

Author: stever

packages/emulator/src/Emulator.js

@@ -65,6 +65,7 @@ export class Emulator extends EventEmitter {
                     break;
                 case 'frameCompleted':
                     // benchmarkRunCount++;
+                    this.advanceAutoType();
                     if ('audioBufferLeft' in e.data) {
                         this.audioHandler.frameCompleted(e.data.audioBufferLeft, e.data.audioBufferRight);
                     }
@@ -86,12 +87,24 @@ export class Emulator extends EventEmitter {
                     break;
                 case 'fileOpened':
                     if (e.data.mediaType == 'tape' && this.autoLoadTapes) {
-                        const TAPE_LOADERS_BY_MACHINE = {
-                            '48': {'default': '../tapeloaders/tape_48.szx', 'usr0': '../tapeloaders/tape_48.szx'},
-                            '128': {'default': '../tapeloaders/tape_128.szx', 'usr0': '../tapeloaders/tape_128_usr0.szx'},
-                            '5': {'default': '../tapeloaders/tape_pentagon.szx', 'usr0': '../tapeloaders/tape_pentagon_usr0.szx'},
-                        };
-                        this.openUrl(new URL(TAPE_LOADERS_BY_MACHINE[this.machineType][this.tapeAutoLoadMode], scriptUrl));
+                        if (this.machineType == 48) {
+                            /* 48K boots to BASIC, so cold-boot and type LOAD ""
+                               ourselves. The tapeloader snapshots park the machine
+                               in a captured state that breaks some games' loaders
+                               (e.g. report 5 "Out of screen"); a cold boot matches a
+                               real load. */
+                            this.reset();
+                            this.beginAutoTypeLoad();
+                        } else {
+                            /* 128K/Pentagon boot to a menu where a typed LOAD ""
+                               wouldn't apply, so drive them via the per-machine
+                               tapeloader snapshot. */
+                            const TAPE_LOADERS_BY_MACHINE = {
+                                '128': {'default': '../tapeloaders/tape_128.szx', 'usr0': '../tapeloaders/tape_128_usr0.szx'},
+                                '5': {'default': '../tapeloaders/tape_pentagon.szx', 'usr0': '../tapeloaders/tape_pentagon_usr0.szx'},
+                            };
+                            this.openUrl(new URL(TAPE_LOADERS_BY_MACHINE[this.machineType][this.tapeAutoLoadMode], scriptUrl));
+                        }
                         if (!this.tapeTrapsEnabled) {
                             this.playTape();
                         }
@@ -214,6 +227,48 @@ export class Emulator extends EventEmitter {
         this.worker.postMessage({message: 'reset'});
     }
 
+    /* Cold-boot autoload for 48K: type LOAD "" + ENTER by injecting the matrix
+       keypresses. Driven off completed emulator frames (not wall-clock time), so
+       the keystrokes only advance while the CPU is actually executing - they wait
+       for the machine to start and the ROM to boot rather than guessing. Tune the
+       frame counts if the keystrokes land before the ROM is ready or get merged. */
+    beginAutoTypeLoad() {
+        const BOOT_FRAMES = 120;  // ~2.4s of execution for the ROM to reach the input loop
+        const HOLD_FRAMES = 5;    // frames each key/chord is held down
+        const GAP_FRAMES = 5;     // frames between keystrokes so the ROM debounces
+
+        const SYMBOL_SHIFT = {row: 7, mask: 0x02};
+        const P = {row: 5, mask: 0x01};
+        const J = {row: 6, mask: 0x08};
+        const ENTER = {row: 6, mask: 0x01};
+
+        /* LOAD "" : J = the LOAD keyword, " = symbol-shift + P (x2), then ENTER */
+        const chords = [[J], [SYMBOL_SHIFT, P], [SYMBOL_SHIFT, P], [ENTER]];
+
+        const actions = [];
+        let frame = BOOT_FRAMES;
+        for (const chord of chords) {
+            actions.push({frame, message: 'keyDown', keys: chord});
+            frame += HOLD_FRAMES;
+            actions.push({frame, message: 'keyUp', keys: chord});
+            frame += GAP_FRAMES;
+        }
+        this.autoTypeActions = actions;
+        this.autoTypeFrame = 0;
+    }
+
+    advanceAutoType() {
+        if (!this.autoTypeActions) return;
+        this.autoTypeFrame++;
+        while (this.autoTypeActions.length && this.autoTypeActions[0].frame <= this.autoTypeFrame) {
+            const action = this.autoTypeActions.shift();
+            for (const k of action.keys) {
+                this.worker.postMessage({message: action.message, row: k.row, mask: k.mask});
+            }
+        }
+        if (!this.autoTypeActions.length) this.autoTypeActions = null;
+    }
+
     loadSnapshot(snapshot) {
         const fileID = this.nextFileOpenID++;
         this.worker.postMessage({