badline 0.12.1 → 0.14.0

data/doc/snapshots.md

@@ -28,44 +28,72 @@ and `$XDG_DATA_HOME/badline` or `~/.local/share/badline` elsewhere.
 
 Both executables do this, and both open a `.vsf` given as the media,
 in a machine built as the saved one was, whatever `--model` says.
-`--save-snapshot FILE` saves one to `FILE` after the last frame. A
-snapshot that fails to open leaves the machine running as it was.
+`--save-snapshot FILE` saves one to `FILE` after the last frame, and
+`--vice` adds VICE's modules to it (see [VICE](#vice)). A snapshot that
+fails to open leaves the machine running as it was.
+
+## Which snapshots load
+
+Snapshots from badline 0.14.0 on load in that version and every later
+one. Each part of the machine is saved as named fields, so a later
+badline skips a field it no longer needs, and a field an earlier one
+didn't save starts as it does when the machine is switched on. What a
+restore leaves out or changes is printed, such as a module missing from
+the file. [snapshot-format.md](snapshot-format.md) lists every field.
+
+Snapshots from badline 0.13 and earlier are refused, with a message
+naming the version that saved them, which still opens them. No snapshot
+loaded across releases before 0.14.0, and none converts.
 
 ## From Ruby
 
 `computer.save_snapshot(path)` saves, `computer.restore_snapshot(path)`
 takes a machine back to a snapshot, and `Badline::Snapshot.load(path)`
 builds a new machine as the saved one was built and restores it.
-`computer.snapshot` and `computer.restore(state)` do the same in memory,
-without a file. A restore that fails leaves the machine as it was.
+`computer.snapshot` returns a `Badline::Snapshot::Image` in memory,
+without a file, and `computer.restore(image)` takes the machine back to
+it; `image.load` builds a new machine from it. A restore that fails
+leaves the machine as it was. `computer.export_snapshot(path)` saves with
+VICE's modules too.
+
+Saving first runs the machine on to the next instruction boundary, and
+to the end of an REU transfer under way, so it advances the machine by a
+few cycles: usually under a hundred, and up to about 262,000 for an REU
+swapping 64K. `computer.cycles` afterwards says where it was saved. A
+save straight after another runs no cycles and writes the same file. In
+the window this happens between frames, and the cycles fold into the
+next frame. `computer.snapshot` in memory saves the same way.
 
 ## What a snapshot holds
 
-A snapshot holds the machine as it was on the cycle it was saved: the
-chips down to the instruction step and the pixel pipeline, the RAM and
+A snapshot holds the machine as it was at the instruction boundary it
+was saved at: the chips down to the pixel pipeline, the RAM and
 any +60K or +256K expansion, the cartridge with its RAM and flash, a
 GEO-RAM, a true 1541 with its RAM, its VIAs and the disk under the head,
 a disk or directory mounted through the traps with its open channels,
 and the tape with its place on it. A restored machine runs on exactly
 as the saved one would have.
 
-A tape, a `.t64` archive and a disk image mounted through the traps come
-back with their contents from the snapshot, so they need no file to
-restore. A true drive's disk opens again from its image's path, with its
-tracks as the drive last saw them. When that file is gone, the disk
-comes back from the tracks alone, write-protected. A directory mounted
-as device 8 opens again from its path. What the host holds stays the
+A tape, a `.t64` archive, a disk image mounted through the traps and a
+true drive's disk come back with their contents from the snapshot, so
+they need no file to restore. A true drive's disk holds its image as last
+written to its file, with the tracks the drive has written since, and
+writes back to that file while it is there. When the file is gone, the
+disk comes back write-protected. A directory mounted as device 8 opens
+again from its path. What the host holds stays the
 host's: the keyboard, the joysticks, the mouse and paddles, sound, and
 blocks given to `on_init` that hadn't run yet, which a restore reports.
 
 Every model saves this way, PAL, NTSC, old NTSC and Drean alike, and so
-does a machine with an REU, with its RAM, its registers and a transfer
-part way through. A snapshot only restores in the badline version that
-wrote it, into a machine with the same chip models, region, RAM
-expansion, REU, KERNAL, datasette and board. One saved before badline
-recorded the KERNAL and the datasette restores as a machine with the
-C64's KERNAL and a datasette, and one saved before it recorded the board
-restores on a C64's.
+does a machine with an REU, with its RAM and its registers. A snapshot
+restores into a machine with the same chip models, region, RAM
+expansion, REU, KERNAL, datasette and board.
+
+Text typed with `type_text` that the machine hasn't taken yet, such as
+autostart's `RUN`, carries over, and so do the keys a C128 is typing on
+its key matrix. The VIC-II's line in progress carries over to a badline
+that draws lines the same way. A later badline that draws them another
+way starts the rest of that line afresh, and says so.
 
 ## The VIC-20
 
@@ -73,10 +101,10 @@ restores on a C64's.
 slots and pause menu page. A VIC-20 snapshot holds its RAM and colour
 RAM, a cartridge's ROM, the VIC with its picture and sound, both VIAs,
 the CPU, the tape with its place on it, the disk or directory device 8
-serves through the traps and a true 1541, and restores into a VIC-20
-with the same RAM expansion. Its file names its machine `VIC20`, as
-xvic's do, and holds only the `BADLINE` module, so xvic doesn't open
-it, and badline doesn't open xvic's. Restoring a
+serves through the traps and a true 1541 or 1581, and restores into a
+VIC-20 with the same RAM expansion. Its file names its machine `VIC20`,
+as xvic's do, and holds only badline's modules, so xvic doesn't open it,
+and badline doesn't open xvic's. Restoring a
 VIC-20 snapshot while a C64 runs, or a C64 one while a VIC-20 runs,
 swaps the machine in the window.
 
@@ -85,30 +113,32 @@ swaps the machine in the window.
 `badline c128` saves and restores the same way too. A C128 snapshot
 holds its 128K of RAM, both colour RAM banks, the CPU port, the MMU's
 registers and the page pointer writes it holds, the VIC-IIe, both CIAs,
-the SID, the VDC with its RAM and registers, the CPU, a cartridge, the
-tape, the disk device 8 serves through the traps and a true 1541, and
-restores into a C128 of the same model with the same SID, built for the
-same mode. The VDC's picture is left out and painted again while the
-window shows it, and the window shows the VIC-IIe after a restore. Its
-file names its machine `C128`, as x128's do, and holds only the
-`BADLINE` module, so x128 doesn't open it, and badline doesn't open
-x128's. Restoring a C128 snapshot while another machine runs swaps the
+the SID, the VDC with its RAM and registers, the 8502 and the Z80, a
+cartridge, the tape, the disk device 8 serves through the traps and a
+true 1541, 1571 or 1581, and restores into a C128 of the same model with
+the same SID, built for the same mode. The VDC's picture is left out and
+painted again while the window shows it, and the window shows the
+VIC-IIe after a restore. Its file names its machine `C128`, as x128's
+do, and holds only badline's modules, so x128 doesn't open it, and
+badline doesn't open x128's. Restoring a C128 snapshot while another machine runs swaps the
 machine in the window, as for the VIC-20.
 
 ## VICE
 
-Snapshots use VICE's `.vsf` format. badline writes VICE's modules for
-the CPU, RAM and CPU port, both CIAs, the SID and the VIC-II, and an
-REU's `REU1764`, plus the ones x64sc needs to open the file, with
-nothing else attached to the cartridge port, nothing on the tape or user
-ports and no true drive. The VIC-II module names the chip as VICE does:
-the 6569 or 8565 on PAL, the 6567R8 or 8562 on NTSC, the 6567R56A on old
-NTSC and the 6572 on PAL-N. A `BADLINE` module, which VICE skips, holds
-the whole machine, and badline restores its own snapshots from it.
-
-x64sc 3.10 opens badline's snapshots, taken at the end of the
-instruction the CPU was in, and of an REU transfer under way, as long
-as its VIC-II model matches: `-model c64`, `c64c`, `ntsc`, `newntsc`,
+Snapshots use VICE's `.vsf` format, and badline's own modules are named
+`BL-` and something, which VICE skips. A C64 snapshot saved with
+`--vice`, or `computer.export_snapshot(path)`, also holds VICE's
+modules for the CPU, RAM and CPU port, both CIAs, the SID and the
+VIC-II, and an REU's `REU1764`, plus the ones x64sc needs to open the
+file, with nothing else attached to the cartridge port, nothing on the
+tape or user ports and no true drive. The VIC-II module names the chip
+as VICE does: the 6569 or 8565 on PAL, the 6567R8 or 8562 on NTSC, the
+6567R56A on old NTSC and the 6572 on PAL-N. badline restores such a
+snapshot from its own modules, and leaves VICE's alone.
+
+x64sc 3.10 opens those snapshots, which are saved between
+instructions with no REU transfer under way, as long as its VIC-II
+model matches: `-model c64`, `c64c`, `ntsc`, `newntsc`,
 `oldntsc` or `drean`, as `--model` names the machine. It takes the REU
 from the snapshot, keeps its own drives and leaves out the cartridge,
 the other expansions and the tape. A program x64sc runs on from badline's

data/lib/badline/audio/bare_player.rb

@@ -49,13 +49,13 @@ module Badline
       def initialize(tune, subtune: nil, sid_models: tune.sid_models)
         @tune = tune
         @subtune = (subtune || tune.start_subtune).clamp(1, tune.subtunes) - 1
-        @bus = AddressBus.new(sid_model: sid_models[0])
+        @bus = C64::Bus.new(sid_model: sid_models[0])
         # The CPU port as the KERNAL leaves it, which a PSID tune expects.
         @bus.poke(0x00, 0x2f)
         @bus.poke(0x01, 0x37)
         @bus.poke(VIDEO_STANDARD, tune.ntsc? ? 0 : 1)
         @bus.cia1.timer_a_latch = tune.ntsc? ? NTSC_KERNAL_TIMER : KERNAL_TIMER
-        @cpu = CPU.new(@bus)
+        @cpu = Chips::CPU.new(@bus)
         @sid = @bus.sid
         @stereo = Stereo.new(@bus, tune, sid_models)
         @extras = @stereo.extras
@@ -74,26 +74,41 @@ module Badline
         settle
       end
 
-      # The rig between frames: the bus and its chips, the extra SIDs, the
-      # CPU, and the call waiting for the idle loop.
-      def save_state(out)
-        out.marker("BARE PLAYER")
-        @bus.save_state(out)
-        @extras.each { |sid| sid.save_state(out) }
-        @cpu.save_state(out)
-        out.optional_int(@pending).int(@argument).boolean(@idle)
+      # The rig between frames as keyed snapshot modules: the call waiting
+      # for the idle loop in BL-PLAYER, the memories, the CPU and its port,
+      # the chips and the extra SIDs, as BL-SID2 and BL-SID3.
+      def save_modules
+        bus = @bus
+        cpu = @cpu
+        sections = [Snapshot::Keyed.section("BL-PLAYER") do |out|
+          out.optional_int("pending", @pending).int("argument", @argument).bool("idle", @idle)
+        end]
+        sections << Snapshot::Keyed.section("BL-RAM") { |out| bus.ram.save_fields(out, "ram") }
+        sections << Snapshot::Keyed.section("BL-COLORRAM") { |out| bus.color_ram.save_fields(out, "ram") }
+        sections << Snapshot::Keyed.section("BL-CPU") do |out|
+          cpu.save_fields(out)
+          bus.save_port_fields(out)
+        end
+        sections << Snapshot::Keyed.section("BL-VIC") { |out| bus.vic.save_fields(out) }
+        sections << Snapshot::Keyed.section("BL-CIA1") { |out| bus.cia1.save_fields(out) }
+        sections << Snapshot::Keyed.section("BL-CIA2") { |out| bus.cia2.save_fields(out) }
+        sections << Snapshot::Keyed.section("BL-SID") { |out| bus.sid.save_fields(out) }
+        @extras.each_with_index do |sid, index|
+          sections << Snapshot::Keyed.section("BL-SID#{index + 2}") { |out| sid.save_fields(out) }
+        end
+        sections
       end
 
-      # Takes a rig that hasn't started to where #save_state found one, in
+      # Takes a rig that hasn't started to where #save_modules found one, in
       # place of #start.
-      def load_state(input)
-        input.marker("BARE PLAYER")
-        @bus.load_state(input)
-        @extras.each { |sid| sid.load_state(input) }
-        @cpu.load_state(input)
-        @pending = input.optional_int
-        @argument = input.int
-        @idle = input.boolean?
+      def load_modules(modules)
+        load_bus_modules(modules)
+        @cpu.load_fields(modules.required("BL-CPU"))
+        @cpu.restored!
+        player = modules.required("BL-PLAYER")
+        @pending = player.optional_int("pending")
+        @argument = player.int("argument", 0)
+        @idle = player.bool("idle", false)
         @stereo.synthesize!
         install_dispatch
       end
@@ -128,6 +143,24 @@ module Badline
         @bus.cia1.timer_a_latch + 1
       end
 
+      def load_bus_modules(modules)
+        bus = @bus
+        bus.ram.load_fields(modules.required("BL-RAM"), "ram")
+        bus.color_ram.load_fields(modules.required("BL-COLORRAM"), "ram")
+        bus.load_port_fields(modules.required("BL-CPU"))
+        bus.restored!
+        bus.vic.load_fields(modules.required("BL-VIC"))
+        bus.cia1.load_fields(modules.required("BL-CIA1"))
+        bus.cia2.load_fields(modules.required("BL-CIA2"))
+        @stereo.sids.each_with_index do |sid, index|
+          sid.load_fields(modules.required(index.zero? ? "BL-SID" : "BL-SID#{index + 1}"))
+          sid.restored!
+        end
+        bus.vic.restored!
+        bus.cia1.restored!
+        bus.cia2.restored!
+      end
+
       def stub_address = @stub_address ||= @tune.driver_address
 
       def idle_address = stub_address + 3
@@ -164,7 +197,7 @@ module Badline
 
       # Tunes live under the ROMs as often as not, so $01 has to bank out
       # whatever covers the routine about to run. An RSID tune banks itself,
-      # and `SIDFile#bank_for` hands back nil for it.
+      # and `SIDTune::File#bank_for` hands back nil for it.
       def dispatch
         bank = @tune.bank_for(@pending)
         @bus.poke(0x01, bank) if bank

data/lib/badline/audio/cli.rb

@@ -49,8 +49,8 @@ module Badline
       def queue
         @queue ||= begin
           paths = @options.tune_paths
-          queue = Media::Queue.new(entries(paths, @options.subtune), all_parts: @options.all_subtunes?,
-                                                                     build: ->(dropped) { entries(dropped) })
+          queue = Queue.new(entries(paths, @options.subtune), all_parts: @options.all_subtunes?,
+                                                              build: ->(dropped) { entries(dropped) })
           raise Error, "no .sid tunes in #{paths.join(', ')}" if queue.empty? && !paths.empty?
 
           queue
@@ -77,7 +77,7 @@ module Badline
       # below the directories, the first starting on `subtune` if given.
       def entries(paths, subtune = nil)
         tunes = []
-        Media::Queue.files(paths, ".sid").each do |path|
+        Queue.files(paths, ".sid").each do |path|
           tunes << QueuedTune.new(path, @options, subtune: tunes.empty? ? subtune : nil)
         end
         tunes
@@ -223,9 +223,9 @@ module Badline
       end
 
       def stil(entry)
-        list = Storage::STIL.locate(entry.path)
-        hvsc_path = list && Storage::HVSC.path(entry.path, list)
-        hvsc_path && (@stil_lists[list] ||= Storage::STIL.new(list)).entry(hvsc_path)
+        list = SIDTune::STIL.locate(entry.path)
+        hvsc_path = list && SIDTune::HVSC.path(entry.path, list)
+        hvsc_path && (@stil_lists[list] ||= SIDTune::STIL.new(list)).entry(hvsc_path)
       end
 
       def progress(done, total)

data/lib/badline/audio/jukebox.rb

@@ -2,7 +2,7 @@
 
 module Badline
   module Audio
-    # Plays a Media::Queue of tunes interactively: the console's keys step
+    # Plays a Audio::Queue of tunes interactively: the console's keys step
     # between tunes and between a tune's subtunes, seek within the subtune, pause,
     # turn the queue's shuffle, loop and all-subtunes modes on and off, and
     # quit, and the status line follows along. Seeking runs the subtune
@@ -10,7 +10,7 @@ module Badline
     # forward, and from the latest of its Checkpoints at or before there to
     # go back, or to go forward when that checkpoint is further on than
     # where the subtune is. A subtune that plays to its end moves on as
-    # Media::Queue#advance says. It stops at the end of the queue, on q, or
+    # Audio::Queue#advance says. It stops at the end of the queue, on q, or
     # on Ctrl-C.
     #
     # `renderer` builds the renderer for an entry's subtune at the sink's

data/lib/badline/audio/machine_player.rb

@@ -17,7 +17,7 @@ module Badline
       def initialize(tune, subtune: nil, sid_models: tune.sid_models)
         @tune = tune
         @subtune = subtune || tune.start_subtune
-        @computer = Computer.new(sid_model: sid_models[0])
+        @computer = C64.new(sid_model: sid_models[0])
         @stereo = Stereo.new(@computer.address_bus, tune, sid_models)
         @extras = @stereo.extras
         @multi = !@extras.empty?
@@ -39,18 +39,24 @@ module Badline
 
       def clock_hz = @computer.region.clock_hz
 
-      # The whole machine, as Computer#snapshot takes it, and the extra SIDs,
-      # once it plays.
-      def save_state(out)
-        @computer.save_state(out)
-        @extras.each { |sid| sid.save_state(out) }
+      # The whole machine as its keyed snapshot modules, as it stands between
+      # frames, and the extra SIDs as BL-SID2 and BL-SID3, once it plays.
+      def save_modules
+        sections = @computer.save_modules
+        @extras.each_with_index do |sid, index|
+          sections << Snapshot::Keyed.section("BL-SID#{index + 2}") { |out| sid.save_fields(out) }
+        end
+        sections
       end
 
-      # Takes a machine that hasn't started to where #save_state found one,
+      # Takes a machine that hasn't started to where #save_modules found one,
       # in place of #start.
-      def load_state(input)
-        @computer.load_state(input)
-        @extras.each { |sid| sid.load_state(input) }
+      def load_modules(modules)
+        @computer.load_modules(modules)
+        @extras.each_with_index do |sid, index|
+          sid.load_fields(modules.required("BL-SID#{index + 2}"))
+          sid.restored!
+        end
         @stereo.synthesize!
         @started = true
       end

data/lib/badline/{media → audio}/queue.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Badline
-  module Media
+  module Audio
     # An ordered list of media files to go through one at a time, such as
     # the tunes of a player. Each entry is a file and the part of it to
     # start on, counting from 1, out of the parts the file holds: a .sid

data/lib/badline/audio/queued_tune.rb

@@ -2,7 +2,7 @@
 
 module Badline
   module Audio
-    # A .sid tune in the player's Media::Queue, read only once the queue or
+    # A .sid tune in the player's Audio::Queue, read only once the queue or
     # the player first asks about it, so a queue of a whole collection
     # starts at once. Its subtunes, SID model and lengths follow the options:
     # --subtune picks the subtune to start on, --sid the model and --seconds the
@@ -11,7 +11,7 @@ module Badline
     #
     # A file that won't read as a tune, or lacks the subtune asked for, gets
     # an #error and a single subtune.
-    class QueuedTune < Media::Queue::Entry
+    class QueuedTune < Queue::Entry
       def initialize(path, options, subtune: nil)
         super(path)
         @options = options
@@ -39,7 +39,7 @@ module Badline
         @error
       end
 
-      def tune = @tune ||= Storage::SIDFile.new(path)
+      def tune = @tune ||= SIDTune::File.new(path)
 
       # Lets go of the tune's data, which #tune reads again if asked.
       def release = @tune = nil
@@ -71,7 +71,7 @@ module Badline
         @parts = tune.subtunes
         @part = @subtune || tune.start_subtune
         @error = "no subtune #{@part}: the tune has #{@parts}" if @part > @parts
-      rescue Storage::SIDFile::FormatError => e
+      rescue SIDTune::File::FormatError => e
         @error = e.message
       end
 
@@ -81,8 +81,8 @@ module Badline
         return @lengths if @lengths_read
 
         @lengths_read = true
-        database = @options.songlengths || Storage::SongLengths.locate(path)
-        @lengths = database && Storage::SongLengths.new(database).lengths(tune.md5)
+        database = @options.songlengths || SIDTune::SongLengths.locate(path)
+        @lengths = database && SIDTune::SongLengths.new(database).lengths(tune.md5)
       end
     end
   end

data/lib/badline/audio/renderer.rb

@@ -50,7 +50,7 @@ module Badline
         @subtune = subtune
         @rate = rate
         @sid_models = sid_models
-        @filter_chunk = SID::FILTER_CHUNK
+        @filter_chunk = Chips::SID::FILTER_CHUNK
         @silent_samples = 0
         @level = 0
         @still = 0
@@ -136,17 +136,17 @@ module Badline
       # or before `cycles` if there is one, and returns the cycles into the
       # subtune it starts at.
       def start(cycles)
-        state = @checkpoints&.latest(cycles)
-        return start_afresh if state.nil?
+        sections = @checkpoints&.latest(cycles)
+        return start_afresh if sections.nil?
 
-        input = Snapshot::StateReader.new(state)
-        played = input.int
-        resume(input)
+        modules = Snapshot::Keyed::Modules.new(sections)
+        audio = modules.required("BL-AUDIO")
+        restore_player(modules, audio)
         record
-        player.stereo.sids.each { |sid| sid.load_recording(input) }
-        @level = input.int
-        @still = input.int
-        played
+        player.stereo.sids.each_with_index { |sid, index| sid.load_recording_fields(audio, "sid#{index + 1}.rec.") }
+        @level = audio.int("level", 0)
+        @still = audio.int("still", 0)
+        audio.int("played", 0)
       end
 
       def start_afresh
@@ -157,13 +157,17 @@ module Badline
 
       def record = player.stereo.record(rate: @rate, filter_chunk: @filter_chunk, clock_hz: player.clock_hz)
 
-      # Restores the player as it was, then puts back the SID models chosen
-      # for this renderer.
-      def resume(input)
+      # Restores the player as it was, on the SID models it was saved on,
+      # then puts back the SID models chosen for this renderer.
+      def restore_player(modules, audio)
         sids = player.stereo.sids
         chosen = sids.map(&:model)
-        sids.each { |sid| refit(sid, Snapshot::Setup::SID_MODELS.fetch(input.int)) }
-        player.load_state(input)
+        names = Snapshot::C64Setup::SID_MODELS.map(&:to_s)
+        sids.each_with_index do |sid, index|
+          name = audio.choice("sid#{index + 1}.model", names, sid.model.to_s)
+          refit(sid, Snapshot::C64Setup::SID_MODELS.find { |model| model.to_s == name } || sid.model)
+        end
+        player.load_modules(modules)
         sids.each_with_index { |sid, index| refit(sid, chosen[index]) }
       end
 
@@ -171,18 +175,25 @@ module Badline
         sid.model = model unless sid.model == model
       end
 
+      # The player's modules, after a BL-AUDIO module with the cycles into
+      # the subtune, each SID's model and how far its recording has got,
+      # and the silence count. The SIDs have caught up as the frame drained
+      # them, so they leave no samples behind.
       def save_checkpoint(played, clock_hz)
         checkpoints = @checkpoints
         return if checkpoints.nil? || !checkpoints.due?(played, clock_hz)
 
         sids = player.stereo.sids
-        out = Snapshot::StateWriter.new
-        out.int(played)
-        sids.each { |sid| out.int(Snapshot::Setup::SID_MODELS.index(sid.model) || 0) }
-        player.save_state(out)
-        sids.each { |sid| sid.save_recording(out) }
-        out.int(@level).int(@still)
-        checkpoints.keep(played, out.state)
+        sections = player.save_modules
+        audio = Snapshot::Keyed.section("BL-AUDIO") do |out|
+          out.int("played", played)
+          sids.each_with_index do |sid, index|
+            out.text("sid#{index + 1}.model", sid.model.to_s)
+            sid.save_recording_fields(out, "sid#{index + 1}.rec.")
+          end
+          out.int("level", @level).int("still", @still)
+        end
+        checkpoints.keep(played, [audio, *sections])
       end
 
       # Counts the samples since the output last strayed more than QUIET

data/lib/badline/audio/stereo.rb

@@ -18,7 +18,7 @@ module Badline
         @sids = [bus.sid]
         @extras = []
         tune.sid_addresses.each do |address|
-          sid = SID.new(model: models[@sids.size], at: address)
+          sid = Chips::SID.new(model: models[@sids.size], at: address)
           bus.add_sid(sid)
           @sids << sid
           @extras << sid

data/lib/badline/c128/banks.rb

@@ -5,8 +5,8 @@ module Badline
     # The RAM the C128 KERNAL's bank numbers 0-15 reach, as its INDFET and
     # INDSTA reach it for LOAD, SAVE and the file name: the RAM bank of the
     # CR value the KERNAL's table at $F7F0 holds for the bank, with common
-    # RAM in bank 0. The ROMs and I/O some of those CR values map are left
-    # out.
+    # RAM in bank 0. The Bus lays the ROMs and I/O some of those CR values
+    # map over it.
     class Banks
       CONFIGURATIONS = 0xf7f0
 
@@ -18,6 +18,9 @@ module Badline
 
       def peek(bank, addr) = @ram.peek(physical(bank, addr))
 
+      # The CR value the KERNAL's table holds for the bank.
+      def configuration(bank) = @kernal_rom.peek(CONFIGURATIONS + (bank & 0x0f))
+
       def write(bank, addr, bytes)
         bytes.each_with_index { |byte, i| @ram.poke(physical(bank, (addr + i) & 0xffff), byte) }
       end
@@ -27,7 +30,7 @@ module Badline
       def physical(bank, addr)
         page = addr >> 8
         common = page < @mmu.common_low_pages || page >= @mmu.common_high_start
-        ram_bank = common ? 0 : (@kernal_rom.peek(CONFIGURATIONS + (bank & 0x0f)) >> 6) & 0x01
+        ram_bank = common ? 0 : (configuration(bank) >> 6) & 0x01
         (ram_bank << 16) | addr
       end
     end

data/lib/badline/c128/bus/keyed_state.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Badline
+  class C128
+    class Bus
+      # The last access on the bus, which FAST mode's VIC and open bus read,
+      # in a keyed snapshot module (Snapshot::Keyed) under `prefix`, and
+      # what is worked out once the memories, the MMU and the chips are
+      # loaded: the banks each side sees and the keyboard's extra rows.
+      module KeyedState
+        def save_fields(out, prefix)
+          out.int("#{prefix}address", @address).int("#{prefix}data", @data)
+        end
+
+        def load_fields(input, prefix)
+          @address = input.word("#{prefix}address", @address)
+          @data = input.byte("#{prefix}data", @data)
+        end
+
+        # Both banks of colour RAM as bank0 and bank1.
+        def save_color_fields(out)
+          @color_lines.color_ram(0).save_fields(out, "bank0")
+          @color_lines.color_ram(1).save_fields(out, "bank1")
+        end
+
+        def load_color_fields(input)
+          @color_lines.color_ram(0).load_fields(input, "bank0")
+          @color_lines.color_ram(1).load_fields(input, "bank1")
+        end
+
+        # The 8502's port, as the C64's (C64::Bus::KeyedState).
+        def save_port_fields(out) = @cpu_port.save_fields(out, "port.")
+
+        def load_port_fields(input) = @cpu_port.load_fields(input, "port.")
+
+        def restored!
+          update_overlays!
+          @control_ports.extra_rows = 0xf8 | @vic.extra_keyboard_lines
+        end
+      end
+
+      include KeyedState
+    end
+  end
+end