badline 0.16.1 → 0.18.0

data/lib/badline/media/extensions.rb

@@ -7,17 +7,21 @@ module Badline
     # It loads on its own, for Options.
     #
     # - :disk, a disk image that the traps mount and a true drive reads
-    # - :ieee_disk, an 8050's or 8250's disk image, for a PET's IEEE-488
-    #   drive
+    # - :ieee_disk, an 8050's, 8250's or 2040's disk image, for a PET's
+    #   IEEE-488 drive
+    # - :hard_disk, a D9060's or D9090's hard disk, which only a PET's or a
+    #   CBM-II's 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
+    # - :papertape, a MOS papertape, which only the KIM-1 loads
     # - :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,
-        ".d80" => :ieee_disk, ".d82" => :ieee_disk, ".tap" => :tape, ".crt" => :cartridge, ".sid" => :tune,
-        ".m3u" => :disk_list, ".vfl" => :disk_list
+        ".d80" => :ieee_disk, ".d82" => :ieee_disk, ".d67" => :ieee_disk, ".d90" => :hard_disk, ".tap" => :tape,
+        ".crt" => :cartridge, ".sid" => :tune, ".m3u" => :disk_list, ".vfl" => :disk_list, ".ptp" => :papertape,
+        ".pap" => :papertape
       }.freeze
 
       # The kind of the medium at `path`, by its extension.

data/lib/badline/media/kim1_media.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # What a KIM-1 loads (Media.attach): a MOS papertape, a .ptp or .pap
+    # (Storage::Papertape), at the addresses its records give, or a .bin
+    # of bare bytes, which says nothing of where it goes, at its Loading's
+    # load address.
+    #
+    # Once the monitor runs, the bytes go straight into memory, after
+    # the NMI and IRQ vectors at $17FA and $17FE, which nothing sets at
+    # power-on, are pointed at the monitor's $1C00, so ST and BRK stop
+    # the program and show where (User Manual, section 4.1). A papertape
+    # can go in through the teletype instead, as the monitor's L command
+    # reads it, in real time. The program then starts at its Loading's
+    # start address, or else where it loads, as the user would start it:
+    # AD, the address and GO on the keypad, or the address, a space and G
+    # on the teletype. Without autostart the monitor stops at the
+    # address.
+    #
+    # A .wav, a recording of a KIM tape (Storage::KIMTape), goes in the
+    # cassette deck, for the monitor's LOADT to read once PLAY is down.
+    module KIM1Media
+      PAPERTAPES = Extensions.of(%i[papertape])
+
+      # A .bin, bare bytes.
+      BINARY = ".bin"
+
+      # A recording of a tape.
+      TAPE = ".wav"
+
+      # What a KIM-1 takes.
+      EXTENSIONS = (PAPERTAPES + [BINARY, TAPE]).freeze
+
+      # Where a .bin loads without a load address, as most of the First
+      # Book of KIM's programs do.
+      DEFAULT_LOAD_ADDRESS = 0x0200
+
+      # Where the monitor saves the registers and shows the PC, for the
+      # NMI and IRQ vectors.
+      MONITOR = 0x1c00
+
+      NMI_VECTOR = 0x17fa
+      IRQ_VECTOR = 0x17fe
+
+      # How a KIM-1 loads and starts a program: at `load_address`, a .bin's,
+      # or -1 for DEFAULT_LOAD_ADDRESS, from `start_address`, or -1 for
+      # where it loads, and through the teletype's L command if
+      # `teletype`.
+      class Loading
+        attr_reader :load_address, :start_address
+
+        def initialize(load_address: -1, start_address: -1, teletype: false)
+          @load_address = load_address
+          @start_address = start_address
+          @teletype = teletype
+        end
+
+        def teletype? = @teletype
+      end
+
+      # Loads straight into memory, from where it loads.
+      DIRECT = Loading.new
+
+      class << self
+        # The Loading the command line's `options` ask for, with
+        # --load-address, --start-address and --tty-load.
+        def loading(options)
+          load_address = options.load_address
+          start_address = options.start_address
+          Loading.new(load_address: load_address.nil? ? -1 : load_address,
+                      start_address: start_address.nil? ? -1 : start_address, teletype: options.tty_load?)
+        end
+
+        # Whether a KIM-1 takes the file at `path`.
+        def takes?(path) = EXTENSIONS.include?(File.extname(path).downcase)
+
+        # Loads the program at `path` into the KIM-1 `machine` as
+        # `loading` says, and starts it if `autostart`. Raises
+        # Machine::Unsupported when it loads outside the RAM.
+        def attach(machine, path, loading, autostart:)
+          raise Machine::Unsupported, "doesn't go in a KIM-1" unless takes?(path)
+          return insert_tape(machine, path) if File.extname(path).downcase == TAPE
+
+          papertape = PAPERTAPES.include?(File.extname(path).downcase)
+          tape = papertape ? Storage::Papertape.read(path) : nil
+          records = tape.nil? ? [binary(path, loading.load_address)] : tape.records
+          refuse_outside_ram(machine, records)
+          start = loading.start_address.negative? ? records.first.address : loading.start_address
+          if !tape.nil? && loading.teletype? && machine.tty?
+            machine.teletype.type("L#{tape.text}")
+          else
+            machine.on_init { deposit(machine, records) }
+          end
+          machine.on_init { machine.type_text(start_keys(machine, start, autostart)) }
+          "Loading #{path} at $#{hex(records.first.address)}"
+        end
+
+        private
+
+        def insert_tape(machine, path)
+          machine.tape.insert_tape(Storage::KIMTape.read(path))
+          "Inserted #{path} in the tape deck"
+        end
+
+        def binary(path, load_address)
+          Storage::Papertape::Record.new(load_address.negative? ? DEFAULT_LOAD_ADDRESS : load_address,
+                                         File.binread(path).bytes)
+        end
+
+        def refuse_outside_ram(machine, records)
+          records.each do |record|
+            address = record.address
+            last = address + record.bytes.size - 1
+            raise Machine::Unsupported, "has no bytes to load" if last < address
+            next if last <= 0xffff && (address..last).all? { |byte_address| machine.bus.ram?(byte_address) }
+
+            raise Machine::Unsupported, "loads at $#{hex(address)}-$#{hex(last)}, outside the KIM-1's " \
+                                        "#{machine.bus.ram_kb}K of RAM; --ram 5k or --ram expanded adds more"
+          end
+        end
+
+        def deposit(machine, records)
+          [NMI_VECTOR, IRQ_VECTOR].each do |vector|
+            machine.poke(vector, MONITOR & 0xff)
+            machine.poke(vector + 1, MONITOR >> 8)
+          end
+          records.each do |record|
+            address = record.address
+            record.bytes.each_with_index { |byte, offset| machine.poke(address + offset, byte) }
+          end
+        end
+
+        # What starts the program at `start`, or stops at it without
+        # `autostart`.
+        def start_keys(machine, start, autostart)
+          if machine.tty?
+            opened = "#{hex(start)} "
+            return autostart ? "#{opened}G" : opened
+          end
+
+          keys = "AD #{hex(start).chars.join(' ')}"
+          autostart ? "#{keys} GO" : keys
+        end
+
+        def hex(value) = value.to_s(16).upcase.rjust(4, "0")
+      end
+    end
+  end
+end

data/lib/badline/media/pet_media.rb

@@ -27,8 +27,10 @@ module Badline
         # BASIC 2 and 4 load the first program off the disk and run it.
         # BASIC 1's LOAD finds no device on the IEEE-488 bus, so the first
         # program, which the block gives, goes in as a program file does,
-        # once the KERNAL has booted.
+        # once the KERNAL has booted. The SuperPET's 6809 starts its own
+        # menu instead.
         def disk_autostart(machine)
+          return unless machine.boots_basic?
           return machine.type_text(AUTOSTART) unless machine.model.basic1?
 
           data = yield

data/lib/badline/media/program.rb

@@ -2,8 +2,8 @@
 
 module Badline
   module Media
-    # A program loading into a C64, a C128, a 264 series machine or a PET
-    # once it has booted (Media.attach). The VIC-20 has its own
+    # A program loading into a C64, a C128, a 264 series machine, a PET or
+    # a CBM-II once it has booted (Media.attach). The VIC-20 has its own
     # (Vic20Basic).
     module Program
       # Where BASIC 3.5 starts on the 264 series.
@@ -35,10 +35,13 @@ module Badline
         # KERNAL's end address (EAL). BASIC 7.0 starts at $1C01 and keeps
         # the end of its text at $1210, and the 264 KERNAL keeps EAL at $9D.
         # PET BASIC 2 and 4 keep the end of their text at $2A and EAL at
-        # $C9, and BASIC 1 at $7C and $E5.
+        # $C9, and BASIC 1 at $7C and $E5. The CBM-II's BASIC starts at
+        # $0003 of segment 1 and keeps the end of its text at $2F, and its
+        # KERNAL EAL at $96, in segment 15.
         def basic(computer)
           return [PLUS4_BASIC_START, 0x2d, KernalTrap::PLUS4_ZERO_PAGE.end_address] if computer.family == :plus4
           return pet_basic(computer) if computer.family == :pet
+          return [CBM2Media::BASIC_START, CBM2Media::TEXT_END, CBM2Media::EAL] if computer.family == :cbm2
           return [0x1c01, 0x1210, 0xae] if computer.family == :c128 && computer.mode == :c128
 
           [BASIC_START, 0x2d, 0xae]

data/lib/badline/media/true_drive.rb

@@ -4,19 +4,28 @@ module Badline
   module Media
     # Device 8 as a true drive instead of the KERNAL traps: a 1541, or on
     # the C128 its 1571, or on the Plus/4 a 1551 if it asks for one, or a
-    # 1581, or on the PET a 2031 on the IEEE-488 bus. 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 or TCBM. 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 (Drives::Model1581::Slot), and another disk
-    # image swaps a 1581 back for the machine's own drive. The PET has no
-    # 1581, and its 2031 reads .d64 and .g64 images only. The traps' other
-    # disk media, a .t64, a host directory, or a .d80 or .d82, raise Error.
+    # 1581, or on the PET or the CBM-II a drive on the IEEE-488 bus. 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, TCBM or the IEEE-488 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 (Drives::Model1581::Slot), and another disk image
+    # swaps a 1581 back for the machine's own drive. On the PET and
+    # the CBM-II an image goes in the drive on device 8 if it reads it, or
+    # else in a drive of the machine's own model, plug_true_drive's, if
+    # that reads it, or else in the model made for it, swapped in
+    # (Drives::IEEEModels): a 2031 for a .d64, an 8050 for a .d80 and an
+    # 8250 for a .d82, in the drive of a dual unit the machine names
+    # (disk_drive_number): drive 1 on a SuperPET running its 6809. The
+    # traps' other disk media, a .t64 or a host directory, raise Error.
     module TrueDrive
       class Error < ArgumentError; end
 
+      # The families whose drives sit on the IEEE-488 bus.
+      IEEE_FAMILIES = %i[pet cbm2].freeze
+
       class << self
         # Plugs the machine's true drive in as device 8, unless one is there
         # already, and returns it.
@@ -30,12 +39,12 @@ module Badline
           drive if drive && drive.device == KernalTrap::Routine::DEVICE
         end
 
-        # Whether the path goes in a true drive: a .g64 or .g71 always, and
-        # other disk media, which the traps would mount, when a true drive
+        # Whether the path goes in a true drive: a .g64, .g71 or .d90 always,
+        # and other disk media, which the traps would mount, when a true drive
         # is device 8.
         def takes?(computer, path)
           kind = Extensions.kind(path)
-          return true if kind == :gcr
+          return true if %i[gcr hard_disk].include?(kind)
 
           !drive(computer).nil? && (File.directory?(path) || %i[disk archive ieee_disk].include?(kind))
         end
@@ -45,15 +54,13 @@ module Badline
         # 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)
-          pet = computer.family == :pet
-          return insert_d81(computer, path, read_only) if !pet && File.extname(path).casecmp?(".d81")
+          return insert_ieee(computer, path, read_only) if IEEE_FAMILIES.include?(computer.family)
+          return insert_d81(computer, path, read_only) if File.extname(path).casecmp?(".d81")
 
           drive = own_drive(computer)
           name = drive&.model_name || default_model(computer)
           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.join(' or ')} image, which the #{name} reads" if pet
-
             raise Error, "#{path} is not a #{types.join(', ')} or .d81 image, which the #{name} and the 1581 read"
           end
 
@@ -66,20 +73,39 @@ module Badline
         private
 
         # The model plug_true_drive plugs in.
-        def default_model(computer)
-          case computer.family
-          when :c128 then "1571"
-          when :pet then "2031"
-          else "1541"
-          end
-        end
+        def default_model(computer) = computer.family == :c128 ? "1571" : "1541"
 
-        # The drive on device 8 unless it's a 1581.
+        # The drive on device 8 unless it's a 1581, which a .d64 swaps back
+        # out.
         def own_drive(computer)
           drive = drive(computer)
           drive unless drive&.model_name == "1581"
         end
 
+        # The image in the model Drives::IEEEModels.taking picks, swapped in
+        # for the drive on device 8 unless it's that model already.
+        def insert_ieee(computer, path, read_only)
+          drive = drive(computer)
+          model = Drives::IEEEModels.taking(path, drive&.model_name, computer.true_drive_model)
+          unless model
+            name = computer.true_drive_model
+            types = Drives::IEEEModels::MEDIA.fetch(name)
+            raise Error, "#{path} is not a #{types.join(' or ')} image, which the #{name} reads"
+          end
+
+          drive = computer.plug_ieee_drive(model) unless drive&.model_name == model
+          number = computer.disk_drive_number
+          if number.positive? && drive.is_a?(Drives::Model8050)
+            drive.insert_image(path, drive: number, read_only:)
+            computer.unmount
+            return "Inserted #{path} in the #{model}'s drive #{number} as device 8"
+          end
+
+          drive.insert_image(path, read_only:)
+          computer.unmount
+          "Inserted #{path} in the #{model} as device 8"
+        end
+
         def insert_d81(computer, path, read_only)
           drive = drive(computer)
           drive = computer.plug_drive1581 unless drive&.model_name == "1581"

data/lib/badline/media.rb

@@ -12,6 +12,8 @@ require "badline/media/vic20_cartridge"
 require "badline/media/vic20_media"
 require "badline/media/plus4_media"
 require "badline/media/pet_media"
+require "badline/media/cbm2_media"
+require "badline/media/kim1_media"
 require "badline/media/tune"
 require "badline/media/program"
 
@@ -28,7 +30,8 @@ module Badline
       ".d81" => Storage::D81Image,
       ".t64" => Storage::T64,
       ".d80" => Storage::D80Image,
-      ".d82" => Storage::D82Image
+      ".d82" => Storage::D82Image,
+      ".d67" => Storage::D67Image
     }.freeze
 
     class << self
@@ -53,9 +56,13 @@ module Badline
       # .crt cartridges and raw .bin ROM images in its two cartridges'
       # slots (Plus4Media), and no .sid tunes either. The PET mounts .d80
       # and .d82 disks too, which no other machine takes, and has no
-      # cartridges, tunes or true drives (PETMedia). The C128 in C64 mode
-      # takes a C64's.
-      def attach(computer, path, autostart: true, subtune: nil, **)
+      # cartridges, tunes or true drives (PETMedia), and so does the CBM-II,
+      # which takes its own .crt cartridges and no tapes (CBM2Media). The
+      # C128 in C64 mode takes a C64's. The KIM-1 takes only its programs,
+      # which load as `kim1`, a KIM1Media::Loading, says (KIM1Media).
+      def attach(computer, path, autostart: true, subtune: nil, kim1: KIM1Media::DIRECT, **)
+        return KIM1Media.attach(computer, path, kim1, autostart:) if computer.family == :kim1
+
         path = DiskList.disk(path)
         refuse_unsupported(computer, path)
 
@@ -126,17 +133,20 @@ module Badline
       private
 
       # The VIC-20 and the 264 series have no SID to play a .sid tune on,
-      # and only the PET has the IEEE-488 drive a .d80 or .d82 goes in.
+      # only the PET and the CBM-II have the IEEE-488 drive a .d80, .d82
+      # or .d90 goes in, and only the KIM-1 reads papertape.
       def refuse_unsupported(computer, path)
         family = computer.family
-        if Extensions.kind(path) == :ieee_disk && family != :pet
-          raise ArgumentError, "#{path} needs a PET's IEEE-488 drive"
+        raise Machine::Unsupported, "#{path} needs a KIM-1" if Extensions.kind(path) == :papertape
+        if %i[ieee_disk hard_disk].include?(Extensions.kind(path)) && !%i[pet cbm2].include?(family)
+          raise ArgumentError, "#{path} needs a PET's or a CBM-II's IEEE-488 drive"
         end
 
         refused, name = case family
                         when :vic20 then [Vic20Media::UNSUPPORTED, "a VIC-20"]
                         when :plus4 then [Vic20Media::UNSUPPORTED, "a Plus/4"]
                         when :pet then [PETMedia::UNSUPPORTED, "a PET"]
+                        when :cbm2 then [CBM2Media::UNSUPPORTED, "a CBM-II"]
                         else [[], ""]
                         end
         raise ArgumentError, "#{path} doesn't go in #{name}" if refused.include?(File.extname(path).downcase)
@@ -182,7 +192,11 @@ module Badline
       # 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
+        case computer.family
+        when :vic20 then Vic20Media.disk_autostart(yield)
+        when :cbm2 then CBM2Media::AUTOSTART
+        else AUTOSTART
+        end
       end
 
       # A VIC-20 or 264 series cartridge is its ROM chips. On the 264, the
@@ -194,6 +208,7 @@ module Badline
           crt = Storage::CRTFile.new(path, machine: :vic20)
           computer.attach_cartridge(crt.chips, crt.name.empty? ? File.basename(path, File.extname(path)) : crt.name)
         when :plus4 then computer.attach_cartridge(Plus4Media.cartridge_chips(path, slot: options.fetch(:slot, nil)))
+        when :cbm2 then computer.attach_cartridge(CBM2Media.cartridge_chips(path))
         else
           computer.attach_cartridge(C64::Cartridge.from_file(path, **options))
         end

data/lib/badline/options/family.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "badline/storage/crt_file"
 require "badline/storage/p00"
 require "badline/storage/tap"
 
@@ -11,9 +12,94 @@ module Badline
       # Where C128 BASIC starts, which a program for the C128 loads at.
       C128_BASIC_START = 0x1c01
 
+      # Whether the KIM-1 talks to a teletype: with --tty or --tty-load,
+      # and always on the terminal with --headless.
+      def tty? = @tty || @tty_load || kim1_terminal?
+
+      # The KIM-1 teletype's baud.
+      def baud = @baud
+
+      # Whether the KIM-1 loads a papertape through its monitor's L
+      # command, with --tty-load.
+      def tty_load? = @tty_load
+
+      # Where the KIM-1 loads a .bin, and where it starts its program, as
+      # --load-address and --start-address give them, or nil.
+      def load_address = @load_address
+
+      def start_address = @start_address
+
+      # Whether the KIM-1 runs on the terminal, its teletype there.
+      def kim1_terminal? = @family == :kim1 && @headless
+
       private
 
-      # Takes `sid`, `c64`, `vic20`, `c128`, `plus4` or `pet` when given first.
+      # The KIM-1's keypad, until --tty or --baud name its teletype, and
+      # its programs where they load.
+      def initialize_kim1
+        @tty = false
+        @tty_load = false
+        @baud = 9600
+        @load_address = nil
+        @start_address = nil
+      end
+
+      # The KIM-1 teletype's baud, and where it loads a .bin and starts a
+      # program.
+      def kim1_option(name, flag, value)
+        case name
+        when "--baud" then @baud = baud_for(value)
+        when "--load-address" then @load_address = address(flag, value)
+        else @start_address = address(flag, value)
+        end
+      end
+
+      def kim1_switch(name)
+        if name == "--tty"
+          @tty = true
+        else
+          @tty_load = true
+        end
+      end
+
+      # An address in hex, with or without a $ or 0x before it.
+      def address(flag, value)
+        digits = value.delete_prefix("$").delete_prefix("0x").delete_prefix("0X")
+        raise Error, "invalid argument: #{flag} #{value}" unless digits.match?(/\A[0-9a-fA-F]{1,4}\z/)
+
+        digits.to_i(16)
+      end
+
+      def kim1_ram(value)
+        raise Error, "invalid argument: --ram #{value}" unless KIM1_RAM.key?(value)
+
+        KIM1_RAM[value]
+      end
+
+      # The KIM-1 runs in the window, or with --headless on the terminal,
+      # without the C64's SID and REU. Only a papertape goes in through
+      # the teletype, and only a .bin has a load address to give.
+      def validate_kim1
+        raise Error, "--ntsc needs the C64" 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, "--audio-out needs a .sid tune" unless @audio_out.nil?
+
+        extension = @media_path.nil? ? "" : File.extname(@media_path).downcase
+        raise Error, "--tty-load needs a .ptp or .pap" if @tty_load && !%w[.ptp .pap].include?(extension)
+        raise Error, "--load-address needs a .bin" unless @load_address.nil? || extension == ".bin"
+      end
+
+      # Only the KIM-1 has a teletype, and programs without a load address.
+      def refuse_kim1_options
+        raise Error, "#{@tty ? '--tty' : '--baud'} needs kim1" if @tty || @baud != 9600
+        raise Error, "--tty-load needs kim1" if @tty_load
+        raise Error, "--load-address needs kim1" unless @load_address.nil?
+        raise Error, "--start-address needs kim1" unless @start_address.nil?
+      end
+
+      # Takes `sid`, `c64`, `vic20`, `c128`, `plus4`, `pet`, `cbm2` or `kim1`
+      # when given first.
       def subcommand(args)
         case args.first
         when "sid" then @sid_command = true
@@ -22,6 +108,8 @@ module Badline
         when "c128" then @family = :c128
         when "plus4" then @family = :plus4
         when "pet" then @family = :pet
+        when "cbm2" then @family = :cbm2
+        when "kim1" then @family = :kim1
         else return
         end
         @family_named = !@sid_command
@@ -34,27 +122,41 @@ module Badline
         when :c128 then C128_MODELS
         when :plus4 then PLUS4_MODELS
         when :pet then PET_MODELS
+        when :cbm2 then CBM2_MODELS
+        when :kim1 then KIM1_MODELS
         else MODELS
         end
       end
 
       # Without a family named, a program that loads at C128_BASIC_START is
-      # the C128's, and an 8050's or 8250's disk or a PET tape the PET's. A
-      # program that loads where PET BASIC starts could be a VIC-20's too.
+      # the C128's, an 8050's or 8250's disk or a PET tape the PET's, a
+      # cartridge signed as a CBM-II's the CBM-II's, and a papertape the
+      # KIM-1's. A program that loads where PET BASIC starts could be a
+      # VIC-20's too.
       def pick_family
         return if @family_named || @sid_command || @media_path.nil? || !File.file?(@media_path)
 
-        if pet_media?
+        if Media::Extensions.kind(@media_path) == :papertape
+          @family = :kim1
+        elsif pet_media?
           @family = :pet
+        elsif cbm2_cartridge?
+          @family = :cbm2
         elsif Media::Extensions::PROGRAMS.include?(File.extname(@media_path).downcase)
           @family = :c128 if Storage::P00.load_address(@media_path) == C128_BASIC_START
         end
       end
 
-      # Whether the media is an 8050's or 8250's disk or a PET tape.
+      # Whether the media is a cartridge signed as a CBM-II's.
+      def cbm2_cartridge?
+        Media::Extensions.kind(@media_path) == :cartridge && Storage::CRTFile.cbm2?(@media_path)
+      end
+
+      # Whether the media is an 8050's or 8250's disk, a D9060's or D9090's
+      # hard disk, or a PET tape.
       def pet_media?
         kind = Media::Extensions.kind(@media_path)
-        kind == :ieee_disk || (kind == :tape && Storage::TAP.platform_of(@media_path) == Storage::TAP::PET_PLATFORM)
+        %i[ieee_disk hard_disk].include?(kind) || (kind == :tape && Storage::TAP.platform_of(@media_path) == Storage::TAP::PET_PLATFORM)
       end
     end
   end