badline 0.13.0 → 0.15.0

data/lib/badline/snapshot/storage_setup.rb

@@ -2,7 +2,7 @@
 
 module Badline
   module Snapshot
-    # The storage device 8 serves through the traps, as a State holds it:
+    # The storage device 8 serves through the traps, as a snapshot holds it:
     # its kind, its path and, for an archive or a disk image, its bytes, so
     # it opens again without the host file.
     module StorageSetup
@@ -14,23 +14,6 @@ module Badline
 
       module_function
 
-      # The same directory by its path, an archive with the bytes it held,
-      # or a disk image with its path, whether it is write-protected, and
-      # its bytes with the error table after them.
-      def write(storage, out)
-        if storage.is_a?(Storage::HostDirectory)
-          out.int(HOST_DIRECTORY).string(File.expand_path(storage.path))
-        elsif storage.is_a?(Storage::T64)
-          out.int(T64_ARCHIVE).string(File.expand_path(storage.path)).blob(storage.bytes)
-        else
-          write_image(storage, out)
-        end
-      end
-
-      def write_image(image, out)
-        out.int(image_kind(image)).string(File.expand_path(image.path)).boolean(image.read_only?).blob(image.contents)
-      end
-
       def image_kind(image)
         return D71 if image.is_a?(Storage::D71Image)
         return D64 if image.is_a?(Storage::D64Image)
@@ -39,28 +22,40 @@ module Badline
         raise ArgumentError, "#{image.class} can't go in a snapshot"
       end
 
-      # Opens the storage `write` wrote: the same directory by its path, an
-      # archive with the bytes it held, or a disk image with the bytes it
-      # held, writes and all. A detached reader gets the image
-      # write-protected, and Storage::Unavailable for a directory.
-      def read(input)
-        kind = input.int
-        path = input.string
-        case kind
-        when HOST_DIRECTORY then input.detached? ? Storage::Unavailable.new : Storage::HostDirectory.new(path)
-        when T64_ARCHIVE then Storage::T64.new(path, bytes: input.blob)
-        else read_image(kind, path, input)
+      # The storage's kind by name, in a keyed snapshot module, under
+      # storage.*: its path, and for an archive or a disk image whether it
+      # is write-protected and its bytes.
+      def write_fields(storage, out)
+        out.text("storage.path", File.expand_path(storage.path))
+        if storage.is_a?(Storage::HostDirectory)
+          out.text("storage.kind", "directory")
+        elsif storage.is_a?(Storage::T64)
+          out.text("storage.kind", "t64").bytes("storage.bytes", storage.bytes)
+        else
+          out.text("storage.kind", KIND_NAMES.fetch(image_kind(storage))).bool("storage.read_only", storage.read_only?)
+          out.bytes("storage.bytes", storage.contents)
         end
       end
 
-      def read_image(kind, path, input)
-        read_only = input.boolean? || input.detached?
-        bytes = input.blob
+      KIND_NAMES = %w[directory d64 d71 d81 t64].freeze
+
+      # Opens the storage write_fields wrote: the same directory by its
+      # path, an archive with the bytes it held, or a disk image with the
+      # bytes it held, writes and all. A detached reader gets the image
+      # write-protected, and Storage::Unavailable for a directory.
+      def read_fields(input, detached: false)
+        kind = KIND_NAMES.index(input.choice("storage.kind", KIND_NAMES, "directory")).to_i
+        path = input.text("storage.path", "")
+        return (detached ? Storage::Unavailable.new : Storage::HostDirectory.new(path)) if kind == HOST_DIRECTORY
+
+        bytes = input.bytes("storage.bytes", "".b).bytes
+        return Storage::T64.new(path, bytes:) if kind == T64_ARCHIVE
+
+        read_only = input.bool("storage.read_only", false) || detached
         case kind
         when D64 then Storage::D64Image.new(path, read_only:, bytes:)
         when D71 then Storage::D71Image.new(path, read_only:, bytes:)
-        when D81 then Storage::D81Image.new(path, read_only:, bytes:)
-        else raise FormatError, "unknown storage #{kind} in the state"
+        else Storage::D81Image.new(path, read_only:, bytes:)
         end
       end
     end

data/lib/badline/snapshot/vic20_setup.rb

@@ -7,25 +7,16 @@ module Badline
     Vic20Setup = Data.define(:ram)
 
     class Vic20Setup
-      MARKER = "VIC20"
       RAM_CONFIGURATIONS = Vic20::Bus::RAM_CONFIGURATIONS.keys.freeze
 
-      # The setup a VIC-20's State starts with.
-      def self.from(state)
-        input = StateReader.new(state)
-        input.marker(MARKER)
-        input.check_stamp
-        read(input)
+      # The RAM expansion by name, in a keyed snapshot module.
+      def write_fields(out)
+        out.text("ram", ram.to_s)
       end
 
-      def self.read(input)
-        new(ram: RAM_CONFIGURATIONS.fetch(input.int))
-      rescue IndexError
-        raise FormatError, "the state names a VIC-20 RAM expansion badline doesn't know"
-      end
-
-      def write(out)
-        out.int(RAM_CONFIGURATIONS.index(ram))
+      def self.read_fields(input)
+        text = input.choice("ram", RAM_CONFIGURATIONS.map(&:to_s), "unexpanded")
+        new(ram: RAM_CONFIGURATIONS.find { |name| name.to_s == text } || :unexpanded)
       end
 
       # A machine built this way, at power-on.

data/lib/badline/snapshot/vice/reu1764.rb

@@ -9,8 +9,8 @@ module Badline
       # from $DF00, and the RAM.
       #
       # Written: the registers and the RAM. VICE saves between transfers,
-      # so badline's copy of the machine runs a transfer in flight to its
-      # end first (Vice.settled).
+      # so a save runs a transfer in flight to its end first
+      # (Machine::Settling).
       #
       # Read: the registers, as the values the counters run from and
       # start from, and the RAM. The status register's interrupt, end of

data/lib/badline/snapshot/vice.rb

@@ -22,43 +22,19 @@ module Badline
     # machine at power-on with nothing attached, and applies the modules it
     # has, in the order x64sc writes them.
     module Vice
-      # Cycles a copy of the machine may run to reach an instruction
-      # boundary: the longest instruction, stretched by the VIC's longest
-      # hold on the bus.
-      BOUNDARY_CYCLES = 100
-      # Cycles more it may run for an REU transfer in flight to end: a
-      # swap of 64K, two cycles a byte, stretched by the VIC's holds on
-      # the bus.
-      TRANSFER_CYCLES = 0x40000
-
-      # The modules a badline snapshot carries for VICE, in x64sc's order.
-      # They describe a copy of the machine restored from `state`, so saving
-      # leaves the machine itself alone. VICE saves between instructions,
-      # and resumes by fetching an opcode at the program counter, so when
-      # badline's CPU is inside an instruction, or an REU transfer holds
-      # the bus, the copy runs on to the end of both. The copy's SID
-      # catches up, so its registers and voices stand as of that cycle.
-      def self.export(state)
-        machine = settled(state)
+      # The modules a badline snapshot carries for VICE, in x64sc's order,
+      # describing `machine`, which Machine::Settling has brought between
+      # instructions with no REU transfer under way: VICE saves between
+      # instructions, and resumes by fetching an opcode at the program
+      # counter. Its SID has caught up, so the registers and voices stand
+      # as of that cycle.
+      def self.export(machine)
         sections = [MainCPU.export(machine), C64Mem.export(machine), Peripherals.cartridge_port(machine)]
         sections << REU1764.export(machine) if machine.reu
         sections + [*CIAs.export(machine), SIDRegisters.export(machine), SIDExtended.export(machine),
                     Peripherals.drives, VICII.export(machine), Peripherals.glue(machine), *Peripherals.rest]
       end
 
-      # The copy is detached from the host's files (Snapshot::StateReader),
-      # so it reads none and its traps write none.
-      def self.settled(state)
-        copy = C64.restored(state, detached: true)
-        (BOUNDARY_CYCLES + TRANSFER_CYCLES).times do
-          break if copy.cpu.boundary? && !copy.reu&.dma?
-
-          copy.cycle!
-        end
-        copy.sid.catch_up!
-        copy
-      end
-
       # How the machine the snapshot was saved from was built: the VIC
       # model and the region from the VIC-II's model, and an REU from
       # REU1764. VICE doesn't save the CIA model; the 8565 and 8562 go

data/lib/badline/snapshot.rb

@@ -1,23 +1,22 @@
 # frozen_string_literal: true
 
 require "zlib"
-require "badline/snapshot/state"
-require "badline/snapshot/setup"
 require "badline/snapshot/container"
+require "badline/snapshot/c64_setup"
 require "badline/snapshot/machine_state"
+require "badline/snapshot/keyed"
 require "badline/snapshot/vice"
 require "badline/snapshot/image"
 
 module Badline
   # Saves and restores the whole machine in VICE's .vsf snapshot format.
   #
-  # A snapshot badline writes carries VICE's modules for what both
-  # emulators model, and a BADLINE module holding the State
-  # C64#snapshot takes, with everything badline needs to carry on
-  # exactly where it stopped. VICE skips modules it doesn't know. Restoring
-  # a badline snapshot uses the BADLINE module alone; a snapshot from VICE
-  # restores through its modules, as far as they map, and reports the
-  # modules badline doesn't take.
+  # A snapshot badline writes holds the machine as BL-* modules, one per
+  # unit, each a list of keyed records (Snapshot::Keyed), which later
+  # badlines read: doc/snapshot-format.md lists them. VICE skips modules it
+  # doesn't know. An export for VICE puts VICE's own modules for the C64
+  # ahead of them. A snapshot from VICE restores through its modules, as
+  # far as they map, and reports the modules badline doesn't take.
   module Snapshot
     module_function
 
@@ -26,17 +25,22 @@ module Badline
       path
     end
 
-    # A VIC-20's or a C128's snapshot holds the BADLINE module alone, in a
-    # container named as xvic or x128 names its machine.
-    def dump(computer)
-      state = computer.snapshot
-      return Container.new([MachineState.section(state)], machine: Container::VIC20).to_s if computer.family == :vic20
-      return Container.new([MachineState.section(state)], machine: Container::C128).to_s if computer.family == :c128
-
-      Container.new(Vice.export(state) + [MachineState.section(state)]).to_s
+    # Saves the machine's snapshot with VICE's modules ahead of its own for
+    # a C64, so x64sc opens it too.
+    def export(computer, path)
+      File.binwrite(path, Image.exported(computer).to_s)
+      path
     end
 
-    def read(path) = Image.new(Container.parse(File.binread(path)))
+    # The machine's snapshot file. Saving first runs the machine on to the
+    # end of the instruction its CPU is in, and of an REU transfer under
+    # way (Machine::Settling), so a save advances it by a few cycles, and a
+    # second save straight after runs none. A VIC-20's, a C128's or a
+    # Plus/4's snapshot is in a container named as xvic, x128 or xplus4
+    # names its machine.
+    def dump(computer) = Image.of(computer).to_s
+
+    def read(path) = Image.new(Container.parse(File.binread(path)), name: File.basename(path))
 
     # A new machine, built as the snapshot's was and restored from it.
     # Yields a line for each thing it leaves out.
@@ -47,12 +51,32 @@ module Badline
     # snapshot that fails leaves the machine as it was.
     def restore(computer, path, &) = read(path).restore(computer, &)
 
-    # A machine's snapshots as .vsf files. C64, Vic20 and C128 each
-    # include it.
+    # A machine's snapshots, as .vsf files and in memory. C64, Vic20, C128
+    # and Plus4 each include it.
     module Files
       def save_snapshot(path) = Snapshot.save(self, path)
 
+      # Saves the snapshot with VICE's modules too, for a C64, so x64sc
+      # opens it as well as badline.
+      def export_snapshot(path) = Snapshot.export(self, path)
+
       def restore_snapshot(path, &) = Snapshot.restore(self, path, &)
+
+      # The machine's snapshot in memory (Image.of), which settles it as a
+      # save does.
+      def snapshot = Image.of(self)
+
+      # Takes the machine back to an Image from #snapshot. The machine keeps
+      # its chips, its traps and its callbacks, and puts in the cartridge,
+      # drives and tape the image has, taking out any it hasn't. Raises
+      # Snapshot::FormatError for an image of a machine built another way.
+      # The image goes into a new machine first, so one that fails leaves
+      # this machine as it was. What it leaves out goes unsaid:
+      # Image#restore returns it in a Report.
+      def restore(image)
+        image.restore(self) { nil }
+        self
+      end
     end
   end
 
@@ -67,4 +91,8 @@ module Badline
   class C128
     include Snapshot::Files
   end
+
+  class Plus4
+    include Snapshot::Files
+  end
 end

data/lib/badline/storage/crt_file.rb

@@ -7,6 +7,7 @@ module Badline
 
       SIGNATURE = "C64 CARTRIDGE   ".b
       VIC20_SIGNATURE = "VIC20 CARTRIDGE ".b
+      PLUS4_SIGNATURE = "PLUS4 CARTRIDGE ".b
       CHIP_SIGNATURE = "CHIP".b
       CHIP_HEADER_SIZE = 0x10
       RAM_CHIP = 1
@@ -35,7 +36,7 @@ module Badline
       end
 
       # `bytes` stands in for the file's contents. `machine` is the one the
-      # image has to be for, :c64 or :vic20, or nil for either.
+      # image has to be for, :c64, :vic20 or :plus4, or nil for any.
       def initialize(path = nil, bytes: nil, machine: :c64)
         parse(bytes || File.binread(path))
         return if machine.nil? || @machine == machine
@@ -58,6 +59,7 @@ module Badline
       def signed_machine(bytes)
         return :c64 if bytes.start_with?(SIGNATURE)
         return :vic20 if bytes.start_with?(VIC20_SIGNATURE)
+        return :plus4 if bytes.start_with?(PLUS4_SIGNATURE)
 
         raise FormatError, "Missing CRT signature"
       end

data/lib/badline/storage/g64_image.rb

@@ -47,7 +47,7 @@ module Badline
       # track 1 and 1 for track 1.5, laid out as VICE lays one out: every
       # block as long as the longest track.
       def self.create(path, tracks, half_tracks: HALF_TRACKS)
-        max = [MAX_TRACK_SIZE, *tracks.values.map { |bytes, _| bytes.length }].max
+        max = tracks.values.map { |bytes, _| bytes.length }.push(MAX_TRACK_SIZE).max
         offsets = Array.new(half_tracks, 0)
         zones = Array.new(half_tracks, 0)
         blocks = +"".b
@@ -66,15 +66,20 @@ module Badline
         [bytes.length].pack("v") + bytes.pack("C*").ljust(size, "\x00".b)
       end
 
-      attr_reader :half_tracks, :max_track_size
+      attr_reader :half_tracks, :max_track_size, :path
 
-      def initialize(path, read_only: false)
+      # `bytes` stands in for the host file's contents, as a snapshot
+      # restores the image as it was.
+      def initialize(path, read_only: false, bytes: nil)
         @path = path
         @read_only = read_only
-        @data = File.binread(path)
+        @data = bytes ? bytes.pack("C*") : File.binread(path)
         parse
       end
 
+      # The image as its file holds it.
+      def contents = @data.bytes
+
       # Whether the image was opened write-protected.
       def read_only? = @read_only
 

data/lib/badline/storage/tap.rb

@@ -5,21 +5,26 @@ module Badline
     # Raw datasette pulse stream. The header holds the signature, the
     # version at $0c, the platform at $0d (0 C64, 1 VIC-20, 2 C16) and the
     # data size at $10; the data runs from $14, every byte the time to the
-    # next falling edge on the tape read line, in units of 8 cycles.
+    # next falling edge on the tape read line, in units of 8 cycles. A
+    # version 2 tape, the C16's and the Plus/4's, times half waves instead,
+    # so it takes two bytes to the next falling edge.
     class TAP
       class FormatError < StandardError; end
 
       SIGNATURE = "C64-TAPE-RAW".bytes.freeze
+      C16_SIGNATURE = "C16-TAPE-RAW".bytes.freeze
       HEADER_SIZE = 0x14
       OVERFLOW = 0x100 * 8
 
       # The file it was read from, expanded, and the file's bytes.
       attr_reader :version, :platform, :path, :bytes
 
-      # A blank version 1 tape for `platform` (0 C64, 1 VIC-20) at `path`,
-      # written to the host file.
+      # A blank tape for `platform` at `path`, written to the host file: a
+      # version 1 tape for the C64 (0) or the VIC-20 (1), and a version 2
+      # C16 tape for the 264 series (2).
       def self.create(path, platform:)
-        File.binwrite(path, (SIGNATURE + [1, platform, 0, 0, 0, 0, 0, 0]).pack("C*"))
+        header = platform == 2 ? C16_SIGNATURE + [2] : SIGNATURE + [1]
+        File.binwrite(path, (header + [platform, 0, 0, 0, 0, 0, 0]).pack("C*"))
         new(path)
       end
 
@@ -28,10 +33,11 @@ module Badline
       def initialize(path, bytes: nil)
         @path = File.expand_path(path)
         @bytes = bytes || File.binread(path).bytes
-        raise FormatError, "Missing TAP signature" unless @bytes[0, SIGNATURE.length] == SIGNATURE
+        signature = @bytes[0, SIGNATURE.length]
+        raise FormatError, "Missing TAP signature" unless [SIGNATURE, C16_SIGNATURE].include?(signature)
 
         @version = @bytes[0x0c].to_i
-        raise FormatError, "Unsupported TAP version #{@version}" if @version > 1
+        raise FormatError, "Unsupported TAP version #{@version}" if @version > 2
 
         @platform = @bytes[0x0d].to_i
 
@@ -55,18 +61,18 @@ module Badline
       # Records a pulse `cycles` long at the position, in place of the rest
       # of the tape: a byte of units of 8 cycles, or a zero and the 24-bit
       # cycle count for a long one (a lone zero, an overflow, on a version 0
-      # tape).
+      # tape). A version 2 tape records it as two equal halves.
       def record_pulse(cycles)
-        units = (cycles + 4) / 8
-        encoded = if units.between?(1, 0xff) then [units]
-                  elsif version.zero? then [0]
-                  else
-                    count = [cycles, 0xffffff].min
-                    [0, count & 0xff, (count >> 8) & 0xff, count >> 16]
-                  end
-        @bytes.slice!(@pos..)
-        @bytes.concat(encoded)
-        @pos = @end = @bytes.length
+        return record(encode(cycles)) unless version == 2
+
+        half = cycles / 2
+        record(encode(cycles - half) + encode(half))
+      end
+
+      # Records a half wave `cycles` long at the position, in place of the
+      # rest of the tape, as a version 2 tape times them.
+      def record_half_wave(cycles)
+        record(encode(cycles))
       end
 
       # Writes the tape back to its host file, with the data size the
@@ -77,20 +83,51 @@ module Badline
         File.binwrite(@path, @bytes.pack("C*"))
       end
 
+      # Whether each byte times a half wave, as on a version 2 tape.
+      def half_waves? = version == 2
+
       # Cycles until the next falling edge, or nil once the tape has run out.
+      # On a version 2 tape that is two half waves, or one left at the end.
       def next_pulse
         return if end?
+        return next_time unless half_waves?
+
+        first = next_time
+        end? ? first : first + next_time
+      end
+
+      # Cycles until the read line's next edge on a version 2 tape, or nil
+      # once the tape has run out.
+      def next_half_wave
+        next_time unless end?
+      end
 
+      private
+
+      def next_time
         byte = @bytes[@pos]
         @pos += 1
         return byte * 8 unless byte.zero?
 
-        # $00 is an overflow in version 0 and a 24-bit cycle count in
-        # version 1.
+        # $00 is an overflow in version 0 and a 24-bit cycle count from
+        # version 1 on.
         version.zero? ? OVERFLOW : long_pulse
       end
 
-      private
+      def record(times)
+        @bytes.slice!(@pos..)
+        @bytes.concat(times)
+        @pos = @end = @bytes.length
+      end
+
+      def encode(cycles)
+        units = (cycles + 4) / 8
+        return [units] if units.between?(1, 0xff)
+        return [0] if version.zero?
+
+        count = [cycles, 0xffffff].min
+        [0, count & 0xff, (count >> 8) & 0xff, count >> 16]
+      end
 
       # The stated size disagrees with the file in the wild, and a few dumps
       # leave it zeroed altogether.

data/lib/badline/support/checkpoint.rb

@@ -9,8 +9,9 @@ module Badline
     # interface, so taking a checkpoint leaves the machine as it was.
     #
     # Checkpoint.take digests a C64's components, COMPONENTS.
-    # Vic20Checkpoint and C128Checkpoint digest the other families', each
-    # with a list of its own, which a checkpoint carries as +components+.
+    # Vic20Checkpoint, C128Checkpoint and Plus4Checkpoint digest the other
+    # families', each with a list of its own, which a checkpoint carries as
+    # +components+.
     #
     # Colour RAM is digested as the four bits each cell stores: the upper
     # nibble a CPU read sees comes off the open bus.

data/lib/badline/support/plus4_checkpoint.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Badline
+  module Support
+    # A Checkpoint of a 264 series machine: its CPU, its RAM, the TED's
+    # picture, the TED's registers, timers and beam, its sound, and the
+    # CPU's port with the ROM banks. The sound's voices are run up to the
+    # cycle to read them, which changes nothing they do.
+    module Plus4Checkpoint
+      COMPONENTS = %w[cpu ram display ted sound port].freeze
+
+      def self.take(machine)
+        ram = machine.ram
+        Checkpoint.new(machine.cycles, [
+                         Checkpoint.fnv1a(Checkpoint.cpu_state(machine.cpu)),
+                         Checkpoint.fnv1a(Checkpoint.ram(ram, ram.length)),
+                         Checkpoint.fnv1a(machine.ted.display),
+                         Checkpoint.fnv1a(ted_state(machine.ted)),
+                         Checkpoint.fnv1a(sound_state(machine.sound)),
+                         Checkpoint.fnv1a(port_state(machine))
+                       ], COMPONENTS)
+      end
+
+      def self.parse(line) = Checkpoint.parse(line, COMPONENTS)
+
+      def self.ted_state(ted)
+        Array.new(0x20) { |register| ted.peek(0xff00 + register) } +
+          ted.timer_counts + [ted.line, ted.column, ted.interrupt_flags, ted.cpu_slots]
+      end
+
+      def self.sound_state(sound)
+        [sound.noise, sound.phase(0), sound.phase(1), sound.level, sound.volume, sound.control]
+      end
+
+      def self.port_state(machine)
+        port = machine.port
+        bus = machine.bus
+        [port.ddr, port.data, bus.low_bank, bus.high_bank, bus.rom_selected ? 1 : 0]
+      end
+    end
+  end
+end

data/lib/badline/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Badline
-  VERSION = "0.13.0"
+  VERSION = "0.15.0"
 end

data/lib/badline/vic20/attachments.rb

@@ -34,6 +34,9 @@ module Badline
       # The VIC-20's KERNAL, which the traps stand in for.
       def trap_layout = KernalTrap::VIC20_LAYOUT
 
+      # The VIC-20's KERNAL keeps its keyboard buffer where the C64's does.
+      def keyboard_buffer = Machine::KeyboardBuffer::C64_LAYOUT
+
       def trap_bus = @bus
 
       # A drive that powers on with the machine takes longer to boot than

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Badline
+  class Vic20
+    class Bus
+      class ColorRAM
+        # The cells in a keyed snapshot module, under `key`.
+        def save_fields(out, key) = out.bytes(key, @cells)
+
+        def load_fields(input, key) = input.bytes_into(key, @cells)
+      end
+
+      # The bytes each side's data lines hold, under `prefix`, and a
+      # cartridge's ROM chips as rom<N>.start and rom<N>.bytes, in a keyed
+      # snapshot module (Snapshot::Keyed). The pages are mapped again once
+      # they are loaded.
+      module KeyedState
+        def save_fields(out, prefix)
+          out.int("#{prefix}data", @data).int("#{prefix}video_data", @video_data)
+        end
+
+        def load_fields(input, prefix)
+          @data = input.byte("#{prefix}data", @data)
+          @video_data = input.byte("#{prefix}video_data", @video_data)
+        end
+
+        # Whether a cartridge's ROM chips are in the expansion blocks.
+        def cartridge? = !@roms.empty?
+
+        def save_rom_fields(out)
+          out.int("roms", @roms.length)
+          @roms.each_with_index do |rom, number|
+            out.int("rom#{number}.start", rom.start)
+            rom.save_fields(out, "rom#{number}.bytes")
+          end
+        end
+
+        def load_rom_fields(input)
+          @roms = []
+          input.int("roms", 0).times do |number|
+            bytes = input.bytes("rom#{number}.bytes", "".b).bytes
+            @roms << ROM.new(bytes, length: bytes.length, start: input.word("rom#{number}.start", 0))
+          end
+        end
+
+        def restored! = map_pages
+      end
+
+      include KeyedState
+    end
+  end
+end

data/lib/badline/vic20/bus.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "badline/vic20/bus/saved_state"
+require "badline/vic20/bus/keyed_state"
 
 module Badline
   class Vic20
@@ -29,7 +29,6 @@ module Badline
     # Writes to ROM and to empty spots go nowhere.
     class Bus
       include Addressable
-      include SavedState
 
       # The pages each expansion block covers, as [first page, count].
       BLOCKS = {