badline 0.11.1 → 0.12.1

data/lib/badline/media/true_drive.rb

@@ -3,13 +3,15 @@
 module Badline
   module Media
     # Device 8 as a true drive instead of the KERNAL traps: a 1541, or on
-    # the C128 its 1571. Once a true drive is plugged in as device 8, disk
-    # media go into it rather than into the traps, so a LOAD runs the DOS
-    # and every byte crosses the serial bus. A .g64 holds the disk's raw
-    # GCR, which only a true drive reads, so it plugs one in when there's
-    # none yet. The 1541 reads only .d64 and .g64 images, and the 1571
-    # .d71 and .g71 as well, so the traps' other disk media, a .d81 or
-    # .t64 or a host directory, raise Error.
+    # the C128 its 1571, or a 1581. Once a true drive is plugged in as
+    # device 8, disk media go into it rather than into the traps, so a LOAD
+    # runs the DOS and every byte crosses the serial bus. A .g64 holds the
+    # disk's raw GCR, which only a true drive reads, so it plugs one in
+    # when there's none yet. The 1541 reads only .d64 and .g64 images, the
+    # 1571 .d71 and .g71 as well, and the 1581 only .d81, so a .d81 swaps
+    # the drive on device 8 for a 1581 (Drive1581::Slot), and another disk
+    # image swaps a 1581 back for the machine's own drive. The traps' other
+    # disk media, a .t64 or a host directory, raise Error.
     module TrueDrive
       class Error < ArgumentError; end
 
@@ -30,27 +32,46 @@ 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 when
-        # there's none, and takes out what was mounted through the traps,
-        # so LOAD and SAVE reach the drive too. `read_only` puts it in
-        # write-protected.
+        # Puts the image in the drive on device 8, plugging one in that
+        # reads it when the drive there doesn't, and takes out what was
+        # mounted through the traps, so LOAD and SAVE reach the drive too.
+        # `read_only` puts it in write-protected.
         def insert(computer, path, read_only: false)
-          name = drive(computer)&.model_name || (computer.family == :c128 ? "1571" : "1541")
+          return insert_d81(computer, path, read_only) if File.extname(path).casecmp?(".d81")
+
+          drive = own_drive(computer)
+          name = drive&.model_name || (computer.family == :c128 ? "1571" : "1541")
           types = name == "1571" ? %w[.d64 .g64 .d71 .g71] : %w[.d64 .g64]
           unless types.include?(File.extname(path).downcase)
-            raise Error, "#{path} is not a #{types[0..-2].join(', ')} or #{types.last} image, which the #{name} reads"
+            raise Error, "#{path} is not a #{types.join(', ')} or .d81 image, which the #{name} and the 1581 read"
           end
 
-          disk = Drive1541::Disk.open(path, read_only:)
+          (drive || computer.plug_true_drive).insert_image(path, read_only:)
           computer.unmount
-          plug(computer).insert(disk)
           "Inserted #{path} in the #{name} as device 8"
         end
+
+        private
+
+        # The drive on device 8 unless it's a 1581.
+        def own_drive(computer)
+          drive = drive(computer)
+          drive unless drive&.model_name == "1581"
+        end
+
+        def insert_d81(computer, path, read_only)
+          drive = drive(computer)
+          drive = computer.plug_drive1581 unless drive&.model_name == "1581"
+          drive.insert_image(path, read_only:)
+          computer.unmount
+          "Inserted #{path} in the 1581 as device 8"
+        end
       end
     end
   end

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,12 +1,17 @@
 # frozen_string_literal: true
 
+require "badline/media/extensions"
 require "badline/media/true_drive"
+require "badline/media/boot_disk"
+require "badline/media/not_disk"
 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"
+require "badline/media/tune"
+require "badline/media/program"
 
 module Badline
   module Media
@@ -14,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,
@@ -32,14 +38,21 @@ module Badline
       # there, a .d64 goes into it instead of the KERNAL traps too. The
       # autostart then loads through it.
       #
+      # On a C128 in C128 mode, a boot disk goes in a true drive for the
+      # 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
 
-        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,
@@ -50,11 +63,12 @@ module Badline
       # A .g64 goes in a true 1541, which is plugged in as device 8 when
       # there's none yet (TrueDrive). Once a true 1541 is device 8, a .d64
       # goes in its drive as well, and other disks, which a 1541 can't
-      # read, raise TrueDrive::Error, an ArgumentError.
+      # read, raise TrueDrive::Error, an ArgumentError. Anything else
+      # raises NotDisk.
       def insert_disk(computer, path, read_only: false)
         return TrueDrive.insert(computer, path, read_only:) if TrueDrive.takes?(computer, path)
 
-        raise ArgumentError, "#{path} is not a disk image or a directory" unless disk?(path)
+        raise NotDisk, "#{path} is not a disk image or a directory" unless disk?(path)
 
         computer.mount(open_storage(path, { read_only: }))
         "Inserted #{path} in device 8"
@@ -67,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

data/lib/badline/options/event.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "badline/media/extensions"
+
 module Badline
   class Options
     # One event of --at or --script: what to do, with its argument, once
@@ -23,7 +25,7 @@ module Badline
 
       # 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
+      INSERTABLE = Media::Extensions.of(%i[disk gcr archive tape cartridge disk_list])
 
       attr_reader :frame, :action, :argument
 
@@ -95,7 +97,7 @@ module Badline
       def self.insertable?(path)
         return true if File.directory?(path)
 
-        File.exist?(path) && (INSERTABLE.include?(File.extname(path).downcase) || Media::DiskList.list?(path))
+        File.exist?(path) && INSERTABLE.include?(File.extname(path).downcase)
       end
     end
   end

data/lib/badline/options/family.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "badline/storage/p00"
+
 module Badline
   class Options
     # The machine family: the subcommand that names it, or else the media,
@@ -37,15 +39,7 @@ module Badline
         return if @family_named || @sid_command || @media_path.nil?
         return unless %w[.prg .p00].include?(File.extname(@media_path).downcase) && File.file?(@media_path)
 
-        @family = :c128 if load_address(@media_path) == C128_BASIC_START
-      end
-
-      # The load address of a .prg, or of the program a .p00 wraps after its
-      # 26-byte header.
-      def load_address(path)
-        offset = File.extname(path).casecmp?(".p00") ? 26 : 0
-        bytes = File.binread(path).bytes
-        bytes.size >= offset + 2 ? bytes[offset] | (bytes[offset + 1] << 8) : -1
+        @family = :c128 if Storage::P00.load_address(@media_path) == C128_BASIC_START
       end
     end
   end

data/lib/badline/options/help.rb

@@ -61,7 +61,8 @@ module Badline
         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, or on
-        the C128 the C128D's 1571, which reads .d71 and .g71 too. A .sid
+        the C128 the C128D's 1571, which reads .d71 and .g71 too. A .d81
+        then goes in an emulated 1581 in its place. A .sid
         tune opens in the SID player, as `sid` plays it, unless an option
         of the emulator's window asks for the machine.
 

data/lib/badline/roms/README

@@ -70,6 +70,15 @@ Downloaded from
 https://www.zimmers.net/anonftp/pub/cbm/firmware/drives/new/1571/1571-rom.310654-05.bin
 SHA-1 f1be619c106641a685f6609e4d43d6fc9eac1e70.
 
+dos1581.rom
+-----------
+The 1581 disk drive's DOS, 318045-02, 32 KB for $8000-$FFFF.
+Drive1581 loads it.
+
+Downloaded from
+https://www.zimmers.net/anonftp/pub/cbm/firmware/drives/new/1581/1581-rom.318045-02.bin
+SHA-1 01228eae6f066bd9b7b2b6a7fa3f667e41dad393.
+
 Commodore VIC-20 ROMs
 =====================