badline 0.7.0 → 0.9.0

data/lib/badline/kernal_trap/serial.rb

@@ -85,17 +85,24 @@ module Badline
       end
 
       # Addressing the bus starts a new frame. The channel number arrives
-      # in the secondary address that follows.
+      # in the secondary address that follows. Each byte sent under ATN,
+      # and each byte of a frame, times its handshake with CIA 1's timer B
+      # as ISOUR does.
       def talk
         @talk_channel = nil
         @talking = @cpu.a == @device
-        return_to_caller if @talking
+        sent_under_atn if @talking
       end
 
       def listen
         @listen_channel = nil
         @listening = @cpu.a == @device
-        return_to_caller if @listening
+        sent_under_atn if @listening
+      end
+
+      def sent_under_atn
+        time_serial_byte(ISOUR_TIMEOUT)
+        return_to_caller
       end
 
       def second
@@ -104,19 +111,22 @@ module Badline
         @frame = @cpu.a & 0xf0
         @listen_channel = @cpu.a & 0x0f
         @buffer = []
-        return_to_caller
+        sent_under_atn
       end
 
       def tksa
         return unless @talking
 
         @talk_channel = @cpu.a & 0x0f
-        return_to_caller
+        sent_under_atn
       end
 
+      # CIOUT holds each byte back until the next one, or the UNLISTEN,
+      # comes, so the first byte of a frame sends nothing.
       def ciout
         return unless @listening
 
+        time_serial_byte(ISOUR_TIMEOUT) if !@buffer.empty? && accepted?
         @buffer << @cpu.a
         update_status(DEVICE_NOT_PRESENT) unless accepted?
         @cpu.status.carry = false
@@ -135,6 +145,7 @@ module Badline
 
         @listening = false
         deliver_frame
+        time_serial_byte(ISOUR_TIMEOUT)
         release_bus
       end
 
@@ -142,14 +153,14 @@ module Badline
         return unless @talking
 
         @talking = false
+        time_serial_byte(ISOUR_TIMEOUT)
         release_bus
       end
 
       # UNLSN and UNTLK end by releasing ATN, the clock and the data line on
       # CIA 2's port A, and leave the port's last read in the accumulator.
       def release_bus
-        @bus.poke(0xdd00, @bus.peek(0xdd00) & 0xc7)
-        @cpu.a = @bus.peek(0xdd00) & 0xdf
+        @cpu.a = release_serial_lines
         @cpu.status.negative = @cpu.a.anybits?(0x80)
         @cpu.status.zero = @cpu.a.zero?
         return_to_caller
@@ -159,6 +170,7 @@ module Badline
         return unless @talking
 
         byte, status = received
+        time_serial_byte(ACPTR_TIMEOUT)
         @cpu.a = byte
         update_status(status)
         @cpu.status.carry = false

data/lib/badline/media/disk_list.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # A list of the disks of a set: an .m3u playlist, one path a line, or
+    # a VICE .vfl flip list, whose paths follow a `UNIT 8` line. Paths are
+    # relative to the list or absolute, and blank lines and lines starting
+    # with # are skipped. Only the disk images the list names that are
+    # there count.
+    module DiskList
+      # A list naming no disk image that's there.
+      class Error < ArgumentError; end
+
+      EXTENSIONS = %w[.m3u .vfl].freeze
+
+      def self.list?(path) = EXTENSIONS.include?(File.extname(path).downcase)
+
+      # The disk `path` puts in the drive: a list's first disk, or the
+      # path itself.
+      def self.disk(path)
+        return path unless list?(path)
+
+        disks = disks(path)
+        raise Error, "#{path} lists no disk image that's there" if disks.empty?
+
+        disks.first
+      end
+
+      # The disk images the list names that are there, in its order.
+      def self.disks(list)
+        directory = File.dirname(list)
+        found = []
+        entries(list).each do |entry|
+          disk = entry.start_with?("/") ? entry : File.join(directory, entry)
+          found << disk if DiskSet::EXTENSIONS.include?(File.extname(disk).downcase) && File.file?(disk)
+        end
+        found
+      end
+
+      # The paths of the list's lines, only unit 8's for a .vfl, which
+      # starts on unit 8.
+      def self.entries(list)
+        flip = File.extname(list).casecmp?(".vfl")
+        unit = true
+        found = []
+        File.foreach(list) do |line|
+          text = line.strip
+          next if text.empty? || text.start_with?("#")
+
+          if flip && text.match?(/\AUNIT\s+\d+\z/i)
+            unit = text.split.last.to_i == 8
+          elsif unit
+            found << text
+          end
+        end
+        found
+      rescue SystemCallError
+        []
+      end
+
+      # The disks of the first list in the disk's folder that names it,
+      # with the disk as given, or none.
+      def self.beside(path)
+        directory = File.dirname(path)
+        own = File.expand_path(path)
+        lists = DiskSet.children(directory).sort.select { |name| list?(name) }
+        sets = lists.map { |name| disks(File.join(directory, name)) }
+        set = sets.find { |listed| listed.any? { |disk| File.expand_path(disk) == own } }
+        return [] if set.nil?
+
+        set.map { |disk| File.expand_path(disk) == own ? path : disk }
+      end
+    end
+  end
+end

data/lib/badline/media/disk_set.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # The disks of a set a disk image belongs to, found by name in its
+    # folder: images whose names differ only in their disk, side or part
+    # markers, such as "Disk 1", "Side B", "d2", "(Disk 1 of 3)", ordered
+    # by those markers. A name with no marker can end in a number or a
+    # letter, as in game_1.d64 and game_2.d64, which counts only when the
+    # folder has the first of the set too.
+    #
+    # A list in the disk's folder that names it (DiskList) gives its set
+    # ahead of the names.
+    module DiskSet
+      KINDS = %w[disk disc side part].freeze
+      EXTENSIONS = %w[.d64 .d71 .d81 .g64].freeze
+
+      # The paths of the set's disks in order, or just `path` when it
+      # belongs to none. A list's set is the disks it lists.
+      def self.around(path)
+        return DiskList.disks(path) if DiskList.list?(path)
+        return [path] unless EXTENSIONS.include?(File.extname(path).downcase)
+
+        listed = DiskList.beside(path)
+        listed.empty? ? named(path) : listed
+      end
+
+      # The set of the disk's name.
+      def self.named(path)
+        extension = File.extname(path).downcase
+        marked = !parse(stem(path))[1].negative?
+        base = key(stem(path), marked)[0]
+        found = siblings(File.dirname(path), extension, base, marked)
+        return [path] if found.size < 2 || (!marked && found.none? { |pair| pair[0] == 1 })
+
+        found.sort_by { |pair| pair[0] }.map { |pair| File.join(File.dirname(path), pair[1]) }
+      end
+
+      # The name's words without their markers, joined, and the order the
+      # markers give it, -1 for none.
+      def self.parse(stem)
+        words = words(stem)
+        base = []
+        values = []
+        index = 0
+        index = take(words, index, base, values) while index < words.size
+        [base.join(" "), order(values)]
+      end
+
+      # The words before a trailing number or letter, joined, and its
+      # order, -1 for a name that doesn't end in one.
+      def self.trailing(stem)
+        words = words(stem)
+        last = words.last.to_s
+        return ["", -1] if words.size < 2 || !value?(last) || last.length > 2
+
+        [words[0, words.size - 1].join(" "), value(last)]
+      end
+
+      def self.words(stem) = stem.downcase.split(/[^a-z0-9]+/).reject(&:empty?)
+
+      def self.stem(path) = File.basename(path, File.extname(path))
+
+      def self.key(stem, marked) = marked ? parse(stem) : trailing(stem)
+
+      # The order and name of each image in the folder in the set.
+      def self.siblings(directory, extension, base, marked)
+        found = []
+        children(directory).each do |name|
+          next unless File.extname(name).downcase == extension
+
+          name_key = key(stem(name), marked)
+          found << [name_key[1], name] if name_key[0] == base && !name_key[1].negative?
+        end
+        found
+      end
+
+      # Adds the word at `index` to the base, or its marker's value to the
+      # values, and returns the index of the next word.
+      def self.take(words, index, base, values)
+        word = words[index]
+        following = words[index + 1].to_s
+        if KINDS.include?(word) && value?(following)
+          values << value(following)
+          index += 2
+          index += 2 if words[index] == "of" && words[index + 1].to_s.match?(/\A\d+\z/)
+          index
+        elsif marker?(word)
+          values << value(word.sub(/\A(disk|disc|side|part|d|s)/, ""))
+          index + 1
+        else
+          base << word
+          index + 1
+        end
+      end
+
+      def self.marker?(word) = word.match?(/\A(disk|disc|side|part)(\d+|[a-z])\z/) || word.match?(/\A[ds]\d+\z/)
+
+      def self.value?(word) = word.match?(/\A(\d+|[a-z])\z/)
+
+      # A number counts as itself and a letter by its place in the
+      # alphabet, so side A is 1.
+      def self.value(word) = word.match?(/\A\d+\z/) ? word.to_i : word.ord - 96
+
+      def self.order(values)
+        return -1 if values.empty?
+
+        values.reduce(0) { |order, value| (order * 1000) + value }
+      end
+
+      def self.children(directory)
+        Dir.children(directory)
+      rescue SystemCallError
+        []
+      end
+    end
+  end
+end

data/lib/badline/media.rb

@@ -2,6 +2,8 @@
 
 require "badline/media/true_drive"
 require "badline/media/queue"
+require "badline/media/disk_set"
+require "badline/media/disk_list"
 
 module Badline
   module Media
@@ -26,7 +28,11 @@ module Badline
       # A .g64 plugs in a true drive as device 8 (TrueDrive), and with one
       # there, a .d64 goes into it instead of the KERNAL traps too. The
       # autostart then loads through it.
+      #
+      # An .m3u or .vfl list of disks attaches the first disk it lists
+      # (DiskList).
       def attach(computer, path, autostart: true, subtune: nil, **options)
+        path = DiskList.disk(path)
         if TrueDrive.takes?(computer, path)
           attach_true_drive(computer, path, options.fetch(:disk, {}), autostart:)
         elsif File.directory?(path)
@@ -64,9 +70,9 @@ module Badline
       end
 
       # The SID a machine for `path` should be built with. A .sid tune names
-      # its own; everything else gets the 6581.
-      def sid_model(path)
-        return :mos6581 unless path && File.extname(path).downcase == ".sid"
+      # its own; everything else gets `otherwise`.
+      def sid_model(path, otherwise: :mos6581)
+        return otherwise unless path && File.extname(path).downcase == ".sid"
 
         Storage::SIDFile.new(path).sid_model
       end

data/lib/badline/model.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Badline
+  # = Model
+  #
+  # The C64s badline builds by name, as `--model` selects them: the chips
+  # each was sold with, its video standard, its KERNAL and whether it has
+  # a datasette. The names are x64sc's.
+  module Model
+    # Each field but the name is a keyword Computer.new takes.
+    Profile = Data.define(:name, :vic_model, :cia_model, :sid_model, :region, :kernal, :datasette)
+
+    # The breadbin PAL C64: the 6569 VIC-II, 6526 CIAs and the 6581 SID.
+    C64 = Profile.new(name: "c64", vic_model: :mos6569, cia_model: :mos6526, sid_model: :mos6581,
+                      region: Region::PAL, kernal: :c64, datasette: true)
+
+    # The PAL C64C: the HMOS 8565 VIC-II, 6526A CIAs and the 8580 SID.
+    C64C = Profile.new(name: "c64c", vic_model: :mos8565, cia_model: :mos6526a, sid_model: :mos8580,
+                       region: Region::PAL, kernal: :c64, datasette: true)
+
+    # The NTSC C64 with the 6567R8 VIC-II.
+    NTSC = Profile.new(name: "ntsc", vic_model: :mos6569, cia_model: :mos6526, sid_model: :mos6581,
+                       region: Region::NTSC, kernal: :c64, datasette: true)
+
+    # The NTSC C64C: the 8562, the 6567R8's HMOS successor, with the
+    # C64C's CIAs and SID.
+    NEW_NTSC = Profile.new(name: "newntsc", vic_model: :mos8565, cia_model: :mos6526a, sid_model: :mos8580,
+                           region: Region::NTSC, kernal: :c64, datasette: true)
+
+    # The first NTSC C64s, with the 6567R56A VIC-II.
+    OLD_NTSC = Profile.new(name: "oldntsc", vic_model: :mos6569, cia_model: :mos6526, sid_model: :mos6581,
+                           region: Region::NTSC_OLD, kernal: :c64, datasette: true)
+
+    # The Drean C64 of Argentina, on PAL-N with the 6572 VIC-II.
+    DREAN = Profile.new(name: "drean", vic_model: :mos6569, cia_model: :mos6526, sid_model: :mos6581,
+                        region: Region::DREAN, kernal: :c64, datasette: true)
+
+    # The portable SX-64: a PAL C64's chips with its own KERNAL, a 1541
+    # built in as device 8 and no cassette port.
+    SX64 = Profile.new(name: "sx64", vic_model: :mos6569, cia_model: :mos6526, sid_model: :mos6581,
+                       region: Region::PAL, kernal: :sx64, datasette: false)
+
+    ALL = [C64, C64C, NTSC, NEW_NTSC, OLD_NTSC, DREAN, SX64].freeze
+
+    def self.named(name)
+      model = ALL.find { |candidate| candidate.name == name }
+      raise ArgumentError, "no C64 model named #{name}" if model.nil?
+
+      model
+    end
+
+    # The model whose chips, region, KERNAL and datasette `machine` has, or
+    # nil for none.
+    def self.of(machine)
+      ALL.find do |model|
+        model.vic_model == machine.vic_model && model.cia_model == machine.cia_model &&
+          model.sid_model == machine.sid_model && model.region == machine.region &&
+          model.kernal == machine.kernal && model.datasette == machine.datasette
+      end
+    end
+  end
+end

data/lib/badline/options/event.rb

@@ -17,8 +17,8 @@ module Badline
 
       EJECTABLE = %w[disk tape cartridge].freeze
 
-      # What insert takes: disk images, tapes and cartridges, or a
-      # directory to mount as device 8.
+      # What insert takes: disk images, tapes and cartridges, or an .m3u
+      # or .vfl list of disks or a directory to mount as device 8.
       INSERTABLE = %w[.d64 .d71 .d81 .g64 .t64 .tap .crt].freeze
 
       attr_reader :frame, :action, :argument
@@ -87,7 +87,9 @@ module Badline
       end
 
       def self.insertable?(path)
-        File.directory?(path) || (File.exist?(path) && INSERTABLE.include?(File.extname(path).downcase))
+        return true if File.directory?(path)
+
+        File.exist?(path) && (INSERTABLE.include?(File.extname(path).downcase) || Media::DiskList.list?(path))
       end
     end
   end

data/lib/badline/options/help.rb

@@ -43,14 +43,18 @@ module Badline
                #{@program} sid [options] FILE|DIR...
 
         Media can be a .prg/.p00 program, a .d64/.d71/.d81 disk image, a
-        .g64 disk image for the true 1541, a .t64 tape archive, a .tap
-        tape, a .crt cartridge, a .sid tune, a .vsf snapshot, or a directory
-        to mount as device 8. It opens in the emulator window, where F11
-        saves a snapshot and F12 restores it. Device 8 answers through
-        traps on the KERNAL's disk routines, unless --true-drive puts an
-        emulated 1541 there, which runs its own DOS and reads .d64 and .g64
-        images only. A .sid tune opens in the SID player, as `sid` plays it,
-        unless an option of the emulator's window asks for the machine.
+        .g64 disk image for the true 1541, an .m3u or .vfl list of disk
+        images, a .t64 tape archive, a .tap tape, a .crt cartridge, a .sid
+        tune, a .vsf snapshot, or a directory to mount as device 8. It
+        opens in the emulator window. There F11 quicksaves the machine to
+        the next of five slots in badline's data folder, replacing the
+        oldest, and F12 restores the newest quicksave or named save. The
+        window also autosaves every two minutes of play, which only the
+        pause menu loads. Device 8 answers through traps on the KERNAL's
+        disk routines, unless --true-drive puts an emulated 1541 there,
+        which runs its own DOS and reads .d64 and .g64 images only. A .sid
+        tune opens in the SID player, as `sid` plays it, unless an option
+        of the emulator's window asks for the machine.
 
         --headless plays a .sid tune on the host's audio device without the
         window, and --audio-out renders it to 16-bit PCM instead. The
@@ -74,10 +78,10 @@ module Badline
         key=NAME presses a C64 key (space, return, a, f1, run_stop, restore)
         or a joystick's direction or fire (joy1-up, joy2-fire) for #{Event::HOLD}
         frames. type=TEXT types it, with \\n for RETURN. insert=FILE swaps
-        in a disk, tape or cartridge, and eject=disk, tape or cartridge
-        takes one out. screenshot=FILE saves the frame as a .bmp, with the
-        frame's number in place of %d. reset, freeze and quit take no
-        argument.
+        in a disk, a list's first disk, a tape or a cartridge, and
+        eject=disk, tape or cartridge takes one out. screenshot=FILE saves
+        the frame as a .bmp, with the frame's number in place of %d. reset,
+        freeze and quit take no argument.
       BANNER
     end
 

data/lib/badline/options/table.rb

@@ -4,6 +4,9 @@ module Badline
   class Options
     DEFAULT_RATE = 44_100
 
+    # The names Badline::Model builds, in the order the help lists them.
+    MODELS = %w[c64 c64c ntsc newntsc oldntsc drean sx64].freeze
+
     SECTIONS = ["Options", "Window options", "Options without the window", "Testing options"].freeze
 
     # Every option of both builds, in the order the help lists them.
@@ -16,7 +19,7 @@ module Badline
       Option.new("--version", "Show the version and what built it", section: "Options", build: :native),
       Option.new("--no-autostart", "Boot to READY. instead of running the program",
                  section: "Window options", needs: :window),
-      Option.new("--read-only", "Mount a disk image write-protected, leaving its file unchanged",
+      Option.new("--writable", "Let the machine write to disk images, changing their files",
                  section: "Window options", needs: :window),
       Option.new("--sound", "Play the SID through the host's audio device (F10 mutes)",
                  section: "Window options", needs: :window),
@@ -25,8 +28,9 @@ module Badline
                  section: "Window options", needs: :window),
       Option.new("--reu SIZE", "Plug in an REU of SIZE K: 128, 256, 512 (a 1750) or up to 16384",
                  section: "Window options", needs: :window),
-      Option.new("--ntsc", "Run an NTSC C64, with the 6567R8 VIC-II, instead of a PAL one",
+      Option.new("--model NAME", "C64 to run: #{MODELS.join(', ')} (default: #{MODELS.first})",
                  section: "Window options", needs: :window),
+      Option.new("--ntsc", "Run an NTSC C64, as --model ntsc does", section: "Window options", needs: :window),
       Option.new("--no-vsync", "Pace frames by the timer or the sound instead of the display",
                  section: "Window options", needs: :window),
       Option.new("--verbose", "Print the display, sound and gamepad setup and the frame timing",

data/lib/badline/options/validation.rb

@@ -10,6 +10,7 @@ module Badline
 
       def validate
         validate_mode
+        validate_models
         validate_numbers
         validate_paths
       end
@@ -33,6 +34,14 @@ module Badline
         raise Error, "not a .sid tune: #{path}"
       end
 
+      # --model and --ntsc may be given more than once, but only for one
+      # model.
+      def validate_models
+        unknown = @models.find { |name| !MODELS.include?(name) }
+        raise Error, "invalid argument: --model #{unknown}" unless unknown.nil?
+        raise Error, "conflicting models: #{@models.uniq.join(' and ')}" unless @models.uniq.size <= 1
+      end
+
       def validate_numbers
         positive("--subtune", @subtune)
         positive("--seconds", @seconds)

data/lib/badline/options.rb

@@ -59,16 +59,16 @@ module Badline
       @tune_paths = []
       @subtune = nil
       @sid_model = nil
+      @models = []
       @reu = nil
       @autostart = true
-      @read_only = false
+      @writable = false
       @sound = native
       @frames = 0
       @paced = true
       @vsync = true
       @verbose = false
       @true_drive = false
-      @ntsc = false
       @screenshot = ""
       @save_snapshot = ""
       @timeline = []
@@ -135,7 +135,7 @@ module Badline
 
     def autostart? = @autostart
 
-    def read_only? = @read_only
+    def writable? = @writable
 
     def sound? = @sound
 
@@ -147,10 +147,12 @@ module Badline
 
     def true_drive? = @true_drive
 
-    def ntsc? = @ntsc
-
     def jit? = @jit
 
+    # The name of the C64 to build (Badline::Model). --ntsc is short for
+    # --model ntsc.
+    def model = @models.empty? ? MODELS.first : @models.first
+
     def help? = @help
 
     def version? = @version
@@ -222,6 +224,7 @@ module Badline
       case name
       when "--subtune" then @subtune = number(flag, value)
       when "--sid" then @sid_model = sid_model_for(value)
+      when "--model" then @models << value
       when "--reu" then @reu = reu_size(value)
       when "--frames" then @frames = number(flag, value)
       when "--screenshot" then @screenshot = value
@@ -238,13 +241,13 @@ module Badline
     def switch(name)
       case name
       when "--no-autostart" then @autostart = false
-      when "--read-only" then @read_only = true
+      when "--writable" then @writable = true
       when "--sound" then @sound = true
       when "--no-sound" then @sound = false
       when "--no-vsync" then @vsync = false
       when "--verbose" then @verbose = true
       when "--true-drive" then @true_drive = true
-      when "--ntsc" then @ntsc = true
+      when "--ntsc" then @models << "ntsc"
       when "--unpaced" then @paced = false
       when "--disable-jit" then @jit = false
       when "--help" then @help = true

data/lib/badline/region.rb

@@ -21,8 +21,8 @@ module Badline
     # `sprite_cycle` is Bauer's cycle for sprite 0's p-access, and each
     # sprite after it takes two more. `sprite_display_cycle` is the cycle
     # that turns a sprite's display on or off. `x_hold` is how many pixels
-    # the X counter spends past its run, repeating $184-$187, and a raster
-    # of more than 512 pixels needs them.
+    # the X counter spends past its run, going over $180-$187 a second
+    # time, and a raster of more than 512 pixels needs them.
     Profile = Data.define(:name, :clock_hz, :cycles_per_line, :lines_per_frame, :hblank, :vblank,
                           :display_x_bounds, :crop, :mains_hz, :sprite_cycle, :sprite_display_cycle,
                           :x_hold)
@@ -40,8 +40,8 @@ module Badline
     # The 6567R8 of an NTSC C64: 65 cycles by 263 lines at 1,022,727 Hz,
     # with 60 Hz mains. The sprite fetches and the compares ahead of them
     # run a cycle later than on the 6569 (the spritesteal, spritex and
-    # phi1timing testprogs), and the X counter pauses near $184, as Bauer's
-    # 6567R8 diagram shows, reading $184-$187 for 8 pixels more. The
+    # phi1timing testprogs), and the X counter runs over $180-$187 twice,
+    # 8 pixels more, as the 6567R8's lightpen dump shows. The
     # blanked lines are the ones VICE's NTSC view leaves out, 12-27. It shows lines 0-11 below
     # line 262, and the crop leaves those out.
     NTSC = Profile.new(
@@ -65,6 +65,18 @@ module Badline
       sprite_cycle: 59, sprite_display_cycle: 58, x_hold: 0
     )
 
+    # The 6572 of the Drean C64, sold in Argentina on PAL-N: 65 cycles by
+    # 312 lines at 1,023,440 Hz, with 50 Hz mains. It lays out the line
+    # as the 6567R8 does, sprite fetches and X counter hold included
+    # (spritescan_drean), and blanks and crops lines as PAL does.
+    DREAN = Profile.new(
+      name: :drean, clock_hz: 1_023_440, cycles_per_line: 65, lines_per_frame: 312,
+      hblank: [63, 9].freeze, vblank: [300, 15].freeze,
+      display_x_bounds: [[135, 438].freeze, [128, 447].freeze].freeze,
+      crop: [96, 20, 384, 272].freeze, mains_hz: 50,
+      sprite_cycle: 59, sprite_display_cycle: 59, x_hold: 8
+    )
+
     # Whether a column or line lies in a [first, last] blanking span.
     def self.blanked?(position, span)
       first, last = span

data/lib/badline/reu/ram.rb

@@ -52,8 +52,35 @@ module Badline
         @banks.each_index { |number| @banks[number] = input.boolean? ? input.blob : [] }
       end
 
+      # Every byte, as one string, with a bank the REC hasn't touched at
+      # its power-on contents.
+      def contents
+        power_on = power_on_strings
+        Array.new(@banks.length) do |number|
+          bank = @banks[number]
+          bank.empty? ? power_on[(number >> 1) & 1] : bank.pack("C*")
+        end.join
+      end
+
+      # Takes every byte from a string as long as the RAM. A bank that
+      # holds its power-on contents stays untouched.
+      def restore(bytes)
+        power_on = power_on_strings
+        @banks.each_index do |number|
+          slice = bytes.byteslice(number * BANK_SIZE, BANK_SIZE).to_s
+          @banks[number] = slice == power_on[(number >> 1) & 1] ? [] : slice.bytes
+        end
+      end
+
       private
 
+      def power_on_strings
+        [0, 1].map do |half|
+          @power_on[half] = power_on_bank(half == 1) if @power_on[half].empty?
+          @power_on[half].pack("C*")
+        end
+      end
+
       # A bank takes its power-on contents the first time it is touched,
       # so an REU costs only the memory a program uses.
       def bank(number)

data/lib/badline/reu/saved_state.rb

@@ -32,6 +32,33 @@ module Badline
         @ram.load_state(input)
       end
 
+      # The sixteen bytes the REC's registers read from $DF00, without
+      # what reading the status does, as VICE's REU1764 module holds them.
+      def register_file = Array.new(16) { |register| register_value(register) }
+
+      # Sets the registers from a register file, as writing them would but
+      # without starting a transfer: each address and the length set both
+      # the counter and the value it starts from. A command with the
+      # execute bit set and the $FF00 trigger on arms the REC.
+      def restore_registers(values)
+        @status = (values[STATUS] & (INTERRUPT_PENDING | END_OF_BLOCK | FAULT)) | @chips
+        @command = values[COMMAND]
+        @c64 = @c64_start = values[C64_LOW] | (values[C64_HIGH] << 8)
+        @expansion = @expansion_start = values[EXPANSION_LOW] | (values[EXPANSION_HIGH] << 8)
+        @bank = @bank_start = values[EXPANSION_BANK] & @bank_bits
+        @length = @length_start = values[LENGTH_LOW] | (values[LENGTH_HIGH] << 8)
+        @interrupt_mask = values[INTERRUPT_MASK] | 0x1f
+        @address_control = values[ADDRESS_CONTROL] | 0x3f
+        @armed = @command.anybits?(EXECUTE) && @command.nobits?(NO_FF00_TRIGGER)
+        @requested = @running = @ba_was_low = false
+        interrupt(@status.anybits?(INTERRUPT_PENDING))
+      end
+
+      # The RAM, every byte of it, as one string.
+      def ram_contents = @ram.contents
+
+      def restore_ram(bytes) = @ram.restore(bytes)
+
       private
 
       def load_registers(input)