badline 0.12.1 → 0.14.0

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,
@@ -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/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/tap.rb

@@ -5,11 +5,14 @@ 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
 
@@ -28,10 +31,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,17 +59,16 @@ 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)
+        if version == 2
+          half = cycles / 2
+          @bytes.concat(encode(cycles - half))
+          @bytes.concat(encode(half))
+        else
+          @bytes.concat(encode(cycles))
+        end
         @pos = @end = @bytes.length
       end
 
@@ -77,20 +80,45 @@ 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 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/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.1"
+  VERSION = "0.14.0"
 end

data/lib/badline/vic20/attachments.rb

@@ -4,11 +4,11 @@ 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
-    # (Computer::KernalTraps), and a true 1541 or 1581 on the serial bus
-    # (Computer::TrueDrives).
+    # (C64::KernalTraps), and a true 1541 or 1581 on the serial bus
+    # (C64::TrueDrives).
     module Attachments
-      include Computer::TrueDrives
-      include Computer::KernalTraps
+      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
@@ -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
@@ -46,7 +49,7 @@ module Badline
       # 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/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,5 +1,7 @@
 # frozen_string_literal: true
 
+require "badline/vic20/bus/keyed_state"
+
 module Badline
   class Vic20
     # The CPU's bus:
@@ -215,31 +217,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)
 

data/lib/badline/vic20/cpu.rb

@@ -4,7 +4,7 @@ module Badline
   class Vic20
     # The VIC-20's 6502, on the Vic20::Bus.
     class CPU
-      include Badline::CPU::Core
+      include Badline::Chips::CPU::Core
     end
   end
 end

data/lib/badline/vic20/keyed_modules.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Badline
+  class Vic20
+    # The whole machine as keyed snapshot modules (Snapshot::Keyed), in the
+    # order a load applies them, as C64::KeyedModules: BL-MACHINE with the
+    # RAM expansion and the bytes each side's data lines hold under bus.*,
+    # the memories, a cartridge's ROM chips, the VIC with its sound, both
+    # VIAs, the CPU, the datasette, device 8 through the traps and the true
+    # drives.
+    module KeyedModules
+      def save_modules
+        bus = @bus
+        sections = [Snapshot::Keyed.section("BL-MACHINE") do |out|
+          save_machine_fields(out)
+          bus.save_fields(out, "bus.")
+        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-CART") { |out| bus.save_rom_fields(out) } if bus.cartridge?
+        sections << Snapshot::Keyed.section("BL-CPU") { |out| @cpu.save_fields(out) }
+        sections << Snapshot::Keyed.section("BL-VICI") { |out| @vic.save_fields(out) }
+        sections << Snapshot::Keyed.section("BL-VIA1") { |out| @via1.save_fields(out) }
+        sections << Snapshot::Keyed.section("BL-VIA2") { |out| @via2.save_fields(out) }
+        sections << Snapshot::Keyed.section("BL-TAPE") { |out| @datasette.save_fields(out) }
+        sections << Snapshot::Keyed.section("BL-TRAPDOS") { |out| save_trap_dos_fields(out) } if mounted?
+        save_drive_modules(sections)
+      end
+
+      # Raises Snapshot::FormatError for the modules of a VIC-20 with
+      # another RAM expansion.
+      def load_modules(modules)
+        machine = modules.machine
+        check_snapshot_setup(Snapshot::Vic20Setup.read_fields(machine))
+        load_machine_fields(machine)
+        bus = @bus
+        bus.load_fields(machine, "bus.")
+        bus.ram.load_fields(modules.required("BL-RAM"), "ram")
+        bus.color_ram.load_fields(modules.required("BL-COLORRAM"), "ram")
+        bus.load_rom_fields(modules.optional("BL-CART") || Snapshot::Keyed::Reader.new("BL-CART"))
+        bus.restored!
+        @vic.load_fields(modules.required("BL-VICI"))
+        @via1.load_fields(modules.required("BL-VIA1"))
+        @via2.load_fields(modules.required("BL-VIA2"))
+        @cpu.load_fields(modules.required("BL-CPU"))
+        @datasette.load_fields(modules.required("BL-TAPE"))
+        trap_dos = modules.optional("BL-TRAPDOS")
+        trap_dos ? load_trap_dos_fields(trap_dos, detached: modules.detached?) : unmount
+        load_drive_modules(modules)
+        modules_restored!
+        self
+      end
+
+      private
+
+      def modules_restored!
+        @cpu.restored!
+        @vic.restored!
+        @via1.restored!
+        @via2.restored!
+        machine_restored!
+      end
+
+      def check_snapshot_setup(setup)
+        return if setup.ram == @ram_configuration
+
+        raise Snapshot::FormatError, "the snapshot is of a VIC-20 with #{setup.ram} RAM, not #{@ram_configuration}"
+      end
+    end
+
+    include KeyedModules
+  end
+end