jsbeeb 1.7.0 → 1.9.0

package/package.json

@@ -7,7 +7,7 @@
   "name": "jsbeeb",
   "description": "Emulate a BBC Micro",
   "repository": "git@github.com:mattgodbolt/jsbeeb.git",
-  "version": "1.7.0",
+  "version": "1.9.0",
   "//": "If you change the version of Node, it must also be updated at the top of the Dockerfile.",
   "engines": {
     "node": "22"

package/src/6502.js

@@ -1131,7 +1131,7 @@ export class Cpu6502 extends Base6502 {
         this.resetLine = !resetOn;
     }
 
-    snapshotState() {
+    snapshotState({ includeRoms = false } = {}) {
         return {
             // CPU registers
             a: this.a,
@@ -1155,8 +1155,10 @@ export class Cpu6502 extends Base6502 {
             peripheralCycles: this.peripheralCycles,
             videoCycles: this.videoCycles,
             music5000PageSel: this.music5000PageSel,
-            // RAM only (ROMs don't change at runtime)
+            // RAM only by default; pass includeRoms:true to also capture
+            // sideways ROM/RAM slots (adds ~256KB to the snapshot).
             ram: this.ramRomOs.slice(0, this.romOffset),
+            roms: includeRoms ? this.ramRomOs.slice(this.romOffset, this.romOffset + 16 * 16384) : undefined,
             // Sub-component state
             scheduler: this.scheduler.snapshotState(),
             sysvia: this.sysvia.snapshotState(),

package/src/disc.js

@@ -535,7 +535,10 @@ export function loadSsd(disc, data, isDsd, onChange) {
     const blankSector = new Uint8Array(SsdFormat.sectorSize);
     const numSides = isDsd ? 2 : 1;
     if (data.length % SsdFormat.sectorSize !== 0) {
-        throw new Error("SSD file size is not a multiple of sector size");
+        const paddedLength = Math.ceil(data.length / SsdFormat.sectorSize) * SsdFormat.sectorSize;
+        const padded = new Uint8Array(paddedLength);
+        padded.set(data);
+        data = padded;
     }
     const maxSize = SsdFormat.sectorSize * SsdFormat.sectorsPerTrack * SsdFormat.tracksPerDisc * numSides;
     if (data.length > maxSize) {

package/src/utils.js

@@ -437,6 +437,14 @@ export function getKeyMap(keyLayout) {
     // shift not pressed
     keys2[false] = {};
 
+    // Create a key map entry that overrides the BBC SHIFT state while held.
+    // Used in natural keyboard for keys where the PC and BBC shift states
+    // differ for the same character (e.g. US Shift+6 = ^ needs BBC HAT_TILDE
+    // without shift, even though the physical shift key is held).
+    function withShiftOverride(bbcKey, bbcShift) {
+        return [bbcKey[0], bbcKey[1], bbcShift];
+    }
+
     // shiftDown MUST be true or false (not undefined)
     function doMap(s, colRow, shiftDown) {
         if (keys2[shiftDown][s] && keys2[shiftDown][s] !== colRow) {
@@ -554,7 +562,8 @@ export function getKeyMap(keyLayout) {
         map(keyCodes.K1, BBC.K1);
         map(keyCodes.K4, BBC.K4);
         map(keyCodes.K5, BBC.K5);
-        map(keyCodes.K6, BBC.K6);
+        map(keyCodes.K6, BBC.K6, false);
+        map(keyCodes.K6, withShiftOverride(BBC.HAT_TILDE, false), true);
 
         map(keyCodes.MINUS, BBC.MINUS);
 

package/src/via.js

@@ -541,6 +541,9 @@ export class SysVia extends Via {
         this.mouseButton1 = false;
         this.mouseButton2 = false;
         this.keyboardEnabled = true;
+        this._physicalShiftDown = false;
+        this._shiftOverrideActive = false;
+        this._shiftOverrideDesiredShift = false;
         this.setKeyLayout(initialLayout);
         this.video = video;
         this.soundChip = soundChip;
@@ -589,6 +592,9 @@ export class SysVia extends Via {
                 this.keys[i][j] = false;
             }
         }
+        this._physicalShiftDown = false;
+        this._shiftOverrideActive = false;
+        this._shiftOverrideDesiredShift = false;
         this.updateKeys();
     }
 
@@ -604,9 +610,34 @@ export class SysVia extends Via {
 
     set(key, val, shiftDown) {
         if (!this.keyboardEnabled) return;
-        const colrow = this.keycodeToRowCol[!!shiftDown][key];
-        if (!colrow) return;
-        this.keys[colrow[0]][colrow[1]] = val;
+        const mapping = this.keycodeToRowCol[!!shiftDown][key];
+        if (!mapping) return;
+
+        const [col, row, bbcShiftOverride] = mapping;
+        const [shiftCol, shiftRow] = utils.BBC.SHIFT;
+
+        this.keys[col][row] = val;
+
+        const isPhysicalShiftKey = col === shiftCol && row === shiftRow && bbcShiftOverride === undefined;
+
+        if (isPhysicalShiftKey) {
+            this._physicalShiftDown = !!val;
+        }
+
+        if (bbcShiftOverride !== undefined) {
+            this._shiftOverrideActive = !!val;
+            this._shiftOverrideDesiredShift = bbcShiftOverride;
+        }
+
+        // When a shift override is active, force BBC SHIFT to the desired
+        // state; otherwise follow the physical shift key.
+        // Note: keyDownRaw/keyUpRaw bypass this logic intentionally as they
+        // are used by gamepad/paste code that manages shift independently.
+        if (this._shiftOverrideActive || isPhysicalShiftKey || bbcShiftOverride !== undefined) {
+            const shiftPressed = this._shiftOverrideActive ? this._shiftOverrideDesiredShift : this._physicalShiftDown;
+            this.keys[shiftCol][shiftRow] = shiftPressed ? 1 : 0;
+        }
+
         this.updateKeys();
     }
 
@@ -765,10 +796,11 @@ export class SysVia extends Via {
             const pad2 = pads[1];
 
             // Combine gamepad and mouse button states (OR logic)
-            button1 = button1 || pad.buttons[10].pressed;
-            // if two gamepads, use button from 2nd
-            // otherwise use 2nd button from first
-            button2 = button2 || (pad2 ? pad2.buttons[10].pressed : pad.buttons[11].pressed);
+            button1 = button1 || !!pad.buttons[10]?.pressed;
+            // FIRE2 on first gamepad always maps to button2
+            button2 = button2 || !!pad.buttons[11]?.pressed;
+            // If two gamepads, FIRE1 on second gamepad also maps to button2
+            if (pad2) button2 = button2 || !!pad2.buttons[10]?.pressed;
         }
 
         return { button1: button1, button2: button2 };

package/tests/test-machine.js

@@ -11,12 +11,60 @@ export class TestMachine {
     constructor(model, opts) {
         model = model || "B-DFS1.2";
         this.processor = fake6502(findModel(model), opts || {});
+        this._capturedChars = [];
+        this._captureHookInstalled = false;
     }
 
     async initialise() {
         await this.processor.initialise();
     }
 
+    /**
+     * Install the character capture hook (once). All characters sent
+     * through WRCHV are accumulated and can be read with drainText().
+     * Safe to call multiple times — only installs one hook.
+     */
+    startCapture() {
+        if (this._captureHookInstalled) return;
+        this._captureHookInstalled = true;
+        this.processor.debugInstruction.add((addr) => {
+            const wrchv = this.readword(0x20e);
+            if (addr === wrchv) {
+                this._capturedChars.push(this.processor.a);
+            }
+            return false;
+        });
+    }
+
+    /**
+     * Return all captured characters since the last drain (or since
+     * startCapture was called), then clear the buffer.
+     * @returns {number[]} array of character codes
+     */
+    drainCapturedChars() {
+        const chars = this._capturedChars;
+        this._capturedChars = [];
+        return chars;
+    }
+
+    /**
+     * Return captured text as a string (printable chars only, with
+     * optional newline preservation), then clear the buffer.
+     * @param {Object} [opts]
+     * @param {boolean} [opts.raw=false] - if true, preserve newlines
+     */
+    drainText({ raw = false } = {}) {
+        const chars = this.drainCapturedChars();
+        return chars
+            .map((c) => {
+                if (raw && c === 10) return "\n";
+                if (c === 13) return "";
+                if (c >= 0x20 && c < 0x7f) return String.fromCharCode(c);
+                return "";
+            })
+            .join("");
+    }
+
     runFor(cycles) {
         let left = cycles;
         let stopped = false;
@@ -102,6 +150,39 @@ export class TestMachine {
         this.processor.fdc.loadDisc(0, fdc.discFor(this.processor.fdc, "", data));
     }
 
+    /**
+     * Load a disc image from raw data (Uint8Array or Buffer).
+     * @param {Uint8Array|Buffer} data - raw disc image bytes
+     */
+    loadDiscData(data) {
+        this.processor.fdc.loadDisc(0, fdc.discFor(this.processor.fdc, "", data));
+    }
+
+    /**
+     * Reset the machine.
+     * @param {boolean} hard - true for power-on reset, false for soft reset
+     */
+    reset(hard) {
+        this.processor.reset(hard);
+    }
+
+    /**
+     * Take a snapshot of the entire machine state (CPU, RAM, SWRAM,
+     * VIAs, video, FDC, etc). Returns an opaque state object that
+     * can be passed to restore().
+     */
+    snapshot({ includeRoms = true } = {}) {
+        return this.processor.snapshotState({ includeRoms });
+    }
+
+    /**
+     * Restore a previously saved snapshot. The machine will be in
+     * exactly the state it was when snapshot() was called.
+     */
+    restore(state) {
+        this.processor.restoreState(state);
+    }
+
     async loadBasic(source) {
         const tokeniser = await Tokeniser.create();
         const tokenised = tokeniser.tokenise(source);
@@ -186,8 +267,19 @@ export class TestMachine {
                 return { code: utils.keyCodes.K4, shift: true };
             case "%":
                 return { code: utils.keyCodes.K5, shift: true };
-            default:
-                return { code: ch.toUpperCase().charCodeAt(0), shift: false };
+            default: {
+                const upper = ch.toUpperCase();
+                const isLetter = (ch >= "a" && ch <= "z") || (ch >= "A" && ch <= "Z");
+                if (isLetter) {
+                    const wantUpper = ch >= "A" && ch <= "Z";
+                    const capsOn = this.processor.sysvia.capsLockLight;
+                    // CAPS LOCK on: unshifted = upper, shifted = lower
+                    // CAPS LOCK off: unshifted = lower, shifted = upper
+                    const needShift = capsOn ? !wantUpper : wantUpper;
+                    return { code: upper.charCodeAt(0), shift: needShift };
+                }
+                return { code: ch.charCodeAt(0), shift: false };
+            }
         }
     }
 
@@ -201,7 +293,7 @@ export class TestMachine {
     async type(text) {
         const fullText = text + "\n"; // append RETURN
         const keys = fullText.split("").map((ch) => this._charToKey(ch));
-        const holdCycles = 40000; // cycles between key events, matching old type() timing
+        const holdCycles = 40000;
         let index = 0;
         let phase = "idle"; // "idle" → "down" → "idle"
         let nextEventCycle = 0;
@@ -246,6 +338,34 @@ export class TestMachine {
         }
     }
 
+    /**
+     * Press a key on the BBC keyboard.
+     * @param {number} code - BBC key code (e.g. utils.keyCodes.SPACE)
+     */
+    keyDown(code) {
+        this.processor.sysvia.keyDown(code);
+    }
+
+    /**
+     * Release a key on the BBC keyboard.
+     * @param {number} code - BBC key code
+     */
+    keyUp(code) {
+        this.processor.sysvia.keyUp(code);
+    }
+
+    /**
+     * Load a ROM image directly into a sideways RAM slot.
+     * @param {number} slot - slot number (0-15, typically 4-7 for SWRAM)
+     * @param {Uint8Array|Buffer} data - ROM data (up to 16384 bytes)
+     */
+    loadSidewaysRam(slot, data) {
+        const offset = this.processor.romOffset + slot * 16384;
+        for (let i = 0; i < data.length && i < 16384; i++) {
+            this.processor.ramRomOs[offset + i] = data[i];
+        }
+    }
+
     writebyte(addr, val) {
         this.processor.writemem(addr, val);
     }