badline 0.16.0 → 0.17.0

data/lib/badline/machine/ieee_drives.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require "badline/drives/model2031"
+require "badline/drives/model8050"
+
+module Badline
+  module Machine
+    # A machine's true drive on its IEEE-488 bus: a Drives::Model2031,
+    # Model8050 or Model8250, one at a time, clocked after the CPU each
+    # cycle at the machine's clock (ieee_host_clock_hz) and reset with it,
+    # as the machine's RES line reaches IFC. The traps on the KERNAL's
+    # primitives leave device 8 to the drive while it is device 8
+    # (trap_device). The PET (PET::IEEEDrive) and the CBM-II
+    # (CBM2::IEEEDrive) include it.
+    #
+    # The machine's @ieee is its side of the bus: #bus, the
+    # Drives::IEEEBus, #push_lines, which shows the drives the lines the
+    # machine pulls now, and #cycle_lines, which does so once a cycle if
+    # the machine doesn't push them as its chips are written.
+    module IEEEDrives
+      # The 2031 on the bus, or nil.
+      attr_reader :drive2031
+
+      # The 8050 or 8250 on the bus, or nil.
+      attr_reader :drive8050
+
+      # Plugs in a Drives::Model2031, in place of the drive there.
+      def attach_drive2031(drive)
+        detach_true_drives
+        connect_drive(drive)
+        @drive2031 = drive
+        @ieee_trap&.device = trap_device
+        @init_threshold = [@init_threshold, Badline::Drives::Model2031::BOOT_CYCLES].max if @cycles < @init_threshold
+      end
+
+      # Unplugs the 2031, leaving it on a bus of its own.
+      def detach_drive2031
+        drive = @drive2031
+        return unless drive
+
+        drive.connect(Badline::Drives::IEEEBus.new)
+        @drive2031 = nil
+        @ieee_trap&.device = trap_device
+      end
+
+      # Plugs in a Drives::Model8050 or Model8250, in place of the drive
+      # there.
+      def attach_drive8050(drive)
+        detach_true_drives
+        connect_drive(drive)
+        @drive8050 = drive
+        @ieee_trap&.device = trap_device
+        @init_threshold = [@init_threshold, Badline::Drives::Model8050::BOOT_CYCLES].max if @cycles < @init_threshold
+      end
+
+      # Unplugs the 8050 or 8250, leaving it on a bus of its own.
+      def detach_drive8050
+        drive = @drive8050
+        return unless drive
+
+        drive.connect(Badline::Drives::IEEEBus.new)
+        @drive8050 = nil
+        @ieee_trap&.device = trap_device
+      end
+
+      # Plugs in an 8050, or an 8250 for +model+ "8250", as device 8, in
+      # place of the drive there, and returns it.
+      def plug_drive8050(model = "8050")
+        drive = model == "8250" ? Badline::Drives::Model8250.new : Badline::Drives::Model8050.new
+        drive.tap { |unit| attach_drive8050(unit) }
+      end
+
+      # The true drive on the bus, or nil.
+      def true_drive = @drive8050 || @drive2031
+
+      # Plugs in a 2031 as device 8, in place of the drive there, and
+      # returns it.
+      def plug_true_drive
+        Badline::Drives::Model2031.new.tap { |drive| attach_drive2031(drive) }
+      end
+
+      # Settles for a snapshot, then runs on until a 2031's CPU, or an
+      # 8050's interface processor with its controller at the start of its
+      # idle loop, is between instructions with the machine's, as VICE
+      # saves them, or for so many cycles, then on to the machine's next
+      # instruction. It stands in for Machine::Settling's, which the
+      # machines include first.
+      def settle_for_vice!
+        ran = settle_for_snapshot!
+        return ran if @drive2031.nil? && @drive8050.nil?
+
+        until ran >= Machine::Settling::LIMIT || (drive_settled_for_vice? && settled_for_snapshot?)
+          cycle!
+          ran += 1
+        end
+        ran + settle_for_snapshot!
+      end
+
+      # Whether the true drive is where VICE saves it (#settle_for_vice!).
+      def drive_settled_for_vice?
+        return @drive2031.cpu.boundary? if @drive2031
+
+        fdc = @drive8050.fdc_cpu
+        @drive8050.ip_cpu.boundary? && fdc.boundary? && fdc.program_counter == Badline::Drives::Model8050::Idle::FDC_LOOP
+      end
+
+      private
+
+      def init_ieee_drives
+        @drive2031 = nil
+        @drive8050 = nil
+      end
+
+      def detach_true_drives
+        detach_drive2031
+        detach_drive8050
+      end
+
+      def connect_drive(drive)
+        drive.host_clock_hz = ieee_host_clock_hz
+        drive.connect(@ieee.bus)
+        @ieee.push_lines
+      end
+
+      # The true drive's cycles for one of the machine's, after the lines
+      # it pulls.
+      def clock_ieee_drives
+        drive2031 = @drive2031
+        drive8050 = @drive8050
+        return unless drive2031 || drive8050
+
+        @ieee.cycle_lines
+        drive2031&.host_cycle!
+        drive8050&.host_cycle!
+      end
+
+      # The RES line reaches the true drive as IFC.
+      def reset_ieee_drives
+        @drive2031&.reset!
+        @drive8050&.reset!
+      end
+
+      # The true drive as keyed snapshot modules named from its device
+      # number: BL-D8, BL-D8-CPU and so on for device 8.
+      def save_drive_modules(sections)
+        drive2031 = @drive2031
+        drive2031&.save_modules(sections, "BL-D#{drive2031.device}")
+        drive8050 = @drive8050
+        drive8050&.save_modules(sections, "BL-D#{drive8050.device}")
+        sections
+      end
+
+      # The true drive a snapshot's modules hold, a 2031, an 8050 or an
+      # 8250 by its model, built afresh unless the same model is on the bus
+      # as the same device, or none when they hold no drive. The bus then
+      # carries the machine's lines as its chips left them.
+      def load_drive_modules(modules)
+        device = 8
+        input = modules.optional("BL-D8")
+        while input.nil? && device < 15
+          device += 1
+          input = modules.optional("BL-D#{device}")
+        end
+        model = input&.text("model", "2031")
+        if %w[8050 8250].include?(model)
+          load_drive8050_modules(modules, input, model, device)
+        elsif input
+          load_drive2031_modules(modules, input, device)
+        else
+          detach_true_drives
+        end
+        @ieee.push_lines
+      end
+
+      def load_drive2031_modules(modules, input, device)
+        detach_drive8050
+        detach_drive2031 if @drive2031 && @drive2031.device != device
+        attach_drive2031(Badline::Drives::Model2031.new(device:)) unless @drive2031
+        @drive2031.load_modules(modules, input, "BL-D#{device}")
+      end
+
+      def load_drive8050_modules(modules, input, model, device)
+        detach_drive2031
+        drive = @drive8050
+        detach_drive8050 if drive && (drive.device != device || drive.model_name != model)
+        unless @drive8050
+          unit = model == "8250" ? Badline::Drives::Model8250.new(device:) : Badline::Drives::Model8050.new(device:)
+          attach_drive8050(unit)
+        end
+        @drive8050.load_modules(modules, input, "BL-D#{device}")
+      end
+    end
+  end
+end

data/lib/badline/machine/settling.rb

@@ -24,6 +24,10 @@ module Badline
         settle_chips_for_snapshot
         ran
       end
+
+      # Settles as #settle_for_snapshot! does, for a snapshot VICE opens,
+      # which a machine with a drive VICE runs settles further.
+      def settle_for_vice! = settle_for_snapshot!
     end
   end
 end

data/lib/badline/machine.rb

@@ -69,20 +69,24 @@ module Badline
     # Media the machine named doesn't take.
     class Unsupported < ArgumentError; end
 
-    # A new machine of `family`, :c64, :vic20, :c128, :plus4 or :pet, 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
+    # A new machine of `family`, :c64, :vic20, :c128, :plus4, :pet or :cbm2, 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, built
     # for C64 mode. A Plus/4's is one of Plus4::Model::ALL or c116, with
     # the model's own RAM. A PET's is one of PET::Model::ALL, with its own
-    # RAM and ROMs, its CRTC's editor the 50 Hz one.
+    # RAM and ROMs, its CRTC's editor the 50 Hz one. A CBM-II's is one of
+    # CBM2::Model::ALL, with VICE's KERNAL, 901244-04a, at 50 Hz, or a 510,
+    # one of CBM2::P500::Model::ALL, with its region's mains.
     def self.build(family, model:, sid_model: nil, reu: nil, ram: nil)
       return vic20(model, ram) if family == :vic20
       return c128(model, sid_model, :c64) if family == :c128
       return Plus4.new(model:) if family == :plus4
       return PET.new(model:) if family == :pet
+      return CBM2::P500.new(model:) if family == :cbm2 && model.start_with?("510")
+      return CBM2.new(model:) if family == :cbm2
       raise ArgumentError, "no machine family named #{family}" unless family == :c64
 
       profile = Model.named(model)
@@ -98,12 +102,14 @@ module Badline
     # 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, a Plus/4 or a PET doesn't take.
+    # Unsupported for media a VIC-20, a Plus/4, a PET or a CBM-II doesn't
+    # take.
     def self.for_options(options, media, &)
       family = options.family
       return vic20_for(media, options.model, options.ram, &) if family == :vic20
       return plus4_for(media, options) if family == :plus4
       return pet_for(media, options) if family == :pet
+      return cbm2_for(media, options) if family == :cbm2
 
       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
@@ -153,16 +159,28 @@ module Badline
 
     # A PET with the RAM --ram names (PET::Model::RAM_SIZES), or with the
     # model's own without it, the editor at the frame rate --60hz or
-    # --editor asks for, and the ROMs --basic and --editor fit it with.
+    # --editor asks for, the ROMs --basic, --editor and --characters fit it
+    # with, and the 8296 board's jumpers --jumpers names.
     def self.pet_for(media, options)
       unsupported = !media.nil? && Media::PETMedia::UNSUPPORTED.include?(File.extname(media).downcase)
       raise Unsupported, "doesn't go in a PET" if unsupported
 
       PET.new(model: options.model, ram_kb: options.ram_kb, refresh_hz: options.refresh_hz, basic: options.basic,
-              editor: options.editor)
+              editor: options.editor, characters: options.characters, jumpers: options.jumpers)
     end
     private_class_method :pet_for
 
+    # A CBM-II with the KERNAL --kernal names, on the mains --60hz asks
+    # for: a B series' 50 Hz without it, and a P500's its region's.
+    def self.cbm2_for(media, options)
+      unsupported = !media.nil? && Media::CBM2Media::UNSUPPORTED.include?(File.extname(media).downcase)
+      raise Unsupported, "doesn't go in a CBM-II" if unsupported
+      return CBM2::P500.new(model: options.model, mains_hz: options.mains_hz) if options.p500?
+
+      CBM2.new(model: options.model, kernal: options.kernal, mains_hz: options.mains_hz || 50)
+    end
+    private_class_method :cbm2_for
+
     def self.c64_media?(media)
       return false if media.nil? || !File.file?(media)
 

data/lib/badline/media/cbm2_media.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # What a CBM-II does with media of its own (Media.attach). Disks of
+    # every kind, .d80 and .d82 among them, directories and .t64 archives
+    # mount on device 8 through the traps on the KERNAL's IEEE-488
+    # primitives (CBM2::IEEETraps), programs load into BASIC's text segment
+    # (Program), and a CBM2 .crt's ROMs go in at their load addresses in
+    # segment 15. There is no datasette, the SID plays no .sid tunes, and
+    # the true drives are serial ones.
+    module CBM2Media
+      # What a CBM-II doesn't take.
+      UNSUPPORTED = Extensions.of(%i[tune tape gcr])
+
+      # What loads and runs the first program on the disk in device 8.
+      AUTOSTART = %(load"*",8\rrun\r)
+
+      # Where BASIC's text starts in segment 1, and the pointers to its end
+      # and to the KERNAL's end address (EAL) in segment 15.
+      BASIC_START = 0x0003
+      TEXT_END = 0x2f
+      EAL = 0x96
+
+      # The ROM chips of a CBM2 .crt.
+      def self.cartridge_chips(path) = Storage::CRTFile.new(path, machine: :cbm2).chips
+    end
+  end
+end

data/lib/badline/media/pet_media.rb

@@ -10,7 +10,7 @@ module Badline
     # is no cartridge port and no SID, and the true drives are serial ones.
     module PETMedia
       # What a PET doesn't take.
-      UNSUPPORTED = Extensions.of(%i[tune cartridge gcr])
+      UNSUPPORTED = Extensions.of(%i[tune cartridge])
 
       # What loads and runs the first program on the disk in device 8.
       AUTOSTART = %(load"*",8\rrun\r)
@@ -26,12 +26,12 @@ 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 goes in as a program file does, once the KERNAL has
-        # booted.
-        def disk_autostart(machine, storage)
+        # program, which the block gives, goes in as a program file does,
+        # once the KERNAL has booted.
+        def disk_autostart(machine)
           return machine.type_text(AUTOSTART) unless machine.model.basic1?
 
-          data = storage.read_file("*")
+          data = yield
           machine.on_init { Program.load(machine, data, autostart: true) } if data
         end
       end

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,18 +4,23 @@ 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. Once a true drive is plugged in as device 8, disk media go into
+    # 1581, or on the PET or the CBM-II a 2031 on the IEEE-488 bus, or for
+    # a .d80 or .d82 an 8050 or 8250. 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 traps' other
-    # disk media, a .t64 or a host directory, raise Error.
+    # image swaps a 1581 back for the machine's own drive. The PET and the
+    # CBM-II have no 1581, and their 2031 reads .d64 and .g64 images only.
+    # 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.
@@ -36,7 +41,7 @@ module Badline
           kind = Extensions.kind(path)
           return true if kind == :gcr
 
-          !drive(computer).nil? && (File.directory?(path) || %i[disk archive].include?(kind))
+          !drive(computer).nil? && (File.directory?(path) || %i[disk archive ieee_disk].include?(kind))
         end
 
         # Puts the image in the drive on device 8, plugging one in that
@@ -44,12 +49,16 @@ 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)
-          return insert_d81(computer, path, read_only) if File.extname(path).casecmp?(".d81")
+          swapped = insert_swapping(computer, path, read_only)
+          return swapped if swapped
 
+          pet = IEEE_FAMILIES.include?(computer.family)
           drive = own_drive(computer)
-          name = drive&.model_name || (computer.family == :c128 ? "1571" : "1541")
+          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
 
@@ -61,10 +70,43 @@ module Badline
 
         private
 
-        # The drive on device 8 unless it's a 1581.
+        # The model plug_true_drive plugs in.
+        def default_model(computer)
+          case computer.family
+          when :c128 then "1571"
+          when :pet, :cbm2 then "2031"
+          else "1541"
+          end
+        end
+
+        # The drive on device 8 unless it's a 1581, or an 8050 or 8250,
+        # which a .d64 swaps back out.
         def own_drive(computer)
           drive = drive(computer)
-          drive unless drive&.model_name == "1581"
+          drive unless %w[1581 8050 8250].include?(drive&.model_name)
+        end
+
+        # A .d81 in a 1581, and on the PET or the CBM-II a .d80 or .d82 in
+        # an 8050 or 8250, each swapped in for the drive there, or nil for
+        # the rest.
+        def insert_swapping(computer, path, read_only)
+          extension = File.extname(path).downcase
+          if IEEE_FAMILIES.include?(computer.family)
+            insert_d80(computer, path, read_only) if %w[.d80 .d82].include?(extension)
+          elsif extension == ".d81"
+            insert_d81(computer, path, read_only)
+          end
+        end
+
+        # An 8050 for a .d80 and an 8250 for a .d82, swapped in for the
+        # drive on device 8 unless it's that model already.
+        def insert_d80(computer, path, read_only)
+          model = File.extname(path).casecmp?(".d82") ? "8250" : "8050"
+          drive = drive(computer)
+          drive = computer.plug_drive8050(model) unless drive&.model_name == model
+          drive.insert_image(path, read_only:)
+          computer.unmount
+          "Inserted #{path} in the #{model} as device 8"
         end
 
         def insert_d81(computer, path, read_only)

data/lib/badline/media.rb

@@ -12,6 +12,7 @@ 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/tune"
 require "badline/media/program"
 
@@ -53,8 +54,9 @@ 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.
+      # 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.
       def attach(computer, path, autostart: true, subtune: nil, **)
         path = DiskList.disk(path)
         refuse_unsupported(computer, path)
@@ -126,17 +128,19 @@ 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.
+      # and only the PET and the CBM-II have the IEEE-488 drive a .d80 or
+      # .d82 goes in.
       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"
+        if Extensions.kind(path) == :ieee_disk && !%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)
@@ -159,7 +163,11 @@ module Badline
 
       def attach_true_drive(computer, path, disk, autostart:)
         message = TrueDrive.insert(computer, path, read_only: disk.fetch(:read_only, false))
-        computer.type_text(disk_autostart(computer) { Vic20Media.first_program(path) }) if autostart
+        if autostart && computer.family == :pet
+          PETMedia.disk_autostart(computer) { Vic20Media.first_program(path) }
+        elsif autostart
+          computer.type_text(disk_autostart(computer) { Vic20Media.first_program(path) })
+        end
         message
       end
 
@@ -167,7 +175,7 @@ module Badline
         storage = open_storage(path, disk)
         computer.mount(storage)
         if autostart && computer.family == :pet
-          PETMedia.disk_autostart(computer, storage)
+          PETMedia.disk_autostart(computer) { storage.read_file("*") }
         elsif autostart
           computer.type_text(disk_autostart(computer) { storage.read_file("*") })
         end
@@ -178,7 +186,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
@@ -190,6 +202,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"
 
@@ -13,7 +14,8 @@ module Badline
 
       private
 
-      # Takes `sid`, `c64`, `vic20`, `c128`, `plus4` or `pet` when given first.
+      # Takes `sid`, `c64`, `vic20`, `c128`, `plus4`, `pet` or `cbm2` when
+      # given first.
       def subcommand(args)
         case args.first
         when "sid" then @sid_command = true
@@ -22,6 +24,7 @@ module Badline
         when "c128" then @family = :c128
         when "plus4" then @family = :plus4
         when "pet" then @family = :pet
+        when "cbm2" then @family = :cbm2
         else return
         end
         @family_named = !@sid_command
@@ -34,23 +37,32 @@ module Badline
         when :c128 then C128_MODELS
         when :plus4 then PLUS4_MODELS
         when :pet then PET_MODELS
+        when :cbm2 then CBM2_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, and a
+      # cartridge signed as a CBM-II's the CBM-II'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?
           @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 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 or a PET tape.
       def pet_media?
         kind = Media::Extensions.kind(@media_path)

data/lib/badline/options/help.rb

@@ -86,6 +86,7 @@ module Badline
                #{@program} c128 [options] [media]
                #{@program} plus4 [options] [media]
                #{@program} pet [options] [media]
+               #{@program} cbm2 [options] [media]
                #{@program} --headless [options] tune.sid
                #{@program} [options] tune.sid --audio-out FILE
                #{@program} sid [options] FILE|DIR...
@@ -96,6 +97,7 @@ module Badline
             c128                             Run a C128 in C128 mode, the one --model names
             plus4                            Run a Plus/4 or a C16, the one --model names
             pet                              Run a PET or a CBM, the one --model names
+            cbm2                             Run a CBM-II, a B series or a P500, the one --model names
             sid                              Play .sid tunes and directories of them
 
         #{media_kinds}
@@ -126,10 +128,26 @@ module Badline
         and the pause menu's KEYBOARD page says where the rest are. --basic
         and --editor fit the upgrades Commodore sold, as in --model 2001
         --basic 2. BASIC 1 can't LOAD from a disk drive, though a disk still
-        starts its first program, and BASIC 2 can. The 8032 and the 8096
-        have two 50 Hz editors: 4-80-b-50hz, the default, and
-        4-80-b-50hz-0283, another chip's, with 64-cycle lines and 313 lines
-        a frame.
+        starts its first program, and BASIC 2 can. Their --true-drive makes
+        device 8 an emulated 2031 on the IEEE-488 bus, which reads .d64 and
+        .g64 images. The 8032 and the 8096 have two 50 Hz editors:
+        4-80-b-50hz, the default, and 4-80-b-50hz-0283, another chip's,
+        with 64-cycle lines and 313 lines a frame. The 8296 runs its own,
+        4-80-b-50hz-8296, and takes the 8032's too. --characters din fits
+        it with the DIN character ROM, and --jumpers ram9,rama puts RAM at
+        $9000 and $A000, as xpet's -petram9 and -petramA do.
+
+        The CBM-II takes programs, disks, .d80 and .d82 among them, and
+        cartridges, and a cartridge made for it starts one without `cbm2`.
+        --kernal 03b fits the 1983 KERNAL in place of 04a, and --60hz runs
+        it on 60 Hz mains. Its --true-drive makes device 8 an emulated 2031
+        on its IEEE-488 bus, which reads .d64 and .g64 images, and a .d80
+        or a .d82 then goes in an emulated 8050 or 8250. Its keys type what
+        the host's keys type, F12 is RUN/STOP, Alt with F9 or F10 presses
+        its F9 or F10, and the pause menu's KEYBOARD page says where the
+        rest are. --model 510 or 510ntsc runs the P500, on the VIC-II with
+        KERNAL 02, whose keys are the B series' and whose two joysticks Tab
+        switches to.
 
         --headless plays a .sid tune on the host's audio device without the
         window, and --audio-out renders it to 16-bit PCM instead. The
@@ -152,8 +170,8 @@ module Badline
         in --at 3500:key=space or --at 250,500:screenshot=shot%05d.bmp.
         key=NAME presses a key (space, return, a, f1, run_stop, restore, and
         on the C128 esc, help, keypad1 and the rest, on the Plus/4
-        esc, help and f1 to f3, and on the PET rvs, escape and kp1) or a
-        joystick's
+        esc, help and f1 to f3, on the PET rvs, escape and kp1, and on
+        the CBM-II escape, norm_graph and kp00) or a joystick's
         direction or fire (joy1-up, joy2-fire) for #{Event::HOLD} frames, and
         pushes the C128's caps_lock or forty_eighty, which lock. type=TEXT
         types it, with \\n for RETURN. insert=FILE swaps in a disk, a list's