badline 0.16.1 → 0.17.0

data/lib/badline/kernal_trap/ieee_layout.rb

@@ -2,70 +2,122 @@
 
 module Badline
   module KernalTrap
-    # Where a PET KERNAL keeps the eight IEEE-488 bus primitives, which are
-    # internal routines, not jump table entries, and the ZeroPage of its
-    # file variables. Each ROM set has its own.
-    #
-    # TALK and LISTEN take no device number in A: they send $40 or $20
-    # ORed with FA. UNTALK and UNLISTEN send $5F and $3F through the same
-    # code, and SECOND, TKSA, UNTALK and UNLISTEN end by letting go of ATN
-    # (VIA PB2) themselves. Each handshake times out on VIA timer 1, which
-    # the ROM starts with a write of $FF to $E845. LOAD and SAVE run in the
-    # ROM, through the primitives. +overwrites_device+ says UNTALK and
-    # UNLISTEN store their command in FA before they send it.
+    # The +keep+ of an IEEELineStep that only reads its register.
+    IEEE_LINE_READ = -1
+
+    # One step a KERNAL takes on the IEEE-488 bus's lines: a write of +set+
+    # to the register at +address+, or with a +keep+ mask the register read
+    # first, its +keep+ bits kept and +set+ ORed in, or with keep
+    # IEEE_LINE_READ only a read. Returns the value written, or read.
+    IEEELineStep = Data.define(:address, :keep, :set) do
+      def act_on(bus)
+        return bus.peek(address) if keep == IEEE_LINE_READ
+
+        value = keep.zero? ? set : (bus.peek(address) & keep) | set
+        bus.poke(address, value)
+        value
+      end
+    end
+
+    # The steps a KERNAL takes on the bus's lines at each moment the traps
+    # stand in for, each run in order (#run_steps), the last one's value
+    # returned: +timer+ starts the timer that times out each byte's
+    # handshake, +attention+ readies the bus and pulls ATN low for TALK
+    # and LISTEN, +byte_sent+ ends a byte sent, +release_attention+ ends
+    # SECOND, TKSA, UNTALK and UNLISTEN by letting ATN go, +listen_to_talker+
+    # ends TKSA with the computer listening, +byte_received+ ends ACPTR,
+    # and +release+ ends UNTALK and UNLISTEN.
+    IEEELines = Data.define(:timer, :attention, :byte_sent, :release_attention, :listen_to_talker, :byte_received,
+                            :release) do
+      def run_steps(steps, bus)
+        value = 0
+        steps.each { |step| value = step.act_on(bus) }
+        value
+      end
+    end
+
+    # Where a KERNAL keeps the eight IEEE-488 bus primitives, which are
+    # internal routines, not jump table entries, the ZeroPage of its file
+    # variables, and the steps it takes on the bus's lines (IEEELines).
+    # Each ROM set has its own.
     #
-    # The ROM drives the bus's control lines from three chips: ATN from VIA
-    # PB2 and NRFD from PB1 at $E840, NDAC from PIA 2's CA2 and DAV from its
-    # CB2, through the control registers at $E821 and $E823, which the ROM
-    # writes $34 to pull a line low and $3C to let it go, and the data lines
-    # from PIA 2's port B at $E822. The steps below leave the lines as each
-    # primitive leaves them.
+    # On a PET, TALK and LISTEN take no device number in A: they send $40
+    # or $20 ORed with FA. UNTALK and UNLISTEN send $5F and $3F through the
+    # same code, and SECOND, TKSA, UNTALK and UNLISTEN end by letting go of
+    # ATN themselves. LOAD and SAVE run in the ROM, through the primitives.
+    # +overwrites_device+ says UNTALK and UNLISTEN store their command in
+    # FA before they send it. +device_in_a+ says TALK and LISTEN take the
+    # device in A, as the CBM-II's do, where a PET's ignore A and read FA.
     IEEELayout = Data.define(:talk, :listen, :second, :tksa, :ciout, :untalk, :unlisten, :acptr, :overwrites_device,
-                             :zero_page) do
-      # The KERNAL is mapped unless an 8096's board lies over it.
+                             :device_in_a, :zero_page, :lines) do
+      # The KERNAL is mapped unless something lies over it.
       def kernal_mapped?(bus) = bus.kernal_mapped?
 
-      # Starts VIA timer 1, which times out the handshake of each byte.
+      # Starts the timer that times out the handshake of each byte.
       def time_serial_byte(bus, _timer_high)
-        bus.poke(0xe845, 0xff)
+        lines.run_steps(lines.timer, bus)
       end
 
-      # TALK and LISTEN: NRFD and NDAC let go, then ATN pulled low.
+      # TALK and LISTEN: the handshake lines let go, then ATN pulled low.
       def attention(bus)
-        bus.poke(0xe840, bus.peek(0xe840) | 0x02)
-        bus.poke(0xe821, 0x3c)
-        bus.poke(0xe840, bus.peek(0xe840) & 0xfb)
+        lines.run_steps(lines.attention, bus)
       end
 
       # The end of a byte sent: DAV and the data lines let go.
       def byte_sent(bus)
-        bus.poke(0xe823, 0x3c)
-        bus.poke(0xe822, 0xff)
+        lines.run_steps(lines.byte_sent, bus)
       end
 
       # The end of SECOND, TKSA, UNTALK and UNLISTEN: ATN let go. Returns
       # the value written, which the ROM leaves in A.
       def release_attention(bus)
-        value = bus.peek(0xe840) | 0x04
-        bus.poke(0xe840, value)
-        value
+        lines.run_steps(lines.release_attention, bus)
       end
 
-      # TKSA and ACPTR end listening: NRFD and NDAC pulled low.
+      # TKSA ends listening: NRFD and NDAC pulled low.
       def listen_to_talker(bus)
-        bus.poke(0xe840, bus.peek(0xe840) & 0xfd)
-        bus.poke(0xe821, 0x34)
+        lines.run_steps(lines.listen_to_talker, bus)
+      end
+
+      # ACPTR ends listening as well.
+      def byte_received(bus)
+        lines.run_steps(lines.byte_received, bus)
       end
 
       # The end of UNTALK and UNLISTEN, which address the bus as TALK and
-      # LISTEN do, send their command and let ATN go.
+      # LISTEN do, send their command and let ATN go. Returns the value
+      # the ROM leaves in A.
       def release_serial_lines(bus)
-        attention(bus)
-        byte_sent(bus)
-        release_attention(bus)
+        lines.run_steps(lines.release, bus)
       end
     end
 
+    # A PET drives the bus's control lines from three chips: ATN from VIA
+    # PB2 and NRFD from PB1 at $E840, NDAC from PIA 2's CA2 and DAV from its
+    # CB2, through the control registers at $E821 and $E823, which the ROM
+    # writes $34 to pull a line low and $3C to let it go, and the data lines
+    # from PIA 2's port B at $E822. Each handshake times out on VIA timer 1,
+    # which the ROM starts with a write of $FF to $E845. The steps leave the
+    # lines as each primitive leaves them.
+    PET_ATTENTION = [
+      IEEELineStep.new(address: 0xe840, keep: 0xff, set: 0x02),
+      IEEELineStep.new(address: 0xe821, keep: 0, set: 0x3c),
+      IEEELineStep.new(address: 0xe840, keep: 0xfb, set: 0)
+    ].freeze
+    PET_BYTE_SENT = [
+      IEEELineStep.new(address: 0xe823, keep: 0, set: 0x3c),
+      IEEELineStep.new(address: 0xe822, keep: 0, set: 0xff)
+    ].freeze
+    PET_RELEASE_ATTENTION = [IEEELineStep.new(address: 0xe840, keep: 0xff, set: 0x04)].freeze
+    PET_LISTEN = [IEEELineStep.new(address: 0xe840, keep: 0xfd, set: 0),
+                  IEEELineStep.new(address: 0xe821, keep: 0, set: 0x34)].freeze
+    PET_LINES = IEEELines.new(
+      timer: [IEEELineStep.new(address: 0xe845, keep: 0, set: 0xff)].freeze,
+      attention: PET_ATTENTION, byte_sent: PET_BYTE_SENT, release_attention: PET_RELEASE_ATTENTION,
+      listen_to_talker: PET_LISTEN, byte_received: PET_LISTEN,
+      release: (PET_ATTENTION + PET_BYTE_SENT + PET_RELEASE_ATTENTION).freeze
+    )
+
     # The file variables of the BASIC 2 and BASIC 4 KERNALs, which keep
     # them at the same addresses. SAVE copies STAL at $FB to SAL at $C7 and
     # walks SAL up to EAL at $C9. LOAD keeps no MEMUSS: it stores each byte
@@ -90,24 +142,24 @@ module Badline
     # LISTEN without a secondary address.
     PET_BASIC1_LAYOUT = IEEELayout.new(
       talk: 0xf0b6, listen: 0xf0ba, second: 0xf12c, tksa: 0xf15b,
-      ciout: 0xf167, untalk: 0xf17a, unlisten: 0xf17e, acptr: 0xf187, overwrites_device: true,
-      zero_page: PET_BASIC1_ZERO_PAGE
+      ciout: 0xf167, untalk: 0xf17a, unlisten: 0xf17e, acptr: 0xf187, overwrites_device: true, device_in_a: false,
+      zero_page: PET_BASIC1_ZERO_PAGE, lines: PET_LINES
     )
 
     # BASIC 2, 901465-03. Its LOAD sends the secondary address after TALK
     # with SECOND, not TKSA.
     PET_BASIC2_LAYOUT = IEEELayout.new(
       talk: 0xf0b6, listen: 0xf0ba, second: 0xf128, tksa: 0xf164,
-      ciout: 0xf16f, untalk: 0xf17f, unlisten: 0xf183, acptr: 0xf18c, overwrites_device: false,
-      zero_page: PET_ZERO_PAGE
+      ciout: 0xf16f, untalk: 0xf17f, unlisten: 0xf183, acptr: 0xf18c, overwrites_device: false, device_in_a: false,
+      zero_page: PET_ZERO_PAGE, lines: PET_LINES
     )
 
     # BASIC 4, 901465-22. LISTEN at $F0D5 is the operand of the BIT
     # instruction that skips it on the way from TALK.
     PET_BASIC4_LAYOUT = IEEELayout.new(
       talk: 0xf0d2, listen: 0xf0d5, second: 0xf143, tksa: 0xf193,
-      ciout: 0xf19e, untalk: 0xf1ae, unlisten: 0xf1b9, acptr: 0xf1c0, overwrites_device: false,
-      zero_page: PET_ZERO_PAGE
+      ciout: 0xf19e, untalk: 0xf1ae, unlisten: 0xf1b9, acptr: 0xf1c0, overwrites_device: false, device_in_a: false,
+      zero_page: PET_ZERO_PAGE, lines: PET_LINES
     )
   end
 end

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
@@ -164,6 +170,17 @@ module Badline
     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/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,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, 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
+    # 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 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.
+    # 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.
@@ -45,9 +49,10 @@ 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")
+          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 || default_model(computer)
           types = name == "1571" ? %w[.d64 .g64 .d71 .g71] : %w[.d64 .g64]
@@ -69,15 +74,39 @@ module Badline
         def default_model(computer)
           case computer.family
           when :c128 then "1571"
-          when :pet then "2031"
+          when :pet, :cbm2 then "2031"
           else "1541"
           end
         end
 
-        # The drive on device 8 unless it's a 1581.
+        # 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)
@@ -182,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
@@ -194,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