badline 0.12.0 → 0.13.0

data/lib/badline/snapshot.rb

@@ -4,7 +4,6 @@ require "zlib"
 require "badline/snapshot/state"
 require "badline/snapshot/setup"
 require "badline/snapshot/container"
-require "badline/snapshot/fields"
 require "badline/snapshot/machine_state"
 require "badline/snapshot/vice"
 require "badline/snapshot/image"
@@ -14,7 +13,7 @@ module Badline
   #
   # A snapshot badline writes carries VICE's modules for what both
   # emulators model, and a BADLINE module holding the State
-  # Computer#snapshot takes, with everything badline needs to carry on
+  # 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
@@ -47,23 +46,25 @@ module Badline
     # applied and left out, yielding a line for each thing left out. A
     # snapshot that fails leaves the machine as it was.
     def restore(computer, path, &) = read(path).restore(computer, &)
-  end
 
-  class Computer
-    def save_snapshot(path) = Snapshot.save(self, path)
+    # A machine's snapshots as .vsf files. C64, Vic20 and C128 each
+    # include it.
+    module Files
+      def save_snapshot(path) = Snapshot.save(self, path)
 
-    def restore_snapshot(path, &) = Snapshot.restore(self, path, &)
+      def restore_snapshot(path, &) = Snapshot.restore(self, path, &)
+    end
   end
 
-  class Vic20
-    def save_snapshot(path) = Snapshot.save(self, path)
+  class C64
+    include Snapshot::Files
+  end
 
-    def restore_snapshot(path, &) = Snapshot.restore(self, path, &)
+  class Vic20
+    include Snapshot::Files
   end
 
   class C128
-    def save_snapshot(path) = Snapshot.save(self, path)
-
-    def restore_snapshot(path, &) = Snapshot.restore(self, path, &)
+    include Snapshot::Files
   end
 end

data/lib/badline/storage/d64_image.rb

@@ -15,20 +15,26 @@ module Badline
         count
       end
 
-      def storage_kind = D64
-
       # The sides of a disk the image's tracks fill.
       def sides = 1
 
-      def sectors_in(track)
-        case track
-        when 1..17 then 21
-        when 18..24 then 19
-        when 25..30 then 18
-        else 17
-        end
+      # The last track of each of the 1541's speed zones but the innermost,
+      # from the outermost, zone 3, in: tracks 1-17, 18-24 and 25-30, and
+      # zone 0 from 31 on.
+      ZONE_LAST_TRACKS = [17, 24, 30].freeze
+
+      # The sectors a track holds in each zone, by its number.
+      ZONE_SECTORS = [17, 18, 19, 21].freeze
+
+      # The speed zone a track is written in, 3 for the outermost.
+      def self.zone(track)
+        zone = 3
+        zone -= 1 while zone.positive? && track > ZONE_LAST_TRACKS[3 - zone]
+        zone
       end
 
+      def sectors_in(track) = ZONE_SECTORS[D64Image.zone(track)]
+
       private
 
       def error_tables = ERROR_TABLES

data/lib/badline/storage/d71_image.rb

@@ -5,8 +5,6 @@ module Badline
     class D71Image < D64Image
       ERROR_TABLES = { 351_062 => 1366 }.freeze
 
-      def storage_kind = D71
-
       # Tracks 1-35 on the first side and 36-70 on the second.
       def track_count = 70
 

data/lib/badline/storage/d81_image.rb

@@ -5,8 +5,6 @@ module Badline
     class D81Image < DiskImage
       ERROR_TABLES = { 822_400 => 3200 }.freeze
 
-      def storage_kind = D81
-
       private
 
       def error_tables = ERROR_TABLES

data/lib/badline/storage/disk_image/writing.rb

@@ -11,7 +11,7 @@ module Badline
       module Writing
         # Whether the disk takes writes: the image wasn't opened read-only
         # and the host file takes them.
-        def writable? = !read_only? && ::File.writable?(@path)
+        def writable? = !read_only? && File.writable?(@path)
 
         # Writes a new file, or with `replace` writes over the one of the
         # same name in its directory entry. A name already on the disk
@@ -87,7 +87,7 @@ module Badline
           saved = [@bytes.dup, @errors&.dup]
           begin
             yield
-            ::File.binwrite(@path, (@bytes + @errors.to_a).pack("C*"))
+            File.binwrite(@path, (@bytes + @errors.to_a).pack("C*"))
           rescue WriteError, SystemCallError => e
             @bytes, @errors = saved
             raise e.is_a?(WriteError) ? e : WriteError.new(WriteError::WRITE_PROTECT_ON)

data/lib/badline/storage/disk_image.rb

@@ -42,12 +42,9 @@ module Badline
       # Whether the image was opened write-protected.
       def read_only? = @read_only
 
-      # What Storage.reopen needs to open the image again as it stands: its
-      # path, whether it is write-protected, and its bytes with the error
-      # table after them.
-      def save_setup(out)
-        out.int(storage_kind).string(::File.expand_path(@path)).boolean(@read_only).blob(@bytes + @errors.to_a)
-      end
+      # The image as its file holds it, with its error table after the
+      # blocks.
+      def contents = @bytes + @errors.to_a
 
       # A LOAD reads only PRG files. An OPEN names the type it wants, or
       # takes the first file of any type with a nil `type`.

data/lib/badline/storage/g64_image.rb

@@ -5,7 +5,7 @@ module Badline
     # A .g64 image: a 1541 disk's flux as raw GCR, track by track, for the
     # true drive to read the way it reads a real disk, copy protection and
     # all. It has no file system of its own, so only the true drive
-    # (Drive1541::Disk.from_g64) can use it. A .g71 holds a 1571 disk the
+    # (Drives::Model1541::Disk.from_g64) can use it. A .g71 holds a 1571 disk the
     # same way, with "GCR-1571" for its signature and 168 half tracks,
     # the first side's 84 and then the second's.
     #
@@ -21,7 +21,7 @@ module Badline
     # A larger one is the offset of a speed map, two bits a byte, four
     # track bytes to a map byte, the first byte's in the top two bits, for
     # a track whose zone changes along it. The drive passes each byte
-    # under the head at its own zone's rate (Drive1541::Track).
+    # under the head at its own zone's rate (Drives::Model1541::Track).
     #
     # The drive writes a track at one zone, so a track written back takes
     # that zone as its speed entry. Writing it puts it in its own block,

data/lib/badline/storage/host_directory.rb

@@ -17,11 +17,6 @@ module Badline
         @path = path
       end
 
-      # What Storage.reopen needs to open the directory again.
-      def save_setup(out)
-        out.int(HOST_DIRECTORY).string(::File.expand_path(@path))
-      end
-
       def read_file(name, **)
         entry = find(name)
         return unless entry

data/lib/badline/storage/t64.rb

@@ -20,14 +20,8 @@ module Badline
         raise FormatError, "Missing T64 signature" unless @bytes[0, 3] == SIGNATURE
       end
 
-      # The host file's path, as it was opened.
-      attr_reader :path
-
-      # What Storage.reopen needs to open the archive again: its path and
-      # its bytes.
-      def save_setup(out)
-        out.int(T64_ARCHIVE).string(::File.expand_path(@path)).blob(@bytes)
-      end
+      # The host file's path, as it was opened, and its bytes.
+      attr_reader :path, :bytes
 
       def read_file(name, **)
         pattern = Storage.matcher(name)

data/lib/badline/storage/unavailable.rb

@@ -3,7 +3,7 @@
 module Badline
   module Storage
     # Stands in for a directory a detached restore leaves out
-    # (Snapshot::StateReader): it finds no files and refuses every write
+    # (Snapshot::StorageSetup): it finds no files and refuses every write
     # as a write-protected disk does.
     class Unavailable
       def path = ""

data/lib/badline/storage.rb

@@ -11,10 +11,6 @@ require "badline/storage/g64_image"
 require "badline/storage/t64"
 require "badline/storage/tap"
 require "badline/storage/crt_file"
-require "badline/storage/sid_file"
-require "badline/storage/hvsc"
-require "badline/storage/song_lengths"
-require "badline/storage/stil"
 require "badline/storage/unavailable"
 
 module Badline
@@ -36,29 +32,7 @@ module Badline
       end
     end
 
-    # The storage a snapshot's device 8 serves, by the number save_setup
-    # writes first.
-    HOST_DIRECTORY = 0
-    D64 = 1
-    D71 = 2
-    D81 = 3
-    T64_ARCHIVE = 4
-
     class << self
-      # Opens the storage a save_setup 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 Unavailable for a directory.
-      def reopen(input)
-        kind = input.int
-        path = input.string
-        case kind
-        when HOST_DIRECTORY then input.detached? ? Unavailable.new : HostDirectory.new(path)
-        when T64_ARCHIVE then T64.new(path, bytes: input.blob)
-        else reopen_image(kind, path, input)
-        end
-      end
-
       # Folds shifted PETSCII letters to their ASCII equivalents.
       def ascii(bytes)
         bytes.map { |b| b.between?(0xc1, 0xda) ? b - 0x80 : b }.pack("C*")
@@ -83,17 +57,6 @@ module Badline
         [base.to_s, FILE_TYPES[type.to_s.strip[0]&.upcase]]
       end
 
-      def reopen_image(kind, path, input)
-        read_only = input.boolean? || input.detached?
-        bytes = input.blob
-        case kind
-        when D64 then D64Image.new(path, read_only:, bytes:)
-        when D71 then D71Image.new(path, read_only:, bytes:)
-        when D81 then D81Image.new(path, read_only:, bytes:)
-        else raise Snapshot::FormatError, "unknown storage #{kind} in the state"
-        end
-      end
-
       # CBM-style filename pattern: "*" and "?" wildcards, case-insensitive.
       # The DOS stops comparing at the first "*", so whatever follows it
       # is ignored.

data/lib/badline/support/c128_checkpoint.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Badline
+  module Support
+    # A Checkpoint of a C128, in either mode: a C64's components, with the
+    # whole 128K of RAM in place of bank 0 and the colour RAM bank the 8502
+    # sees, and besides them the VDC's registers and beam, the VDC's RAM, the
+    # MMU's registers and the Z80.
+    module C128Checkpoint
+      COMPONENTS = %w[cpu ram color_ram display vic cia1 cia2 sid vdc vdc_ram mmu z80].freeze
+
+      def self.take(machine)
+        Checkpoint.new(machine.cycles, [
+                         Checkpoint.fnv1a(Checkpoint.cpu_state(machine.cpu)),
+                         Checkpoint.fnv1a(Checkpoint.ram(machine.ram, 0x20000)),
+                         Checkpoint.fnv1a(Checkpoint.color_ram(machine.address_bus.color_ram, 0xd800)),
+                         Checkpoint.fnv1a(machine.vic.display),
+                         Checkpoint.fnv1a(Checkpoint.vic_state(machine.vic)),
+                         Checkpoint.fnv1a(Checkpoint.cia_state(machine.cia1)),
+                         Checkpoint.fnv1a(Checkpoint.cia_state(machine.cia2)),
+                         Checkpoint.fnv1a(Array.new(0x20) { |reg| machine.sid.register(reg) }),
+                         Checkpoint.fnv1a(machine.vdc.registers + [machine.vdc.frame]),
+                         Checkpoint.fnv1a(machine.vdc.ram),
+                         Checkpoint.fnv1a(machine.mmu.registers),
+                         Checkpoint.fnv1a(z80_state(machine.z80))
+                       ], COMPONENTS)
+      end
+
+      def self.parse(line) = Checkpoint.parse(line, COMPONENTS)
+
+      def self.z80_state(z80)
+        [z80.pc, z80.sp, z80.af, z80.bc, z80.de, z80.hl, z80.ix, z80.iy, z80.af_alt, z80.bc_alt, z80.de_alt,
+         z80.hl_alt, z80.i, z80.r, z80.im, flag(z80.iff1), flag(z80.iff2), flag(z80.halted), z80.cycles]
+      end
+
+      def self.flag(value) = value == true ? 1 : 0
+    end
+  end
+end

data/lib/badline/support/checkpoint.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Badline
+  module Support
+    # A digest of the machine's state at one cycle, for comparing two runs of
+    # the same scenario, on two builds or two revisions. Each component is
+    # hashed on its own with 32-bit FNV-1a, so a mismatch names the part of the
+    # machine that went its own way. Nothing is read through a chip's bus
+    # 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+.
+    #
+    # Colour RAM is digested as the four bits each cell stores: the upper
+    # nibble a CPU read sees comes off the open bus.
+    class Checkpoint
+      COMPONENTS = %w[cpu ram color_ram display vic cia1 cia2 sid].freeze
+
+      FNV_OFFSET = 0x811c9dc5
+      FNV_PRIME = 0x01000193
+
+      attr_reader :cycle, :digests, :components
+
+      class << self
+        def take(computer)
+          new(computer.cycles, [
+                fnv1a(cpu_state(computer.cpu)),
+                fnv1a(ram(computer.ram, 0x10000)),
+                fnv1a(color_ram(computer.address_bus.color_ram, 0xd800)),
+                fnv1a(computer.vic.display),
+                fnv1a(vic_state(computer.vic)),
+                fnv1a(cia_state(computer.cia1)),
+                fnv1a(cia_state(computer.cia2)),
+                fnv1a(Array.new(0x20) { |reg| computer.sid.register(reg) })
+              ])
+        end
+
+        # Reads a line written by #to_s, with a digest for each of
+        # `components`.
+        def parse(line, components = COMPONENTS)
+          fields = line.split
+          digests = components.map do |name|
+            field = fields.find { |f| f.start_with?("#{name}=") }
+            raise ArgumentError, "no #{name} digest in #{line.inspect}" unless field
+
+            field.split("=").last.to_i(16)
+          end
+          new(fields.first.to_i, digests, components)
+        end
+
+        def fnv1a(values)
+          hash = FNV_OFFSET
+          values.each { |value| hash = ((hash ^ (value & 0xffffffff)) * FNV_PRIME) & 0xffffffff }
+          hash
+        end
+
+        # The registers and cycle count of a 6502 or an 8502.
+        def cpu_state(cpu)
+          [cpu.program_counter, cpu.a, cpu.x, cpu.y, cpu.stack_pointer, cpu.p, cpu.cycles]
+        end
+
+        # The first `length` bytes of `memory`.
+        def ram(memory, length)
+          Array.new(length) { |addr| memory.peek(addr) }
+        end
+
+        # The 1K of colour RAM at `start`.
+        def color_ram(memory, start)
+          Array.new(0x400) { |offset| memory.nibble(start + offset) }
+        end
+
+        # A VIC-II's or a VIC-I's registers and beam position.
+        def vic_state(vic)
+          vic.register_file + [vic.rasterline, vic.column]
+        end
+
+        def cia_state(cia)
+          start = cia.start
+          [cia.peek(start), cia.peek(start + 1), cia.peek(start + 2), cia.peek(start + 3),
+           cia.timer_a, cia.timer_a_latch, cia.timer_b, cia.timer_b_latch, cia.serial.data,
+           cia.control_a.value, cia.control_b.value, cia.interrupt_status.value,
+           cia.interrupt_control.value] + cia.time_of_day.registers
+        end
+      end
+
+      def initialize(cycle, digests, components = COMPONENTS)
+        @cycle = cycle
+        @digests = digests
+        @components = components
+      end
+
+      # The components whose digests differ from `other`'s.
+      def differences(other)
+        components.each_index.reject { |i| digests[i] == other.digests[i] }.map { |i| components[i] }
+      end
+
+      def ==(other)
+        other.is_a?(Checkpoint) && cycle == other.cycle && components == other.components && digests == other.digests
+      end
+
+      def to_s
+        fields = components.each_index.map { |i| "#{components[i]}=#{digests[i].to_s(16).rjust(8, '0')}" }
+        "#{cycle} #{fields.join(' ')}"
+      end
+    end
+  end
+end

data/lib/badline/support/vic20_checkpoint.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Badline
+  module Support
+    # A Checkpoint of a VIC-20: its CPU, the 48K of RAM the bus decodes, the
+    # colour RAM, the VIC-I's display and registers, both VIAs and the
+    # sound. The sound's shift registers and noise LFSR move only while it
+    # records, so a run that wants them digested records it.
+    module Vic20Checkpoint
+      COMPONENTS = %w[cpu ram color_ram display vic via1 via2 sound].freeze
+
+      def self.take(machine)
+        Checkpoint.new(machine.cycles, [
+                         Checkpoint.fnv1a(Checkpoint.cpu_state(machine.cpu)),
+                         Checkpoint.fnv1a(Checkpoint.ram(machine.ram, 0xc000)),
+                         Checkpoint.fnv1a(Checkpoint.color_ram(machine.bus.color_ram, 0)),
+                         Checkpoint.fnv1a(machine.vic.display),
+                         Checkpoint.fnv1a(Checkpoint.vic_state(machine.vic)),
+                         Checkpoint.fnv1a(via_state(machine.via1)),
+                         Checkpoint.fnv1a(via_state(machine.via2)),
+                         Checkpoint.fnv1a(sound_state(machine.sound))
+                       ], COMPONENTS)
+      end
+
+      def self.parse(line) = Checkpoint.parse(line, COMPONENTS)
+
+      def self.via_state(via)
+        [via.port_a_output, via.port_b_output, via.timer1, via.timer1_latch, via.timer2,
+         via.shift_register.data, via.acr, via.pcr, via.interrupt_flags, via.interrupt_enable]
+      end
+
+      def self.sound_state(sound)
+        [sound.volume, sound.shift_register(0), sound.shift_register(1), sound.shift_register(2),
+         sound.shift_register(3), sound.lfsr]
+      end
+    end
+  end
+end

data/lib/badline/support.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "badline/support/checkpoint"
+require "badline/support/vic20_checkpoint"
+require "badline/support/c128_checkpoint"

data/lib/badline/version.rb

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

data/lib/badline/vic20/attachments.rb

@@ -3,10 +3,12 @@
 module Badline
   class Vic20
     # What plugs into the VIC-20 besides its chips: cartridge ROM in the
-    # expansion blocks, the disk device 8 serves through the KERNAL traps,
-    # and a true 1541 or 1581 on the serial bus.
+    # expansion blocks, the disk device 8 serves through the KERNAL traps
+    # (C64::KernalTraps), and a true 1541 or 1581 on the serial bus
+    # (C64::TrueDrives).
     module Attachments
-      include Drive1581::Slot
+      include C64::TrueDrives
+      include C64::KernalTraps
 
       # The cycle by which a 1541 switched on with the machine has run its
       # DOS's reset, the RAM test and the ROM checksum, and waits on the
@@ -27,96 +29,24 @@ module Badline
         power_cycle!
       end
 
-      # Puts the storage in device 8. Mounting again swaps the disk at any
-      # point while the machine runs: the drive keeps its RAM and its
-      # status.
-      def mount(storage)
-        return @drive.insert(storage) if @drive
-
-        @drive = KernalTrap::Drive.new(storage)
-        layout = KernalTrap::VIC20_LAYOUT
-        load_trap = KernalTrap::Load.new(cpu:, bus:, layout:, drive: @drive)
-        cpu.install_trap(layout.load) { load_trap.call }
-        @serial_trap = KernalTrap::Serial.new(cpu:, bus:, layout:, drive: @drive, device: serial_trap_device).install
-        save_trap = @save_trap = KernalTrap::Save.new(cpu:, bus:, layout:, drive: @drive)
-        cpu.install_trap(layout.save) { save_trap.call }
-      end
-
-      # Takes device 8's mounted storage out, and with it the LOAD, SAVE and
-      # serial traps, so the KERNAL's routines go out over the serial bus.
-      # Mounting again starts a new drive, with its RAM cleared.
-      def unmount
-        return unless @drive
+      private
 
-        cpu.remove_trap(KernalTrap::VIC20_LAYOUT.load)
-        cpu.remove_trap(KernalTrap::VIC20_LAYOUT.save)
-        @serial_trap.uninstall
-        @serial_trap = nil
-        @save_trap = nil
-        @drive = nil
-      end
+      # The VIC-20's KERNAL, which the traps stand in for.
+      def trap_layout = KernalTrap::VIC20_LAYOUT
 
-      # Whether device 8 serves a disk or directory through the traps.
-      def mounted? = !@drive.nil?
+      def trap_bus = @bus
 
-      # Plugs in a Drive1541, which then runs alongside the VIC-20 on its own
-      # clock and talks to it over the serial bus. The serial traps stop
-      # answering the drive's device number, so the KERNAL's TALK, LISTEN
-      # and byte transfers reach the drive. The LOAD and SAVE traps stay,
-      # and still serve a mounted image.
-      #
       # A drive that powers on with the machine takes longer to boot than
       # the KERNAL, and doesn't answer the bus until it has, so the
       # machine's on_init handlers wait for it too.
-      def attach_drive1541(drive)
+      def drive1541_attached
         @init_threshold = [@init_threshold, DRIVE_BOOT_CYCLES].max if @cycles < @init_threshold
-        @iec_bus.detach(@drive1541) if @drive1541
-        drive.host_clock_hz = timing.clock_hz
-        @drive1541 = drive
-        drive.connect(@iec_bus)
-        @serial_trap&.device = serial_trap_device
-      end
-
-      # The true drive on the serial bus: the Drive1581 ahead of the
-      # Drive1541, or nil.
-      def true_drive = @drive1581 || @drive1541
-
-      # Plugs a Drive1541 in as device 8, in place of a 1581 there, and
-      # returns it.
-      def plug_true_drive
-        detach_drive1581 if drive1581_on_device8?
-        Drive1541.new.tap { |drive| attach_drive1541(drive) }
-      end
-
-      # Unplugs the Drive1541, leaving the serial bus with nothing on it.
-      def detach_drive1541
-        return unless @drive1541
-
-        @iec_bus.detach(@drive1541)
-        @drive1541 = nil
-        @serial_trap&.device = serial_trap_device
-      end
-
-      # Records what the KERNAL prints through CHROUT (ChroutTrap).
-      def capture_output
-        @capture_output ||= ChroutTrap.new(cpu:, bus:, layout: KernalTrap::VIC20_LAYOUT).tap do |trap|
-          cpu.install_trap(ChroutTrap::ADDRESS) { trap.call }
-        end
-      end
-
-      private
-
-      # The device number the serial traps answer: device 8, unless a true
-      # drive is on the bus as device 8.
-      def serial_trap_device
-        device = KernalTrap::Routine::DEVICE
-        @drive1541&.device == device || drive1581_on_device8? ? nil : device
       end
 
       # A 1581 plugged in, as a 1541 does, holds the machine's on_init
       # handlers back until its DOS has booted.
       def drive1581_attached
-        @init_threshold = [@init_threshold, Drive1581::BOOT_CYCLES].max if @cycles < @init_threshold
+        @init_threshold = [@init_threshold, Drives::Model1581::BOOT_CYCLES].max if @cycles < @init_threshold
       end
     end
   end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Badline
+  class Vic20
+    class Bus
+      # The bus's state for a snapshot.
+      module SavedState
+        # The RAM, the colour RAM, the byte each side's data lines hold and the
+        # cartridge's ROM chips, for a snapshot. The expansion blocks are how
+        # the machine was built.
+        def save_state(out)
+          out.marker("VIC20 BUS")
+          @ram.save_state(out)
+          out.blob(@color_ram.cells).int(@data).int(@video_data).int(@roms.length)
+          @roms.each do |rom|
+            out.int(rom.start)
+            rom.save_state(out)
+          end
+        end
+
+        def load_state(input)
+          input.marker("VIC20 BUS")
+          @ram.load_state(input)
+          input.blob_into(@color_ram.cells)
+          @data = input.int
+          @video_data = input.int
+          chips = Array.new(input.int) { [input.int, input.blob] }
+          @roms = []
+          chips.each { |chip| @roms << ROM.new(chip[1], length: chip[1].length, start: chip[0]) }
+          map_pages
+        end
+      end
+    end
+  end
+end

data/lib/badline/vic20/bus.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "badline/vic20/bus/saved_state"
+
 module Badline
   class Vic20
     # The CPU's bus:
@@ -27,6 +29,7 @@ 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 = {
@@ -215,31 +218,6 @@ module Badline
         @ram.clear!(RAM_POWER_ON)
       end
 
-      # The RAM, the colour RAM, the byte each side's data lines hold and the
-      # cartridge's ROM chips, for a snapshot. The expansion blocks are how
-      # the machine was built.
-      def save_state(out)
-        out.marker("VIC20 BUS")
-        @ram.save_state(out)
-        out.blob(@color_ram.cells).int(@data).int(@video_data).int(@roms.length)
-        @roms.each do |rom|
-          out.int(rom.start)
-          rom.save_state(out)
-        end
-      end
-
-      def load_state(input)
-        input.marker("VIC20 BUS")
-        @ram.load_state(input)
-        input.blob_into(@color_ram.cells)
-        @data = input.int
-        @video_data = input.int
-        chips = Array.new(input.int) { [input.int, input.blob] }
-        @roms = []
-        chips.each { |chip| @roms << ROM.new(chip[1], length: chip[1].length, start: chip[0]) }
-        map_pages
-      end
-
       # Whether +block+ (BLOCKS) holds RAM.
       def ram?(block) = @blocks.include?(block)