badline 0.12.0 → 0.12.1

data/lib/badline/machine.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "badline/machine/clocking"
+
 module Badline
   # = Machine
   #
@@ -44,16 +46,22 @@ module Badline
   # +press_caps_lock+, +release_caps_lock+, +press_display_key+,
   # +release_display_key+, and +attach_drive1571+ and +drive1571+ for the
   # C128D's 1571, its true drive.
+  #
+  # Each machine includes Machine::Clocking for the clocking part.
   module Machine
+    # Media the machine named doesn't take.
+    class Unsupported < ArgumentError; end
+
     # A new machine of `family`, :c64, :vic20 or :c128, the model of it
     # `model` names. A C64's model is one of Model::ALL, with its SID
     # `sid_model` when not nil and an REU of `reu` K when not nil. A
     # VIC-20's is "pal", with the RAM expansion `ram` names
     # (Vic20::Bus::RAM_CONFIGURATIONS), unexpanded when nil. A C128's is
-    # one of C128::Model::ALL, with its SID `sid_model` when not nil.
+    # one of C128::Model::ALL, with its SID `sid_model` when not nil, built
+    # for C64 mode.
     def self.build(family, model:, sid_model: nil, reu: nil, ram: nil)
       return vic20(model, ram) if family == :vic20
-      return C128.new(model:, sid_model:) if family == :c128
+      return c128(model, sid_model, :c64) if family == :c128
       raise ArgumentError, "no machine family named #{family}" unless family == :c64
 
       profile = Model.named(model)
@@ -62,11 +70,59 @@ module Badline
                    kernal: profile.kernal, datasette: profile.datasette, board: profile.board)
     end
 
+    # The machine the command line's `options` name, to start `media`, a
+    # path or nil. A C64 or a C128 without a SID named takes the one a .sid
+    # tune names. The C128 is built for C128 mode, with C= held through the
+    # reset, so its KERNAL starts C64 mode, for --c64 (+c64_mode?+) or media
+    # only C64 mode runs: a .sid tune or a program that loads at the C64's
+    # BASIC start. A VIC-20 without RAM named gets the expansion the media
+    # needs (Media::Vic20Media.ram_for) and yields a line saying so. Raises
+    # Unsupported for media a VIC-20 doesn't take.
+    def self.for_options(options, media, &)
+      family = options.family
+      return vic20_for(media, options.model, options.ram, &) if family == :vic20
+
+      sid_model = options.sid_model || Media.sid_model(media, otherwise: nil)
+      return build(:c64, model: options.model, sid_model:, reu: options.reu) unless family == :c128
+
+      machine = c128(options.model, sid_model, :c128)
+      machine.hold_commodore_key if options.c64_mode? || c64_media?(media)
+      machine
+    end
+
     def self.vic20(model, ram)
       raise ArgumentError, "no VIC-20 model named #{model}" unless model == "pal"
 
       Vic20.new(ram: ram || :unexpanded)
     end
     private_class_method :vic20
+
+    def self.c128(model, sid_model, mode) = C128.new(model:, sid_model:, mode:)
+    private_class_method :c128
+
+    def self.vic20_for(media, model, ram)
+      unless media.nil?
+        unsupported = Media::Vic20Media::UNSUPPORTED.include?(File.extname(media).downcase)
+        raise Unsupported, "doesn't go in a VIC-20" if unsupported
+
+        unless ram
+          ram = Media::Vic20Media.ram_for(media)
+          yield "RAM expansion: #{ram}"
+        end
+      end
+      build(:vic20, model:, ram:)
+    end
+    private_class_method :vic20_for
+
+    def self.c64_media?(media)
+      return false if media.nil? || !File.file?(media)
+
+      extension = File.extname(media).downcase
+      return true if extension == ".sid"
+      return false unless %w[.prg .p00].include?(extension)
+
+      [Media::BASIC_START, Media::BASIC_START - 1].include?(Storage::P00.load_address(media))
+    end
+    private_class_method :c64_media?
   end
 end

data/lib/badline/media/boot_disk.rb

@@ -15,7 +15,7 @@ module Badline
     module BootDisk
       SIGNATURE = "CBM".bytes.freeze
       AUTO_BOOT = "copyright cbm 86"
-      TYPES = %w[.d64 .d71 .d81].freeze
+      TYPES = Extensions.of(%i[disk])
 
       class << self
         def takes?(computer, path)
@@ -38,7 +38,7 @@ module Badline
           type = File.extname(path).downcase
           return false unless TYPES.include?(type) && File.file?(path)
 
-          image = MOUNT_TYPES.fetch(type).new(path, read_only: true)
+          image = Media.open_storage(path, { read_only: true })
           block = image.read_block(1, 0)
           return true if block && block[0, 3] == SIGNATURE
 

data/lib/badline/media/disk_list.rb

@@ -11,9 +11,9 @@ module Badline
       # A list naming no disk image that's there.
       class Error < ArgumentError; end
 
-      EXTENSIONS = %w[.m3u .vfl].freeze
+      EXTENSIONS = Extensions.of(%i[disk_list])
 
-      def self.list?(path) = EXTENSIONS.include?(File.extname(path).downcase)
+      def self.list?(path) = Extensions.kind(path) == :disk_list
 
       # The disk `path` puts in the drive: a list's first disk, or the
       # path itself.
@@ -32,7 +32,7 @@ module Badline
         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)
+          found << disk if Extensions::DISKS.include?(File.extname(disk).downcase) && File.file?(disk)
         end
         found
       end

data/lib/badline/media/disk_set.rb

@@ -13,7 +13,7 @@ module Badline
     # ahead of the names.
     module DiskSet
       KINDS = %w[disk disc side part].freeze
-      EXTENSIONS = %w[.d64 .d71 .d81 .g64].freeze
+      EXTENSIONS = Extensions::DISKS
 
       # 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.

data/lib/badline/media/extensions.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # The kind of medium each file extension names, which every check of a
+    # path's extension reads. A file with any other extension is a program.
+    # It loads on its own, for Options.
+    #
+    # - :disk, a disk image that the traps mount and a true drive reads
+    # - :gcr, a disk's raw GCR, which only a true drive reads
+    # - :archive, a .t64, which the traps mount read-only
+    # - :tape, :cartridge and :tune
+    # - :disk_list, a list of the disks of a set (DiskList)
+    module Extensions
+      KINDS = {
+        ".d64" => :disk, ".d71" => :disk, ".d81" => :disk, ".g64" => :gcr, ".g71" => :gcr, ".t64" => :archive,
+        ".tap" => :tape, ".crt" => :cartridge, ".sid" => :tune, ".m3u" => :disk_list, ".vfl" => :disk_list
+      }.freeze
+
+      # The kind of the medium at `path`, by its extension.
+      def self.kind(path) = KINDS.fetch(File.extname(path).downcase, :program)
+
+      # The extensions of the kinds given.
+      def self.of(kinds) = KINDS.keys.select { |extension| kinds.include?(KINDS[extension]) }.freeze
+
+      # Disk images, which a drive reads.
+      DISKS = of(%i[disk gcr])
+
+      # What goes in device 8 through the traps.
+      MOUNTABLE = of(%i[disk archive])
+    end
+  end
+end

data/lib/badline/media/program.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # A program loading into a C64 or a C128 once it has booted
+    # (Media.attach). The VIC-20 has its own (Vic20Basic).
+    module Program
+      class << self
+        # Loads the program where it says, and RUNs one that loads at the
+        # start of BASIC.
+        def load(computer, data, autostart:)
+          load_addr = computer.load_prg(data)
+          # Run only makes sense for programs at BASIC start, or a byte ahead
+          # of it, where BASIC keeps the zero before its first line. BASIC 7.0
+          # starts at $1C01 and keeps the end of its text at $1210.
+          start, text_end = computer.family == :c128 && computer.mode == :c128 ? [0x1c01, 0x1210] : [BASIC_START, 0x2d]
+          return unless autostart && (load_addr == start || load_addr == start - 1)
+
+          # The end of the program, where BASIC's variables start, and where
+          # the KERNAL's LOAD leaves its end address.
+          end_addr = load_addr + data.length - 2
+          [text_end, 0xae].each { |pointer| computer.ram.write(pointer, [end_addr & 0xff, end_addr >> 8]) }
+          computer.type_text("run\r")
+        end
+      end
+    end
+  end
+end

data/lib/badline/media/true_drive.rb

@@ -32,9 +32,10 @@ module Badline
         # other disk media, which the traps would mount, when a true drive
         # is device 8.
         def takes?(computer, path)
-          return true if %w[.g64 .g71].include?(File.extname(path).downcase)
+          kind = Extensions.kind(path)
+          return true if kind == :gcr
 
-          !drive(computer).nil? && (File.directory?(path) || MOUNT_TYPES.key?(File.extname(path).downcase))
+          !drive(computer).nil? && (File.directory?(path) || %i[disk archive].include?(kind))
         end
 
         # Puts the image in the drive on device 8, plugging one in that

data/lib/badline/media/tune.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # A .sid tune on a machine with a SID (Media.attach): its data and the
+    # player the tune boots with go in RAM once the KERNAL has booted, and
+    # the autostart types what starts it.
+    module Tune
+      class << self
+        # Plays `subtune`, or the tune's own start subtune, and says what
+        # plays. A tune for more than one SID raises FormatError.
+        def attach(computer, path, autostart:, subtune:)
+          tune = Storage::SIDFile.new(path)
+          if tune.sids > 1
+            raise Storage::SIDFile::FormatError, "Written for #{tune.sids} SIDs, which only the SID player plays"
+          end
+
+          subtune = (subtune || tune.start_subtune).clamp(1, tune.subtunes)
+          computer.on_init { start(computer, tune, autostart:, subtune:) }
+          title = tune.name.empty? ? path : tune.name
+          title += " (subtune #{subtune})" if tune.subtunes > 1
+          autostart ? "Playing #{title}" : "Loaded #{title}"
+        end
+
+        private
+
+        def start(computer, tune, autostart:, subtune:)
+          computer.ram.write(tune.load_address, tune.data)
+          tune.boot_memory(subtune:).each { |address, bytes| computer.ram.write(address, bytes) }
+          computer.type_text(tune.boot_command) if autostart
+        end
+      end
+    end
+  end
+end

data/lib/badline/media/vic20_cartridge.rb

@@ -26,12 +26,6 @@ module Badline
           parts.map { |part| rom_chip(part) }
         end
 
-        # A program's bytes, unwrapped from a .p00.
-        def program_bytes(path)
-          bytes = File.binread(path).bytes
-          Storage::P00.wraps?(bytes) ? Storage::P00.data(bytes) : bytes
-        end
-
         private
 
         def load_address(data)
@@ -42,7 +36,7 @@ module Badline
           name = part_names(path, own, address).find { |candidate| File.file?(candidate) }
           return unless name
 
-          part = program_bytes(name)
+          part = Media.program_bytes(name)
           part if load_address(part) == address
         end
 

data/lib/badline/media/vic20_media.rb

@@ -2,45 +2,25 @@
 
 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.
+    # What a VIC-20 does with media of its own (Media.attach). 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
+      UNSUPPORTED = Extensions.of(%i[tune])
 
       # 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
@@ -60,72 +40,50 @@ module Badline
           end
         end
 
-        private
-
-        def expansion_reaching(last)
-          BLOCK_EXPANSIONS.each { |reach, ram| return ram if last <= reach }
-          BLOCK_EXPANSIONS.last.last
-        end
-
+        # The program at `path`, or the first on the disk or in the
+        # directory there, or nil.
         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)
+          kind = Extensions.kind(path)
+          if File.directory?(path) || %i[disk archive].include?(kind)
+            Media.open_storage(path).read_file("*")
+          elsif File.file?(path) && !%i[tune cartridge tape gcr].include?(kind)
+            Media.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.
+        # What loads and runs `data`, the first program on the disk in
+        # device 8: 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)
+        # Loads the program, `bytes` from the file at `path`, as Vic20Basic
+        # has it once the KERNAL has booted, or attaches the cartridge it's
+        # a part of (Vic20Cartridge), and says which.
+        def attach_program(machine, path, bytes, autostart:)
           chips = Vic20Cartridge.chips(path, bytes)
-          return attach_cartridge(machine, path, chips) if chips
+          if chips
+            machine.attach_cartridge(chips)
+            return "Attached cartridge #{path}"
+          end
 
           machine.on_init { Vic20Basic.load_program(machine, bytes, autostart:) }
           "Loading #{path}"
         end
+
+        # A tape made for another machine plays all the same, and says so.
+        def tape_message(tape, message)
+          tape.platform == TAPE_PLATFORM ? message : "#{message}, a tape for another machine than the VIC-20"
+        end
+
+        private
+
+        def expansion_reaching(last)
+          BLOCK_EXPANSIONS.each { |reach, ram| return ram if last <= reach }
+          BLOCK_EXPANSIONS.last.last
+        end
       end
     end
   end

data/lib/badline/media.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "badline/media/extensions"
 require "badline/media/true_drive"
 require "badline/media/boot_disk"
 require "badline/media/not_disk"
@@ -9,6 +10,8 @@ require "badline/media/disk_list"
 require "badline/media/vic20_basic"
 require "badline/media/vic20_cartridge"
 require "badline/media/vic20_media"
+require "badline/media/tune"
+require "badline/media/program"
 
 module Badline
   module Media
@@ -16,6 +19,7 @@ module Badline
     TAPE_AUTOSTART = %(lO\rrun\r)
     BASIC_START = 0x0801
 
+    # The storage that opens each of Extensions::MOUNTABLE.
     MOUNT_TYPES = {
       ".d64" => Storage::D64Image,
       ".d71" => Storage::D71Image,
@@ -38,13 +42,17 @@ module Badline
       # KERNAL to boot at power-on, with nothing typed (BootDisk).
       #
       # An .m3u or .vfl list of disks attaches the first disk it lists
-      # (DiskList). The VIC-20 takes its own media (Vic20Media), and the
-      # C128 in C64 mode a C64's.
+      # (DiskList). Every machine takes each kind of medium the same way,
+      # except that the VIC-20 (Vic20Media) has cartridges, programs and a
+      # disk autostart of its own, and takes no .sid tunes. The C128 in C64
+      # mode takes a C64's.
       def attach(computer, path, autostart: true, subtune: nil, **)
         path = DiskList.disk(path)
-        return Vic20Media.attach(computer, path, autostart:, **) if computer.family == :vic20
+        if computer.family == :vic20 && Vic20Media::UNSUPPORTED.include?(File.extname(path).downcase)
+          raise ArgumentError, "#{path} doesn't go in a VIC-20"
+        end
 
-        BootDisk.attach(computer, path, **) || attach_c64(computer, path, autostart:, subtune:, **)
+        BootDisk.attach(computer, path, **) || attach_kind(computer, path, autostart:, subtune:, **)
       end
 
       # Swaps the disk in device 8 for a disk image or a host directory,
@@ -73,109 +81,104 @@ module Badline
       # 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)
-        return otherwise unless path && File.extname(path).downcase == ".sid"
+        return otherwise unless path && Extensions.kind(path) == :tune
 
         Storage::SIDFile.new(path).sid_model
       end
 
-      private
+      # What the medium at `path` is to `computer`, which attach goes by:
+      # :true_drive for a disk that goes in a true drive (TrueDrive),
+      # :directory, :storage for a disk image or a .t64 that the traps
+      # mount, and otherwise its kind by its extension (Extensions).
+      def kind(computer, path)
+        return :true_drive if TrueDrive.takes?(computer, path)
+        return :directory if File.directory?(path)
 
-      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
+        kind = Extensions.kind(path)
+        %i[disk archive].include?(kind) ? :storage : kind
       end
 
-      def disk?(path)
-        storage = MOUNT_TYPES[File.extname(path).downcase]
-        File.directory?(path) || (!storage.nil? && storage < Storage::DiskImage)
-      end
-
-      # Disk images take the `disk` options. A .t64 is read-only whatever
-      # it's given.
-      def open_storage(path, disk)
+      # What device 8 serves through the traps for a host directory, a disk
+      # image or a .t64. Disk images take the `disk` options. A .t64 is
+      # read-only whatever it's given.
+      def open_storage(path, disk = {})
         return Storage::HostDirectory.new(path) if File.directory?(path)
 
-        storage = MOUNT_TYPES[File.extname(path).downcase]
+        storage = MOUNT_TYPES.fetch(File.extname(path).downcase)
         storage < Storage::DiskImage ? storage.new(path, **disk) : storage.new(path)
       end
 
-      def attach_cartridge(computer, path, options)
-        computer.attach_cartridge(Cartridge.from_file(path, **options))
-        "Attached cartridge #{path}"
+      # A program file's bytes, unwrapped from a .p00.
+      def program_bytes(path)
+        bytes = File.binread(path).bytes
+        Storage::P00.wraps?(bytes) ? Storage::P00.data(bytes) : bytes
       end
 
-      def attach_sid(computer, path, autostart:, subtune:)
-        tune = Storage::SIDFile.new(path)
-        if tune.sids > 1
-          raise Storage::SIDFile::FormatError, "Written for #{tune.sids} SIDs, which only the SID player plays"
-        end
-
-        subtune = (subtune || tune.start_subtune).clamp(1, tune.subtunes)
-        computer.on_init { start_tune(computer, tune, autostart:, subtune:) }
-        title = tune.name.empty? ? path : tune.name
-        title += " (subtune #{subtune})" if tune.subtunes > 1
-        autostart ? "Playing #{title}" : "Loaded #{title}"
-      end
+      private
 
-      def start_tune(computer, tune, autostart:, subtune:)
-        computer.ram.write(tune.load_address, tune.data)
-        tune.boot_memory(subtune:).each { |address, bytes| computer.ram.write(address, bytes) }
-        computer.type_text(tune.boot_command) if autostart
+      def attach_kind(computer, path, autostart:, subtune:, **options)
+        disk = options.fetch(:disk, {})
+        case kind(computer, path)
+        when :true_drive then attach_true_drive(computer, path, disk, autostart:)
+        when :directory then mount(computer, path, disk, autostart: false)
+        when :storage then mount(computer, path, disk, autostart:)
+        when :cartridge then attach_cartridge(computer, path, options.fetch(:cartridge, {}))
+        when :tune then Tune.attach(computer, path, autostart:, subtune:)
+        when :tape then attach_tape(computer, path, autostart:)
+        else attach_prg(computer, path, autostart:)
+        end
       end
 
-      def attach_tape(computer, path, autostart:)
-        computer.datasette.insert(Storage::TAP.new(path))
-        computer.datasette.play!
-        computer.type_text(TAPE_AUTOSTART) if autostart
-        "Inserted #{path} in the datasette"
-      end
+      def disk?(path) = File.directory?(path) || Extensions.kind(path) == :disk
 
       def attach_true_drive(computer, path, disk, autostart:)
         message = TrueDrive.insert(computer, path, read_only: disk.fetch(:read_only, false))
-        computer.type_text(AUTOSTART) if autostart
+        computer.type_text(disk_autostart(computer) { Vic20Media.first_program(path) }) if autostart
         message
       end
 
-      def attach_storage(computer, path, disk, autostart:)
-        computer.mount(open_storage(path, disk))
-        computer.type_text(AUTOSTART) if autostart
+      def mount(computer, path, disk, autostart:)
+        storage = open_storage(path, disk)
+        computer.mount(storage)
+        computer.type_text(disk_autostart(computer) { storage.read_file("*") }) if autostart
         "Mounted #{path} as device 8"
       end
 
-      def attach_prg(computer, path, autostart:)
-        bytes = File.binread(path).bytes
-        bytes = Storage::P00.data(bytes) if Storage::P00.wraps?(bytes)
-        computer.on_init { start_prg(computer, bytes, autostart:) }
-        "Loading #{path}"
+      # What loads and runs the first program on the disk in device 8. A
+      # VIC-20 goes by that program, which the block gives
+      # (Vic20Media.disk_autostart).
+      def disk_autostart(computer)
+        computer.family == :vic20 ? Vic20Media.disk_autostart(yield) : AUTOSTART
+      end
+
+      # A VIC-20 cartridge is its ROM chips.
+      def attach_cartridge(computer, path, options)
+        if computer.family == :vic20
+          computer.attach_cartridge(Storage::CRTFile.new(path, machine: :vic20).chips)
+        else
+          computer.attach_cartridge(Cartridge.from_file(path, **options))
+        end
+        "Attached cartridge #{path}"
       end
 
-      def start_prg(computer, data, autostart:)
-        load_addr = computer.load_prg(data)
-        # Run only makes sense for programs at BASIC start, or a byte ahead
-        # of it, where BASIC keeps the zero before its first line. BASIC 7.0
-        # starts at $1C01 and keeps the end of its text at $1210.
-        start, text_end = computer.family == :c128 && computer.mode == :c128 ? [0x1c01, 0x1210] : [BASIC_START, 0x2d]
-        return unless autostart && (load_addr == start || load_addr == start - 1)
-
-        # The end of the program, where BASIC's variables start, and where
-        # the KERNAL's LOAD leaves its end address.
-        end_addr = load_addr + data.length - 2
-        [text_end, 0xae].each { |pointer| computer.ram.write(pointer, [end_addr & 0xff, end_addr >> 8]) }
-        computer.type_text("run\r")
+      # A VIC-20 says when the tape was made for another machine
+      # (Vic20Media.tape_message).
+      def attach_tape(computer, path, autostart:)
+        tape = Storage::TAP.new(path)
+        computer.datasette.insert(tape)
+        computer.datasette.play!
+        computer.type_text(TAPE_AUTOSTART) if autostart
+        message = "Inserted #{path} in the datasette"
+        computer.family == :vic20 ? Vic20Media.tape_message(tape, message) : message
+      end
+
+      # A VIC-20 has programs of its own (Vic20Media.attach_program).
+      def attach_prg(computer, path, autostart:)
+        bytes = program_bytes(path)
+        return Vic20Media.attach_program(computer, path, bytes, autostart:) if computer.family == :vic20
+
+        computer.on_init { Program.load(computer, bytes, autostart:) }
+        "Loading #{path}"
       end
     end
   end