badline 0.8.0 → 0.10.0

data/lib/badline/media.rb

@@ -3,6 +3,10 @@
 require "badline/media/true_drive"
 require "badline/media/queue"
 require "badline/media/disk_set"
+require "badline/media/disk_list"
+require "badline/media/vic20_basic"
+require "badline/media/vic20_cartridge"
+require "badline/media/vic20_media"
 
 module Badline
   module Media
@@ -27,23 +31,15 @@ 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.
-      def attach(computer, path, autostart: true, subtune: nil, **options)
-        if TrueDrive.takes?(computer, path)
-          attach_true_drive(computer, path, options.fetch(:disk, {}), autostart:)
-        elsif File.directory?(path)
-          computer.mount(Storage::HostDirectory.new(path))
-          "Mounted #{path} as device 8"
-        elsif File.extname(path).downcase == ".crt"
-          attach_cartridge(computer, path, options.fetch(:cartridge, {}))
-        elsif File.extname(path).downcase == ".sid"
-          attach_sid(computer, path, autostart:, subtune:)
-        elsif File.extname(path).downcase == ".tap"
-          attach_tape(computer, path, autostart:)
-        elsif MOUNT_TYPES.key?(File.extname(path).downcase)
-          attach_storage(computer, path, options.fetch(:disk, {}), autostart:)
-        else
-          attach_prg(computer, path, autostart:)
-        end
+      #
+      # An .m3u or .vfl list of disks attaches the first disk it lists
+      # (DiskList). A machine other than the C64 takes its own media
+      # (Vic20Media).
+      def attach(computer, path, autostart: true, subtune: nil, **)
+        path = DiskList.disk(path)
+        return Vic20Media.attach(computer, path, autostart:, **) unless computer.is_a?(Computer)
+
+        attach_c64(computer, path, autostart:, subtune:, **)
       end
 
       # Swaps the disk in device 8 for a disk image or a host directory,
@@ -64,16 +60,39 @@ module Badline
         "Inserted #{path} in device 8"
       end
 
+      # The RAM expansion a VIC-20 for `path` should be built with
+      # (Vic20Media.ram_for), a key of Vic20::Bus::RAM_CONFIGURATIONS.
+      def vic20_ram_for(path) = Vic20Media.ram_for(path)
+
       # 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
 
       private
 
+      def attach_c64(computer, path, autostart:, subtune:, **options)
+        if TrueDrive.takes?(computer, path)
+          attach_true_drive(computer, path, options.fetch(:disk, {}), autostart:)
+        elsif File.directory?(path)
+          computer.mount(Storage::HostDirectory.new(path))
+          "Mounted #{path} as device 8"
+        elsif File.extname(path).downcase == ".crt"
+          attach_cartridge(computer, path, options.fetch(:cartridge, {}))
+        elsif File.extname(path).downcase == ".sid"
+          attach_sid(computer, path, autostart:, subtune:)
+        elsif File.extname(path).downcase == ".tap"
+          attach_tape(computer, path, autostart:)
+        elsif MOUNT_TYPES.key?(File.extname(path).downcase)
+          attach_storage(computer, path, options.fetch(:disk, {}), autostart:)
+        else
+          attach_prg(computer, path, autostart:)
+        end
+      end
+
       def disk?(path)
         storage = MOUNT_TYPES[File.extname(path).downcase]
         File.directory?(path) || (!storage.nil? && storage < Storage::DiskImage)

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

@@ -6,10 +6,11 @@ module Badline
     # `frame` frames have run. An event given at several frames becomes
     # one Event per frame.
     class Event
-      # The actions, and whether each takes an argument.
+      # The actions, and whether each takes an argument. menu's page may be
+      # left out.
       ACTIONS = {
-        "key" => true, "type" => true, "insert" => true, "eject" => true, "screenshot" => true,
-        "reset" => false, "freeze" => false, "quit" => false
+        "key" => true, "type" => true, "insert" => true, "eject" => true, "screenshot" => true, "menu" => true,
+        "reset" => false, "freeze" => false, "resume" => false, "quit" => false
       }.freeze
 
       # The frames a key or the freeze button is held for.
@@ -17,8 +18,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
@@ -79,6 +80,7 @@ module Badline
 
       def self.valid?(action, argument)
         return false unless ACTIONS.key?(action)
+        return true if action == "menu"
         return argument.empty? unless ACTIONS[action]
         return EJECTABLE.include?(argument) if action == "eject"
         return insertable?(argument) if action == "insert"
@@ -87,7 +89,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

@@ -37,20 +37,30 @@ module Badline
 
     def banner
       <<~BANNER
-        Usage: #{@program} [options] [media]
+        Usage: #{@program} [c64] [options] [media]
+               #{@program} vic20 [options] [media]
                #{@program} --headless [options] tune.sid
                #{@program} [options] tune.sid --audio-out FILE
                #{@program} sid [options] FILE|DIR...
 
+        Commands:
+            c64                              Run a C64, the one --model names (the default)
+            vic20                            Run a PAL VIC-20, with the RAM --ram names
+            sid                              Play .sid tunes and directories of them
+
         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 +84,12 @@ 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. menu
+        opens the pause menu, and menu=PAGE opens it on snapshots, drive,
+        datasette, expansion, ports, sound or power. Its frames still count,
+        and resume closes it. reset, freeze and quit take no argument.
       BANNER
     end
 

data/lib/badline/options/table.rb

@@ -4,6 +4,17 @@ 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
+
+    # The VIC-20's models, as xvic names its video standards. Only PAL is
+    # emulated.
+    VIC20_MODELS = %w[pal ntsc].freeze
+
+    # The VIC-20 RAM expansions --ram takes, in the order the help lists
+    # them.
+    RAM_NAMES = %w[unexpanded 3k 8k 16k 24k 32k all].freeze
+
     SECTIONS = ["Options", "Window options", "Options without the window", "Testing options"].freeze
 
     # Every option of both builds, in the order the help lists them.
@@ -25,7 +36,10 @@ 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}); VIC-20: pal",
+                 section: "Window options", needs: :window),
+      Option.new("--ntsc", "Run an NTSC C64, as --model ntsc does", section: "Window options", needs: :window),
+      Option.new("--ram SIZE", "VIC-20 RAM expansion: #{RAM_NAMES.join(', ')} (default: unexpanded)",
                  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),

data/lib/badline/options/validation.rb

@@ -2,14 +2,47 @@
 
 module Badline
   class Options
-    # The checks Options#parse makes once every argument has been read:
-    # the options fit the mode, the numbers are positive and the files
-    # exist.
+    # The checks Options#parse makes: that each value reads as its option
+    # takes it, and once every argument has been read, that the options
+    # fit the mode, the numbers are positive and the files exist.
     module Validation
       private
 
+      def sid_model_for(value)
+        return if value == "auto"
+        raise Error, "invalid argument: --sid #{value}" unless SID_MODELS.key?(value)
+
+        SID_MODELS[value]
+      end
+
+      def ram_configuration(value)
+        raise Error, "invalid argument: --ram #{value}" unless RAM_CONFIGURATIONS.key?(value)
+
+        RAM_CONFIGURATIONS[value]
+      end
+
+      def reu_size(value)
+        raise Error, "invalid argument: --reu #{value}" unless REU_SIZES.include?(value)
+
+        value.to_i
+      end
+
+      def number(flag, value)
+        raise Error, "invalid argument: #{flag} #{value}" unless value.match?(/\A\d+\z/)
+
+        value.to_i
+      end
+
+      def decimal(flag, value)
+        raise Error, "invalid argument: #{flag} #{value}" unless value.match?(DECIMAL)
+
+        value.to_f
+      end
+
       def validate
+        validate_family
         validate_mode
+        validate_models
         validate_numbers
         validate_paths
       end
@@ -25,6 +58,24 @@ module Badline
         end
       end
 
+      def validate_family
+        if @family == :vic20
+          validate_vic20
+        elsif !@ram.nil?
+          raise Error, "--ram needs vic20"
+        end
+      end
+
+      # The VIC-20 is a PAL one, in the window, without the C64's SID and
+      # REU.
+      def validate_vic20
+        raise Error, "the NTSC VIC-20 isn't emulated yet" if @models.include?("ntsc")
+
+        raise Error, "--sid needs the C64" unless @sid_model.nil?
+        raise Error, "--reu needs the C64" unless @reu.nil?
+        raise Error, "the VIC-20 needs the window" if headless?
+      end
+
       # `sid` takes directories as well as tunes.
       def validate_tune(path)
         return if !File.exist?(path) || File.extname(path).casecmp?(".sid")
@@ -33,6 +84,15 @@ 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
+        names = @family == :vic20 ? VIC20_MODELS : MODELS
+        unknown = @models.find { |name| !names.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

@@ -10,7 +10,9 @@ module Badline
   # The command line of both builds, badline-ruby and the native badline.
   # Either opens the window for any media, or with --headless or
   # --audio-out plays or renders a .sid tune without one. `sid`, given
-  # first, plays .sid tunes and directories of them in the terminal. The
+  # first, plays .sid tunes and directories of them in the terminal.
+  # `c64` or `vic20`, given first, names the machine family, and without
+  # either the family is the C64. The
   # native build adds --no-sound and --version, and badline-ruby adds
   # --disable-jit.
   #
@@ -37,6 +39,13 @@ module Badline
 
     REU_SIZES = %w[128 256 512 1024 2048 4096 8192 16384].freeze
 
+    # The VIC-20's RAM expansions as --ram names them (RAM_NAMES), and the
+    # names Vic20::Bus::RAM_CONFIGURATIONS gives them.
+    RAM_CONFIGURATIONS = {
+      "unexpanded" => :unexpanded, "3k" => :"3k", "8k" => :"8k", "16k" => :"16k", "24k" => :"24k",
+      "32k" => :"32k", "all" => :all
+    }.freeze
+
     # A Float as OptionParser took one: digits with an optional sign,
     # fraction and exponent.
     DECIMAL = /\A[-+]?(\d+(\.\d+)?|\.\d+)([eE][-+]?\d+)?\z/
@@ -46,6 +55,13 @@ module Badline
     attr_reader :program, :media_path, :tune_paths, :subtune, :sid_model, :reu, :frames, :screenshot, :save_snapshot,
                 :audio_out, :seconds, :songlengths, :filter_chunk, :timeline
 
+    # The machine family to build (Badline::Machine), :c64 or :vic20.
+    attr_reader :family
+
+    # The VIC-20's RAM expansion --ram names, a key of
+    # Vic20::Bus::RAM_CONFIGURATIONS, or nil without --ram.
+    attr_reader :ram
+
     def self.parse(argv, native: false) = new(native:).parse(argv)
 
     # The native build plays the SID in the window unless --no-sound says
@@ -55,11 +71,14 @@ module Badline
       @native = native
       @program = native ? "badline" : "badline-ruby"
       @media_path = nil
+      @family = :c64
       @sid_command = false
       @tune_paths = []
       @subtune = nil
       @sid_model = nil
+      @models = []
       @reu = nil
+      @ram = nil
       @autostart = true
       @writable = false
       @sound = native
@@ -68,7 +87,6 @@ module Badline
       @vsync = true
       @verbose = false
       @true_drive = false
-      @ntsc = false
       @screenshot = ""
       @save_snapshot = ""
       @timeline = []
@@ -90,7 +108,7 @@ module Badline
 
     def parse(argv)
       args = argv.dup
-      sid_command(args) if args.first == "sid"
+      subcommand(args)
       argument(args.shift, args) until args.empty?
       play_lone_tune
       validate unless help? || version?
@@ -147,10 +165,12 @@ module Badline
 
     def true_drive? = @true_drive
 
-    def ntsc? = @ntsc
-
     def jit? = @jit
 
+    # The name of the model to build: a C64 Badline::Model names, or a
+    # VIC-20 of VIC20_MODELS. --ntsc is short for --model ntsc.
+    def model = @models.first || (@family == :vic20 ? VIC20_MODELS.first : MODELS.first)
+
     def help? = @help
 
     def version? = @version
@@ -163,15 +183,21 @@ module Badline
       [:both, @native ? :native : :ruby].include?(option.build)
     end
 
-    def sid_command(args)
+    # Takes `sid`, `c64` or `vic20` when given first.
+    def subcommand(args)
+      case args.first
+      when "sid" then @sid_command = true
+      when "c64" then @family = :c64
+      when "vic20" then @family = :vic20
+      else return
+      end
       args.shift
-      @sid_command = true
     end
 
     # A .sid on its own plays in the SID player, as `sid` would, unless an
     # option of the emulator's window asks for the machine.
     def play_lone_tune
-      return if @sid_command || headless? || !@window_only.empty? || @media_path.nil?
+      return if @sid_command || @family == :vic20 || headless? || !@window_only.empty? || @media_path.nil?
 
       @sid_command = File.extname(@media_path).casecmp?(".sid")
     end
@@ -222,7 +248,9 @@ 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 "--ram" then @ram = ram_configuration(value)
       when "--frames" then @frames = number(flag, value)
       when "--screenshot" then @screenshot = value
       when "--save-snapshot" then @save_snapshot = value
@@ -244,7 +272,7 @@ module Badline
       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
@@ -256,31 +284,6 @@ module Badline
       end
     end
 
-    def sid_model_for(value)
-      return if value == "auto"
-      raise Error, "invalid argument: --sid #{value}" unless SID_MODELS.key?(value)
-
-      SID_MODELS[value]
-    end
-
-    def reu_size(value)
-      raise Error, "invalid argument: --reu #{value}" unless REU_SIZES.include?(value)
-
-      value.to_i
-    end
-
-    def number(flag, value)
-      raise Error, "invalid argument: #{flag} #{value}" unless value.match?(/\A\d+\z/)
-
-      value.to_i
-    end
-
-    def decimal(flag, value)
-      raise Error, "invalid argument: #{flag} #{value}" unless value.match?(DECIMAL)
-
-      value.to_f
-    end
-
     def media_argument(arg)
       raise Error, "unexpected argument: #{arg}" unless @sid_command || @media_path.nil?
 

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)