badline 0.9.0 → 0.10.0

data/lib/badline/media/vic20_media.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # Media on a VIC-20. A program loads once the KERNAL has booted: a
+    # BASIC program at the start of BASIC, wherever the RAM puts it, and
+    # RUNs. A program that loads into BLK5 at $A000 is a cartridge's ROM
+    # instead, as are the parts of a set that includes one
+    # (Vic20Cartridge), and goes in with a power cycle, as a .crt does.
+    # Disks mount on device 8 through the KERNAL traps, or go in a true
+    # 1541 (TrueDrive), and tapes play on the datasette.
+    module Vic20Media
+      # The expansions that fill BLK1, BLK2 and BLK3 one block after
+      # another, each with the last address it fills.
+      BLOCK_EXPANSIONS = [[0x3fff, :"8k"], [0x5fff, :"16k"], [0x7fff, :"24k"]].freeze
+
+      # What a VIC-20 doesn't take.
+      UNSUPPORTED = %w[.sid].freeze
+
+      # The platform byte of a VIC-20 tape (Storage::TAP#platform).
+      TAPE_PLATFORM = 1
+
+      class << self
+        def attach(machine, path, autostart:, **options)
+          extension = File.extname(path).downcase
+          raise ArgumentError, "#{path} doesn't go in a VIC-20" if UNSUPPORTED.include?(extension)
+
+          if TrueDrive.takes?(machine, path)
+            attach_true_drive(machine, path, options.fetch(:disk, {}), autostart:)
+          elsif File.directory?(path)
+            machine.mount(Storage::HostDirectory.new(path))
+            "Mounted #{path} as device 8"
+          elsif extension == ".crt"
+            attach_cartridge(machine, path, Storage::CRTFile.new(path, machine: :vic20).chips)
+          elsif extension == ".tap"
+            attach_tape(machine, path, autostart:)
+          elsif MOUNT_TYPES.key?(extension)
+            attach_storage(machine, path, options.fetch(:disk, {}), autostart:)
+          else
+            attach_prg(machine, path, autostart:)
+          end
+        end
+
+        # The RAM expansion (Vic20::Bus::RAM_CONFIGURATIONS) a VIC-20 needs
+        # for the program at `path`, or for the first program on the disk
+        # or in the directory there, by where it loads. A BASIC program
+        # needs the expansion its start of BASIC comes with, and more of
+        # BLK1 to BLK3 when it runs past $3FFF. So does a machine-language
+        # program loading into those blocks. Anything else, cartridges
+        # included, runs unexpanded.
+        def ram_for(path)
+          data = first_program(path)
+          return :unexpanded unless data && data.length > 2 && !Vic20Cartridge.chips(path, data)
+
+          load_addr = data[0] | (data[1] << 8)
+          if load_addr == 0x1201 || load_addr.between?(0x2000, 0x7fff)
+            expansion_reaching(load_addr + data.length - 3)
+          else
+            Vic20Basic::BASIC_STARTS.fetch(load_addr, :unexpanded)
+          end
+        end
+
+        private
+
+        def expansion_reaching(last)
+          BLOCK_EXPANSIONS.each { |reach, ram| return ram if last <= reach }
+          BLOCK_EXPANSIONS.last.last
+        end
+
+        def first_program(path)
+          extension = File.extname(path).downcase
+          if File.directory?(path) || MOUNT_TYPES.key?(extension)
+            open_storage(path).read_file("*")
+          elsif File.file?(path) && !%w[.sid .crt .tap .g64].include?(extension)
+            Vic20Cartridge.program_bytes(path)
+          end
+        end
+
+        def open_storage(path, disk = {})
+          return Storage::HostDirectory.new(path) if File.directory?(path)
+
+          storage = MOUNT_TYPES.fetch(File.extname(path).downcase)
+          storage < Storage::DiskImage ? storage.new(path, **disk) : storage.new(path)
+        end
+
+        def attach_cartridge(machine, path, chips)
+          machine.attach_cartridge(chips)
+          "Attached cartridge #{path}"
+        end
+
+        # A tape made for another machine plays all the same, and says so.
+        def attach_tape(machine, path, autostart:)
+          tape = Storage::TAP.new(path)
+          machine.datasette.insert(tape)
+          machine.datasette.play!
+          machine.type_text(TAPE_AUTOSTART) if autostart
+          message = "Inserted #{path} in the datasette"
+          tape.platform == TAPE_PLATFORM ? message : "#{message}, a tape for another machine than the VIC-20"
+        end
+
+        def attach_true_drive(machine, path, disk, autostart:)
+          message = TrueDrive.insert(machine, path, read_only: disk.fetch(:read_only, false))
+          machine.type_text(disk_autostart(first_program(path))) if autostart
+          message
+        end
+
+        def attach_storage(machine, path, disk, autostart:)
+          storage = open_storage(path, disk)
+          machine.mount(storage)
+          machine.type_text(disk_autostart(storage.read_file("*"))) if autostart
+          "Mounted #{path} as device 8"
+        end
+
+        # A BASIC program loads relocated to the start of BASIC, and anything
+        # else where it says.
+        def disk_autostart(data)
+          basic = data && data.length > 2 && Vic20Basic::BASIC_STARTS.key?(data[0] | (data[1] << 8))
+          basic ? %(lO"*",8\rrun\r) : AUTOSTART
+        end
+
+        def attach_prg(machine, path, autostart:)
+          bytes = Vic20Cartridge.program_bytes(path)
+          chips = Vic20Cartridge.chips(path, bytes)
+          return attach_cartridge(machine, path, chips) if chips
+
+          machine.on_init { Vic20Basic.load_program(machine, bytes, autostart:) }
+          "Loading #{path}"
+        end
+      end
+    end
+  end
+end

data/lib/badline/media.rb

@@ -4,6 +4,9 @@ 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
@@ -30,25 +33,13 @@ module Badline
       # 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)
+      # (DiskList). A machine other than the C64 takes its own media
+      # (Vic20Media).
+      def attach(computer, path, autostart: true, subtune: nil, **)
         path = DiskList.disk(path)
-        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
+        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,
@@ -69,6 +60,10 @@ 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 `otherwise`.
       def sid_model(path, otherwise: :mos6581)
@@ -79,6 +74,25 @@ module Badline
 
       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/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.
@@ -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"

data/lib/badline/options/help.rb

@@ -37,11 +37,17 @@ 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, an .m3u or .vfl list of disk
         images, a .t64 tape archive, a .tap tape, a .crt cartridge, a .sid
@@ -80,8 +86,10 @@ module Badline
         frames. type=TEXT types it, with \\n for RETURN. insert=FILE swaps
         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.
+        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

@@ -7,6 +7,14 @@ module Badline
     # 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.
@@ -28,9 +36,11 @@ 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("--model NAME", "C64 to run: #{MODELS.join(', ')} (default: #{MODELS.first})",
+      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),
       Option.new("--verbose", "Print the display, sound and gamepad setup and the frame timing",

data/lib/badline/options/validation.rb

@@ -2,13 +2,45 @@
 
 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
@@ -26,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")
@@ -37,7 +87,8 @@ module Badline
       # --model and --ntsc may be given more than once, but only for one
       # model.
       def validate_models
-        unknown = @models.find { |name| !MODELS.include?(name) }
+        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

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,12 +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
@@ -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?
@@ -149,9 +167,9 @@ module Badline
 
     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
+    # 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
 
@@ -165,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
@@ -226,6 +250,7 @@ module Badline
       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
@@ -259,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/roms/README

@@ -36,3 +36,30 @@ Both halves downloaded from
 https://www.zimmers.net/anonftp/pub/cbm/firmware/drives/new/1541/
 (1541-c000.325302-01.bin and 1541-e000.901229-05.bin) and concatenated.
 SHA-1 ab16f56989b27d89babe5f89c5a8cb3da71a82f0.
+
+Commodore VIC-20 ROMs
+=====================
+
+Downloaded from
+https://www.zimmers.net/anonftp/pub/cbm/firmware/computers/vic20/
+Vic20::Bus maps them.
+
+vic20/basic.rom
+---------------
+VIC-20 BASIC V2, 901486-01, for $C000-$DFFF.
+SHA-1 587d1e90950675ab6b12d91248a3f0d640d02e8d.
+
+vic20/kernal-pal.rom
+--------------------
+The PAL KERNAL, 901486-07, for $E000-$FFFF.
+SHA-1 ce0137ed69f003a299f43538fa9eee27898e621e.
+
+vic20/kernal-ntsc.rom
+---------------------
+The NTSC KERNAL, 901486-06, for $E000-$FFFF.
+SHA-1 06de7ec017a5e78bd6746d89c2ecebb646efeb19.
+
+vic20/character.rom
+-------------------
+The character generator ROM, 901460-03, for $8000-$8FFF.
+SHA-1 4fd85ab6647ee2ac7ba40f729323f2472d35b9b4.

data/lib/badline/snapshot/container.rb

@@ -26,6 +26,8 @@ module Badline
       FORMAT_MINOR = 0
       # x64sc names its machine C64SC, and refuses a snapshot naming another.
       MACHINE = "C64SC"
+      # xvic names its machine VIC20.
+      VIC20 = "VIC20"
       GZIP_MAGIC = "\x1f\x8b".b
 
       # The VICE version block, when VICE wrote the file: four version

data/lib/badline/snapshot/image.rb

@@ -28,11 +28,16 @@ module Badline
       # modules badline reads. Yields a line for each thing left out, or
       # warns it without a block.
       def load(&)
+        return load_vic20(&) if vic20?
+
         computer = badline? ? opening { Computer.restored(state) } : Vice.setup(@container).build
         tell(badline? ? state_report(computer) : Vice::Restore.apply(@container, computer), &)
         computer
       end
 
+      # Whether the machine is a VIC-20, as the container names it.
+      def vic20? = @container.machine == Container::VIC20
+
       # Restores `computer` from the snapshot, and returns the Report. A
       # snapshot that fails leaves the machine as it was.
       def restore(computer, &)
@@ -45,6 +50,16 @@ module Badline
 
       def section = @container[MachineState::NAME]
 
+      # A VIC-20 restores from its BADLINE module alone. xvic's own modules
+      # aren't read.
+      def load_vic20(&)
+        raise FormatError, "badline reads only its own VIC-20 snapshots, not xvic's" unless badline?
+
+        machine = Vic20.restored(state)
+        tell(state_report(machine), &)
+        machine
+      end
+
       def tell(report)
         report.ignored.each { |line| block_given? ? yield(line) : warn("badline: #{line}") }
       end

data/lib/badline/snapshot/state.rb

@@ -14,9 +14,10 @@ module Badline
       # The layout the chips write their fields in. It goes up whenever a
       # save_state writes something else, so a State in another layout
       # fails before anything is read into a machine. Layout 3, without the
-      # KERNAL and datasette in the setup, still reads.
-      SCHEMA = 4
-      READABLE = [3, SCHEMA].freeze
+      # KERNAL and datasette in the setup, and layout 4, without the VIA
+      # shift register's clock delay, still read.
+      SCHEMA = 5
+      READABLE = [3, 4, SCHEMA].freeze
 
       attr_reader :values, :strings
 

data/lib/badline/snapshot.rb

@@ -27,8 +27,12 @@ module Badline
       path
     end
 
+    # A VIC-20's snapshot holds the BADLINE module alone, in a container
+    # named as xvic names its machine.
     def dump(computer)
       state = computer.snapshot
+      return Container.new([MachineState.section(state)], machine: Container::VIC20).to_s if computer.family == :vic20
+
       Container.new(Vice.export(state) + [MachineState.section(state)]).to_s
     end
 
@@ -49,4 +53,10 @@ module Badline
 
     def restore_snapshot(path, &) = Snapshot.restore(self, path, &)
   end
+
+  class Vic20
+    def save_snapshot(path) = Snapshot.save(self, path)
+
+    def restore_snapshot(path, &) = Snapshot.restore(self, path, &)
+  end
 end