jsbeeb 1.5.0 → 1.6.0

package/src/teletext.js

@@ -150,6 +150,75 @@ export class Teletext {
         }
     }
 
+    snapshotState() {
+        // Encode glyph table references as strings for serialization
+        let nextGlyphsName, curGlyphsName, heldGlyphsName;
+        for (const [name, table] of [
+            ["normal", this.normalGlyphs],
+            ["graphics", this.graphicsGlyphs],
+            ["separated", this.separatedGlyphs],
+        ]) {
+            if (this.nextGlyphs === table) nextGlyphsName = name;
+            if (this.curGlyphs === table) curGlyphsName = name;
+            if (this.heldGlyphs === table) heldGlyphsName = name;
+        }
+        return {
+            prevCol: this.prevCol,
+            col: this.col,
+            bg: this.bg,
+            sep: this.sep,
+            dbl: this.dbl,
+            oldDbl: this.oldDbl,
+            secondHalfOfDouble: this.secondHalfOfDouble,
+            wasDbl: this.wasDbl,
+            gfx: this.gfx,
+            flash: this.flash,
+            flashOn: this.flashOn,
+            flashTime: this.flashTime,
+            heldChar: this.heldChar,
+            holdChar: this.holdChar,
+            dataQueue: [...this.dataQueue],
+            scanlineCounter: this.scanlineCounter,
+            levelDEW: this.levelDEW,
+            levelDISPTMG: this.levelDISPTMG,
+            levelRA0: this.levelRA0,
+            nextGlyphs: nextGlyphsName,
+            curGlyphs: curGlyphsName,
+            heldGlyphs: heldGlyphsName,
+        };
+    }
+
+    restoreState(state) {
+        this.prevCol = state.prevCol;
+        this.col = state.col;
+        this.bg = state.bg;
+        this.sep = state.sep;
+        this.dbl = state.dbl;
+        this.oldDbl = state.oldDbl;
+        this.secondHalfOfDouble = state.secondHalfOfDouble;
+        this.wasDbl = state.wasDbl;
+        this.gfx = state.gfx;
+        this.flash = state.flash;
+        this.flashOn = state.flashOn;
+        this.flashTime = state.flashTime;
+        this.heldChar = state.heldChar;
+        this.holdChar = state.holdChar;
+        this.dataQueue = [...state.dataQueue];
+        this.scanlineCounter = state.scanlineCounter;
+        this.levelDEW = state.levelDEW;
+        this.levelDISPTMG = state.levelDISPTMG;
+        this.levelRA0 = state.levelRA0;
+
+        const glyphMap = {
+            normal: this.normalGlyphs,
+            graphics: this.graphicsGlyphs,
+            separated: this.separatedGlyphs,
+        };
+        this.nextGlyphs = glyphMap[state.nextGlyphs] || this.normalGlyphs;
+        this.curGlyphs = glyphMap[state.curGlyphs] || this.normalGlyphs;
+        this.heldGlyphs = glyphMap[state.heldGlyphs] || this.normalGlyphs;
+    }
+
     setNextChars() {
         if (this.gfx) {
             if (this.sep) {

package/src/via.js

@@ -402,6 +402,73 @@ class Via {
         this.portBUpdated();
     }
 
+    snapshotState() {
+        return {
+            ora: this.ora,
+            orb: this.orb,
+            ira: this.ira,
+            irb: this.irb,
+            ddra: this.ddra,
+            ddrb: this.ddrb,
+            sr: this.sr,
+            t1l: this.t1l,
+            t2l: this.t2l,
+            t1c: this.t1c,
+            t2c: this.t2c,
+            acr: this.acr,
+            pcr: this.pcr,
+            ifr: this.ifr,
+            ier: this.ier,
+            t1hit: this.t1hit,
+            t2hit: this.t2hit,
+            portapins: this.portapins,
+            portbpins: this.portbpins,
+            ca1: this.ca1,
+            ca2: this.ca2,
+            cb1: this.cb1,
+            cb2: this.cb2,
+            justhit: this.justhit,
+            t1_pb7: this.t1_pb7,
+            lastPolltime: this.lastPolltime,
+            taskOffset: this.task.scheduled() ? this.task.expireEpoch - this.scheduler.epoch : null,
+        };
+    }
+
+    restoreState(state) {
+        this.ora = state.ora;
+        this.orb = state.orb;
+        this.ira = state.ira;
+        this.irb = state.irb;
+        this.ddra = state.ddra;
+        this.ddrb = state.ddrb;
+        this.sr = state.sr;
+        this.t1l = state.t1l;
+        this.t2l = state.t2l;
+        this.t1c = state.t1c;
+        this.t2c = state.t2c;
+        this.acr = state.acr;
+        this.pcr = state.pcr;
+        this.ifr = state.ifr;
+        this.ier = state.ier;
+        this.t1hit = state.t1hit;
+        this.t2hit = state.t2hit;
+        this.portapins = state.portapins;
+        this.portbpins = state.portbpins;
+        this.ca1 = state.ca1;
+        this.ca2 = state.ca2;
+        this.cb1 = state.cb1;
+        this.cb2 = state.cb2;
+        this.justhit = state.justhit;
+        this.t1_pb7 = state.t1_pb7;
+        this.lastPolltime = state.lastPolltime;
+        this.updateIFR();
+        if (state.taskOffset !== null) {
+            this.task.reschedule(state.taskOffset);
+        } else {
+            this.task.cancel();
+        }
+    }
+
     setca1(level) {
         if (level === this.ca1) return;
         const pcrSet = !!(this.pcr & 1);
@@ -484,6 +551,30 @@ export class SysVia extends Via {
         this.reset();
     }
 
+    snapshotState() {
+        return {
+            ...super.snapshotState(),
+            IC32: this.IC32,
+            capsLockLight: this.capsLockLight,
+            shiftLockLight: this.shiftLockLight,
+        };
+    }
+
+    restoreState(state) {
+        super.restoreState(state);
+        this.IC32 = state.IC32;
+        this.capsLockLight = state.capsLockLight;
+        this.shiftLockLight = state.shiftLockLight;
+        // Re-apply IC32 side effects (sound chip data bus, CMOS, port A)
+        // Must call portBUpdated directly (not recalculatePortBPins which
+        // overwrites IC32 based on portbpins) and then re-set IC32.
+        this.portBUpdated();
+        this.IC32 = state.IC32;
+        this.capsLockLight = state.capsLockLight;
+        this.shiftLockLight = state.shiftLockLight;
+        this.recalculatePortAPins();
+    }
+
     setKeyLayout(map) {
         this.keycodeToRowCol = utils.getKeyMap(map);
     }

package/src/video.js

@@ -82,6 +82,36 @@ class Ula {
         }
     }
 
+    snapshotState() {
+        return {
+            collook: this.collook.slice(),
+            flash: this.flash.slice(),
+            paletteWriteFlag: this.paletteWriteFlag,
+            paletteFirstByte: this.paletteFirstByte,
+            paletteMode: this.paletteMode,
+            horizontalOffset: this.horizontalOffset,
+            leftBlank: this.leftBlank,
+            disabled: this.disabled,
+            attributeMode: this.attributeMode,
+            attributeText: this.attributeText,
+        };
+    }
+
+    restoreState(state) {
+        this.collook.set(state.collook);
+        this.flash.set(state.flash);
+        this.paletteWriteFlag = state.paletteWriteFlag;
+        this.paletteFirstByte = state.paletteFirstByte;
+        this.paletteMode = state.paletteMode;
+        this.horizontalOffset = state.horizontalOffset;
+        this.leftBlank = state.leftBlank;
+        this.disabled = state.disabled;
+        this.attributeMode = state.attributeMode;
+        this.attributeText = state.attributeText;
+        this._recomputeUlaPal(!!(this.video.ulactrl & 1));
+        this.video.teletext.rebuildColours(this.collook);
+    }
+
     // ULA control register (&FE20).
     _writeControl(val) {
         if ((this.video.ulactrl ^ val) & 1) {
@@ -208,6 +238,14 @@ class Crtc {
         ]);
     }
 
+    snapshotState() {
+        return { curReg: this.curReg };
+    }
+
+    restoreState(state) {
+        this.curReg = state.curReg;
+    }
+
     read(addr) {
         if (!(addr & 1)) return 0;
         switch (this.curReg) {
@@ -389,6 +427,111 @@ export class Video {
         this.paint();
     }
 
+    snapshotState() {
+        return {
+            regs: this.regs.slice(),
+            bitmapX: this.bitmapX,
+            bitmapY: this.bitmapY,
+            oddClock: this.oddClock,
+            frameCount: this.frameCount,
+            doEvenFrameLogic: this.doEvenFrameLogic,
+            isEvenRender: this.isEvenRender,
+            lastRenderWasEven: this.lastRenderWasEven,
+            firstScanline: this.firstScanline,
+            inHSync: this.inHSync,
+            inVSync: this.inVSync,
+            hadVSyncThisRow: this.hadVSyncThisRow,
+            checkVertAdjust: this.checkVertAdjust,
+            endOfMainLatched: this.endOfMainLatched,
+            endOfVertAdjustLatched: this.endOfVertAdjustLatched,
+            endOfFrameLatched: this.endOfFrameLatched,
+            inVertAdjust: this.inVertAdjust,
+            inDummyRaster: this.inDummyRaster,
+            hpulseWidth: this.hpulseWidth,
+            vpulseWidth: this.vpulseWidth,
+            hpulseCounter: this.hpulseCounter,
+            vpulseCounter: this.vpulseCounter,
+            dispEnabled: this.dispEnabled,
+            horizCounter: this.horizCounter,
+            vertCounter: this.vertCounter,
+            scanlineCounter: this.scanlineCounter,
+            vertAdjustCounter: this.vertAdjustCounter,
+            addr: this.addr,
+            lineStartAddr: this.lineStartAddr,
+            nextLineStartAddr: this.nextLineStartAddr,
+            ulactrl: this.ulactrl,
+            pixelsPerChar: this.pixelsPerChar,
+            halfClock: this.halfClock,
+            ulaMode: this.ulaMode,
+            teletextMode: this.teletextMode,
+            displayEnableSkew: this.displayEnableSkew,
+            ulaPal: this.ulaPal.slice(),
+            actualPal: this.actualPal.slice(),
+            cursorOn: this.cursorOn,
+            cursorOff: this.cursorOff,
+            cursorOnThisFrame: this.cursorOnThisFrame,
+            cursorDrawIndex: this.cursorDrawIndex,
+            cursorPos: this.cursorPos,
+            interlacedSyncAndVideo: this.interlacedSyncAndVideo,
+            screenSubtract: this.screenSubtract,
+            ula: this.ula.snapshotState(),
+            crtc: this.crtc.snapshotState(),
+            teletext: this.teletext.snapshotState(),
+        };
+    }
+
+    restoreState(state) {
+        this.regs.set(state.regs);
+        this.bitmapX = state.bitmapX;
+        this.bitmapY = state.bitmapY;
+        this.oddClock = state.oddClock;
+        this.frameCount = state.frameCount;
+        this.doEvenFrameLogic = state.doEvenFrameLogic;
+        this.isEvenRender = state.isEvenRender;
+        this.lastRenderWasEven = state.lastRenderWasEven;
+        this.firstScanline = state.firstScanline;
+        this.inHSync = state.inHSync;
+        this.inVSync = state.inVSync;
+        this.hadVSyncThisRow = state.hadVSyncThisRow;
+        this.checkVertAdjust = state.checkVertAdjust;
+        this.endOfMainLatched = state.endOfMainLatched;
+        this.endOfVertAdjustLatched = state.endOfVertAdjustLatched;
+        this.endOfFrameLatched = state.endOfFrameLatched;
+        this.inVertAdjust = state.inVertAdjust;
+        this.inDummyRaster = state.inDummyRaster;
+        this.hpulseWidth = state.hpulseWidth;
+        this.vpulseWidth = state.vpulseWidth;
+        this.hpulseCounter = state.hpulseCounter;
+        this.vpulseCounter = state.vpulseCounter;
+        this.dispEnabled = state.dispEnabled;
+        this.horizCounter = state.horizCounter;
+        this.vertCounter = state.vertCounter;
+        this.scanlineCounter = state.scanlineCounter;
+        this.vertAdjustCounter = state.vertAdjustCounter;
+        this.addr = state.addr;
+        this.lineStartAddr = state.lineStartAddr;
+        this.nextLineStartAddr = state.nextLineStartAddr;
+        this.ulactrl = state.ulactrl;
+        this.pixelsPerChar = state.pixelsPerChar;
+        this.halfClock = state.halfClock;
+        this.ulaMode = state.ulaMode;
+        this.teletextMode = state.teletextMode;
+        this.displayEnableSkew = state.displayEnableSkew;
+        this.actualPal.set(state.actualPal);
+        this.cursorOn = state.cursorOn;
+        this.cursorOff = state.cursorOff;
+        this.cursorOnThisFrame = state.cursorOnThisFrame;
+        this.cursorDrawIndex = state.cursorDrawIndex;
+        this.cursorPos = state.cursorPos;
+        this.interlacedSyncAndVideo = state.interlacedSyncAndVideo;
+        this.screenSubtract = state.screenSubtract;
+        this.ula.restoreState(state.ula);
+        this.crtc.restoreState(state.crtc);
+        this.teletext.restoreState(state.teletext);
+        // Restore ulaPal after ULA restore, since ULA recomputation may overwrite it
+        this.ulaPal.set(state.ulaPal);
+    }
+
     reset(cpu, via) {
         this.cpu = cpu;
         this.sysvia = via;