badline 0.16.0 → 0.17.0

data/lib/badline/drives/model8050.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require "badline/chips/riot"
+require "badline/chips/rriot"
+require "badline/drives/ieee_bus"
+require "badline/drives/engine"
+require "badline/drives/model8050/ip_bus"
+require "badline/drives/model8050/fdc_bus"
+require "badline/drives/model8050/parts"
+require "badline/drives/model8050/ieee_port"
+require "badline/drives/model8050/disk"
+require "badline/drives/model8050/mechanism"
+require "badline/drives/model8050/idle"
+require "badline/drives/model8050/keyed_state"
+
+module Badline
+  module Drives
+    # The 8050 dual disk drive of the PET and CBM-II, two drives on one
+    # IEEE-488 unit (schematic 8050001; the 8050/8250 service manual).
+    #
+    # Two 6502s share the board, clocked at 1 MHz from one 12 MHz crystal
+    # on opposite phases. The interface processor (IP) runs DOS 2.7 from
+    # 16 KB of ROM at $C000, with two 6532s (IPBus): their RAM is its zero
+    # page and stack, and their ports face the IEEE-488 bus (IEEEPort). The
+    # floppy controller (FDC) runs the 1 KB program in its 6530's ROM, with
+    # a VIA and the 6530 facing the drives (FDCBus, Mechanism). The two
+    # meet in 4 KB of common RAM, which each reaches in its own half of
+    # the cycle: the IP leaves jobs there, and the FDC runs them.
+    #
+    # Reset starts both. The FDC waits on the common RAM for the IP, which
+    # tests it, copies the FDC's start-up code into it ($C370) and waits for
+    # the FDC to answer, before both settle into their idle loops.
+    #
+    # The drive clocks against the host through a phase accumulator, as
+    # Drives::Engine::Core does: each host cycle adds 1 MHz of phase, and
+    # every whole host period in it runs a cycle of both processors. While
+    # both processors idle, it sleeps instead (Idle), and the readers of its
+    # parts catch it up first.
+    class Model8050
+      include Idle
+
+      CLOCK_HZ = 1_000_000
+
+      # The host cycles by which a unit switched on with the machine has
+      # run the IP's RAM test and the FDC's start-up and reads its jumpers.
+      BOOT_CYCLES = 1_500_000
+
+      attr_reader :device, :ieee_bus
+
+      def ip_cpu = settled(@ip_cpu)
+
+      def fdc_cpu = settled(@fdc_cpu)
+
+      def ip_bus = settled(@ip_bus)
+
+      def fdc_bus = settled(@fdc_bus)
+
+      def common = settled(@common)
+
+      def data_riot = settled(@data_riot)
+
+      def control_riot = settled(@control_riot)
+
+      def via = settled(@via)
+
+      def rriot = settled(@rriot)
+
+      def mechanism = settled(@mechanism)
+
+      def cycles
+        settle!
+        @cycles
+      end
+
+      attr_writer :host_clock_hz
+
+      def model_name = "8050"
+
+      # The sides each drive's disk has.
+      def sides = 1
+
+      # +dos_rom+ covers $C000-$FFFF and +fdc_rom+ is the 6530's mask, each
+      # defaulting to the image in the ROM path: DOS 2.7 and the mask for
+      # MPI mechanisms. +device+ is the number the jumpers set, 8 to 15.
+      def initialize(dos_rom: nil, fdc_rom: nil, host_clock_hz: CLOCK_HZ, device: 8)
+        @device = device
+        @host_clock_hz = host_clock_hz
+        @phase = 0
+        @cycles = 0
+        build_ip(dos_rom || ROM.load("8050/dos-2.7.rom", 0xc000))
+        build_fdc(fdc_rom || ROM.read("8050/fdc-901869-01.rom"))
+        @ip_cpu = IPCPU.new(@ip_bus)
+        @fdc_cpu = FDCCPU.new(@fdc_bus)
+        init_idle
+        @ieee_bus.attach(self)
+      end
+
+      # Plugs the unit into an IEEE-488 bus, leaving the one it was on.
+      def connect(ieee_bus)
+        settle!
+        @ieee_bus.detach(self)
+        @ieee_bus = ieee_bus
+        @ieee_port.bus = ieee_bus
+        ieee_bus.attach(self)
+      end
+
+      # The lines the unit pulls on the bus while ATN is low or not
+      # (IEEEPort).
+      def ieee_low_lines(atn) = @ieee_port.ieee_low_lines(atn)
+
+      # The controller pushed its lines into the bus.
+      def host_written! = nil
+
+      # Which LEDs are lit: bit 0 drive 1's, bit 1 drive 0's, bit 2 the
+      # error LED. They hold still while the unit sleeps, so reading them
+      # leaves it asleep.
+      def leds = @ieee_port.leds
+
+      def led_on? = leds.anybits?(0x03)
+
+      # Puts a Disk in +drive+, 0 or 1. Nil takes the disk out.
+      def insert(disk, drive: 0)
+        settle!
+        @mechanism.insert(disk, drive)
+      end
+
+      # Puts in the .d80 or .d82 image at +path+, write-protected with
+      # `read_only`.
+      def insert_image(path, drive: 0, read_only: false)
+        image_class = File.extname(path).casecmp?(".d82") ? Storage::D82Image : Storage::D80Image
+        insert(Disk.new(image_class.new(path, read_only:)), drive:)
+      end
+
+      # The Disk in +drive+, or nil.
+      def disk(drive = 0) = @mechanism.disk(drive)
+
+      # Stores what the heads wrote in the disks' images, as the motors
+      # stopping do.
+      def flush
+        settle!
+        @mechanism.flush
+      end
+
+      def power_led_on? = true
+
+      # Runs the drive cycles that fall in one host cycle, then takes the
+      # controller's lines for the next. Asleep, the unit owes the cycles
+      # instead, and wakes once the controller has moved a line.
+      def host_cycle!
+        phase = @phase + CLOCK_HZ
+        while phase >= @host_clock_hz
+          @asleep ? owe_cycle : run_cycle
+          phase -= @host_clock_hz
+        end
+        @phase = phase
+        settle! if @asleep && @ieee_port.lines_moved?
+        @ieee_port.latch_host
+      end
+
+      def cycle!
+        settle!
+        run_cycle
+      end
+
+      # The bus's IFC line resets both processors and every chip. RAM keeps
+      # its contents.
+      def reset!
+        settle!
+        @data_riot.reset!
+        @control_riot.reset!
+        @via.reset!
+        @rriot.reset!
+        @ip_cpu.reset!
+        @fdc_cpu.reset!
+      end
+
+      def inspect
+        "#<#{self.class.name} cycles=#{@cycles} ip=(#{@ip_cpu.inspect}) fdc=(#{@fdc_cpu.inspect})>"
+      end
+
+      private
+
+      def settled(part)
+        settle!
+        part
+      end
+
+      def run_cycle
+        step
+        watch_loops if @idle_skip
+      end
+
+      def build_ip(rom)
+        @common = Memory.new([], length: 0x1000)
+        @ieee_bus = IEEEBus.new
+        @ieee_port = IEEEPort.new(device: @device, bus: @ieee_bus)
+        @data_riot = DataRIOT.new(peripheral: DataLines.new(@ieee_port))
+        @control_riot = ControlRIOT.new(peripheral: ControlLines.new(@ieee_port))
+        @ieee_port.data_riot = @data_riot
+        @ieee_port.control_riot = @control_riot
+        @ip_bus = IPBus.new(rom:, common: @common, data_riot: @data_riot, control_riot: @control_riot)
+      end
+
+      def build_fdc(rom)
+        @mechanism = Mechanism.new(sides:)
+        @via = ControllerVIA.new(start: 0x0040, peripheral: ReadLines.new(@mechanism))
+        @rriot = ControllerRRIOT.new(rom:, peripheral: StatusLines.new(@mechanism))
+        @fdc_bus = FDCBus.new(common: @common, via: @via, rriot: @rriot)
+        @mechanism.via = @via
+        @mechanism.rriot = @rriot
+      end
+
+      # One cycle of the board: the drives, then the chips, then the IP and
+      # the FDC, each in its own half of the cycle. ATN reaches UE1's PA7 as
+      # the port latched it. UE1 pulls the IP's IRQ, and the VIA and the
+      # 6530 the FDC's. Byte ready sets the FDC's V flag through SO for the
+      # next cycle's instruction step, as on the 1541.
+      def step
+        so = @mechanism.take_so
+        @mechanism.cycle!
+        @control_riot.pa7 = @ieee_port.atn_low?
+        @data_riot.cycle!
+        @control_riot.cycle!
+        @via.cycle!
+        @rriot.cycle!
+        @ip_cpu.irq = @control_riot.irq?
+        @ip_cpu.cycle!
+        @fdc_cpu.irq = @via.irq? || @rriot.irq?
+        @fdc_cpu.so! if so
+        @fdc_cpu.cycle!
+        @cycles += 1
+      end
+    end
+
+    # The 8250: the 8050's board driving double-sided mechanisms, 154 tracks
+    # a disk, with jumper E3 grounding the 6530's PB6 to say so.
+    class Model8250 < Model8050
+      def model_name = "8250"
+
+      def sides = 2
+    end
+  end
+end

data/lib/badline/frontend/app.rb

@@ -111,16 +111,23 @@ module Badline
         end
       end
 
+      # The window keeps F8, F9, F10, Tab and the snapshot keys for itself,
+      # but for the keys the machine claims (Controls#claims?).
       def handle_key(scancode, down)
-        if [Keys::F8, Keys::F9, Keys::F10].include?(scancode) || (scancode == Keys::TAB && @controls.tab_toggles?)
+        claimed = @controls.claims?(scancode)
+        if !claimed && toggle?(scancode)
           handle_toggle(scancode) if down
-        elsif down && @snapshots.key(scancode)
+        elsif !claimed && down && @snapshots.key(scancode)
           swap(@snapshots.computer)
-        elsif !Snapshots::KEYS.include?(scancode)
+        elsif claimed || !Snapshots::KEYS.include?(scancode)
           @controls.key(scancode, down)
         end
       end
 
+      def toggle?(scancode)
+        [Keys::F8, Keys::F9, Keys::F10].include?(scancode) || (scancode == Keys::TAB && @controls.tab_toggles?)
+      end
+
       # Runs the restored machine in place of the one before: the screen,
       # the drive LED, the controls, the gamepads and the sound go over to
       # it.

data/lib/badline/frontend/boot.rb

@@ -10,7 +10,7 @@ module Badline
     # attach, an --at key names nothing or an event fails, which it warns
     # about.
     def self.run(options)
-      error = Timeline.error(options.timeline, options.family)
+      error = Timeline.error(options.timeline, options.p500? ? :p500 : options.family)
       unless error.empty?
         warn "#{options.program}: #{error}"
         return 1

data/lib/badline/frontend/controls.rb

@@ -8,10 +8,12 @@ module Badline
     #   switches, the arrow cluster and space drive one joystick and WASD
     #   and left shift the other. The arrows start on joystick 2, and
     #   #swap_ports swaps them. The VIC-20's one joystick takes both. The
-    #   PET has no joystick, and its keys go by the character they type
-    #   (PETKeyboard).
-    # - A pot device the pause menu plugs into a C64 control port: a 1351
-    #   mouse or a pair of paddles, which the host mouse drives. Motion
+    #   PET's and the CBM-II's keys go by the character they type
+    #   (PETKeyboard), and the PET and the CBM-II's B series have no
+    #   joystick.
+    # - A pot device the pause menu plugs into a control port of a C64, a
+    #   C128 or a P500: a 1351 mouse or a pair of paddles, which the host
+    #   mouse drives. Motion
     #   turns the paddles or moves the mouse, and the host's left and right
     #   buttons go to whichever lines the device puts them on.
     class Controls
@@ -24,6 +26,21 @@ module Badline
       # The pot device plugged in, one of POTS.
       attr_reader :pot, :arrows_port
 
+      # Whether the machine has joysticks: all but the PET and the CBM-II's
+      # B series.
+      def self.joysticks?(computer)
+        family = computer.family
+        family != :pet && (family != :cbm2 || p500?(computer))
+      end
+
+      # Whether the machine is the CBM-II's P500, which has the B series'
+      # keyboard and two joysticks.
+      def self.p500?(computer) = computer.is_a?(CBM2::P500)
+
+      # Whether the machine's keys go by the character they type: the PET's
+      # and the CBM-II's.
+      def self.symbolic?(computer) = %i[pet cbm2].include?(computer.family)
+
       def initialize(computer)
         @computer = computer
         @joystick = false
@@ -58,9 +75,19 @@ module Badline
         self.joystick_mode = !@joystick if tab_toggles?
       end
 
-      # Whether Tab switches the keys to the joysticks, or on the PET, which
-      # has none, is a key of its own.
-      def tab_toggles? = @computer.family != :pet
+      # Whether Tab switches the keys to the joysticks, or on a machine
+      # without them is a key of its own.
+      def tab_toggles? = Controls.joysticks?(@computer)
+
+      # Whether the machine takes a key the window would otherwise keep for
+      # itself: on the CBM-II, F8, RUN/STOP on F12, Alt with F9 or F10, and
+      # the release of any key it pressed.
+      def claims?(scancode)
+        return false unless @computer.family == :cbm2
+        return true if @pet_keyboard.holds?(scancode) || [Keys::F8, Keys::F12].include?(scancode)
+
+        @pet_keyboard.alt? && [Keys::F9, Keys::F10].include?(scancode)
+      end
 
       # Plugs in one of POTS, in place of the one before.
       def plug(pot)
@@ -116,7 +143,7 @@ module Badline
       # A host key lets go of the key it pressed, though the C128 has
       # switched between C64 and C128 mode since and maps it elsewhere.
       def machine_key(scancode, down)
-        return @pet_keyboard.key(scancode, down) if @computer.family == :pet
+        return @pet_keyboard.key(scancode, down) if Controls.symbolic?(@computer)
 
         @held[scancode] = host_key(scancode) if down || !@held.key?(scancode)
         key = @held[scancode]
@@ -159,7 +186,7 @@ module Badline
       # A fresh pot device on its port, and none on the other. A machine
       # without the ports takes none.
       def attach_pot_device
-        ports = @computer.family == :pet ? nil : @computer.control_ports
+        ports = Controls.p500?(@computer) || !Controls.symbolic?(@computer) ? @computer.control_ports : nil
         if ports.nil?
           @pot = :none
           return
@@ -211,17 +238,26 @@ module Badline
         down ? joystick.press(direction) : joystick.release(direction)
       end
 
-      # The PET's keyboard for a PET, and for any other machine one it never
-      # uses.
+      # The PET's keyboard for a PET or a CBM-II, and for any other machine
+      # one it never uses.
       def pet_keyboard(computer)
-        PETKeyboard.new(computer.keyboard, computer.family == :pet ? computer.model.keyboard : :graphics)
+        layout = case computer.family
+                 when :pet then computer.model.keyboard
+                 when :cbm2 then :cbm2
+                 else :graphics
+                 end
+        PETKeyboard.new(computer.keyboard, layout)
       end
 
       def release_all
-        return @pet_keyboard.release_all if @computer.family == :pet
+        if Controls.symbolic?(@computer)
+          @pet_keyboard.release_all
+        else
+          Keys::ARROWS.each_key { |scancode| @computer.keyboard.release(host_key(scancode)) }
+          Keys::WASD.each_key { |scancode| @computer.keyboard.release(host_key(scancode)) }
+        end
+        return unless Controls.joysticks?(@computer)
 
-        Keys::ARROWS.each_key { |scancode| @computer.keyboard.release(host_key(scancode)) }
-        Keys::WASD.each_key { |scancode| @computer.keyboard.release(host_key(scancode)) }
         Keys::ARROWS.each_value do |direction|
           @computer.joystick1.release(direction)
           @computer.joystick2.release(direction)

data/lib/badline/frontend/gamepads.rb

@@ -7,8 +7,8 @@ module Badline
     # second one joystick 1. PadPort holds the mapping.
     #
     # The controllers are polled every frame, and rescanned whenever SDL
-    # reports one added or removed. The PET has no joysticks, and the
-    # controllers steer two that nothing reads.
+    # reports one added or removed. The PET and the CBM-II's B series have
+    # no joysticks, and the controllers steer two that nothing reads.
     class Gamepads
       PORTS = [2, 1].freeze
 
@@ -53,7 +53,7 @@ module Badline
       private
 
       def joystick(computer, port)
-        return Input::Joystick.new if computer.family == :pet
+        return Input::Joystick.new unless Controls.joysticks?(computer)
 
         port == 1 ? computer.joystick1 : computer.joystick2
       end

data/lib/badline/frontend/keys.rb

@@ -3,8 +3,8 @@
 module Badline
   module Frontend
     # SDL scancodes follow key positions on a US layout. They map onto the C64
-    # keys, the C128's and the 264's own keys and, in joystick mode, the
-    # joystick directions.
+    # keys, the C128's, the 264's, the PET's and the CBM-II's own keys and,
+    # in joystick mode, the joystick directions.
     module Keys
       RETURN = 40
       ESCAPE = 41
@@ -118,6 +118,41 @@ module Badline
       # The cursor keys, CRSR ⇔ and CRSR ⇕, each with SHIFT for left or up.
       PET_CURSORS = { RIGHT => :cursor_h, LEFT => :cursor_h, DOWN => :cursor_v, UP => :cursor_v }.freeze
 
+      # The CBM-II's keys for the characters a host key types: those it
+      # types without SHIFT, then those it types with it, as the KERNAL's
+      # key tables place them. ← is on _ and `, and SHIFT turns it into \.
+      CBM2_CHARACTERS = {
+        "1" => :"1", "2" => :"2", "3" => :"3", "4" => :"4", "5" => :"5", "6" => :"6", "7" => :"7", "8" => :"8",
+        "9" => :"9", "0" => :"0", "-" => :-, "=" => :"=", "[" => :"[", "]" => :"]", ";" => :";", "'" => :"'",
+        "," => :",", "." => :".", "/" => :/, "_" => :left_arrow, "`" => :left_arrow
+      }.freeze
+
+      CBM2_SHIFTED = {
+        "!" => :"1", "@" => :"2", "#" => :"3", "$" => :"4", "%" => :"5", "^" => :"6", "&" => :"7", "*" => :"8",
+        "(" => :"9", ")" => :"0", "+" => :"=", ":" => :";", "\"" => :"'", "<" => :",", ">" => :".", "?" => :/,
+        "\\" => :left_arrow
+      }.freeze
+
+      # The CBM-II's keys that don't type a character, which keep the
+      # host's SHIFT: RETURN, INST/DEL on Backspace, CLR/HOME on Home, ESC,
+      # TAB, RUN/STOP on F12, CTRL on Control, the four cursor keys on the
+      # arrows, F1-F8 on F1-F8, and the keypad on the host's.
+      CBM2_KEYS = {
+        40 => :return, 42 => :delete, 44 => :space, 74 => :clr_home, 41 => :escape, 43 => :tab, 69 => :run_stop,
+        224 => :control, 228 => :control, 79 => :cursor_right, 80 => :cursor_left, 81 => :cursor_down,
+        82 => :cursor_up, 58 => :f1, 59 => :f2, 60 => :f3, 61 => :f4, 62 => :f5, 63 => :f6, 64 => :f7, 65 => :f8,
+        84 => :kp_divide, 85 => :kp_multiply, 86 => :kp_minus, 87 => :kp_plus, 88 => :kp_enter, 89 => :kp1,
+        90 => :kp2, 91 => :kp3, 92 => :kp4, 93 => :kp5, 94 => :kp6, 95 => :kp7, 96 => :kp8, 97 => :kp9,
+        98 => :kp0, 99 => :kp_period
+      }.freeze
+
+      # The CBM-II's keys that Alt and a host key press: C= on C, CE on E,
+      # NORM/GRAPH on G, OFF/RVS on R, π on P, 00 on 0, and F9 and F10 on
+      # F9 and F10, which open the pause menu and mute without Alt.
+      CBM2_ALT_KEYS = {
+        6 => :cbm, 8 => :ce, 10 => :norm_graph, 21 => :off_rvs, 19 => :pi, 39 => :kp00, 66 => :f9, 67 => :f10
+      }.freeze
+
       ARROWS = { 44 => :fire, 228 => :fire, 79 => :right, 80 => :left, 81 => :down, 82 => :up }.freeze
       WASD = { 225 => :fire, 7 => :right, 4 => :left, 22 => :down, 26 => :up }.freeze
 
@@ -177,6 +212,30 @@ module Badline
         shifted.nil? ? %i[none host] : [shifted, :on]
       end
 
+      # The CBM-II key for the scancode, with the host's SHIFT down if
+      # +shift+, and how the CBM-II's SHIFT goes with it, as pet_key gives
+      # them.
+      def self.cbm2_key(scancode, shift)
+        return [LETTERS[scancode - 4], :host] if scancode.between?(4, 29)
+
+        key = CBM2_KEYS[scancode]
+        return [key, :host] unless key.nil?
+
+        characters = US_CHARACTERS[scancode]
+        return %i[none host] if characters.nil?
+
+        character = characters[shift ? 1 : 0]
+        unshifted = CBM2_CHARACTERS[character]
+        return [unshifted, :off] unless unshifted.nil?
+
+        shifted = CBM2_SHIFTED[character]
+        shifted.nil? ? %i[none host] : [shifted, :on]
+      end
+
+      # The CBM-II key Alt and the scancode press, which keeps the host's
+      # SHIFT, or :none.
+      def self.cbm2_alt_key(scancode) = [CBM2_ALT_KEYS[scancode] || :none, :host]
+
       # The character the key types on a US layout: a letter, a capital
       # with `shift`, or a digit, and "" for any other key.
       def self.character(scancode, shift)

data/lib/badline/frontend/media_slots.rb

@@ -35,7 +35,7 @@ module Badline
         # either cartridge's slots.
         def cartridge?(computer)
           return !computer.cartridge_slots.empty? if computer.family == :plus4
-          return false if computer.family == :pet
+          return false if %i[pet cbm2].include?(computer.family)
 
           !computer.address_bus.cartridge.nil?
         end

data/lib/badline/frontend/menu/menu_media.rb

@@ -50,6 +50,8 @@ module Badline
             Media.insert_disk(@computer, disk, read_only: !@writable)
             list(path)
           else
+            raise Machine::Unsupported, "the CBM-II has no datasette" if @computer.family == :cbm2
+
             @computer.datasette.insert(Storage::TAP.new(path))
           end
         end
@@ -100,17 +102,18 @@ module Badline
       end
 
       # The extensions of the cartridges the machine takes: .crt, on the
-      # Plus/4 raw .bin ROM images too, and none on the PET.
+      # Plus/4 raw .bin ROM images too, and none on the PET, or on the
+      # CBM-II, whose cartridge goes in from the command line.
       def cartridge_extensions
-        extensions = Media::Extensions.of(@computer.family == :pet ? %i[none] : %i[cartridge])
+        extensions = Media::Extensions.of(%i[pet cbm2].include?(@computer.family) ? %i[none] : %i[cartridge])
         @computer.family == :plus4 ? extensions + [Media::Plus4Media::ROM_IMAGE] : extensions
       end
 
-      # The extensions of what goes in device 8: on the PET the 8050's and
-      # 8250's disk images besides the others, and no raw GCR, which only
-      # a serial true drive reads.
+      # The extensions of what goes in device 8: on the PET and the CBM-II
+      # the 8050's and 8250's disk images besides the others, and no raw
+      # GCR, which only a serial true drive reads.
       def disk_extensions
-        return Media::Extensions.of(%i[disk ieee_disk archive disk_list]) if @computer.family == :pet
+        return Media::Extensions.of(%i[disk ieee_disk archive disk_list]) if %i[pet cbm2].include?(@computer.family)
 
         Media::Extensions::DEVICE8
       end
@@ -125,14 +128,14 @@ module Badline
 
       # What a save of the machine is named after: the cartridge, the disk,
       # the tape, or BASIC, without the bracketed parts of a file's name. A
-      # VIC-20's are named after its disk, or else the machine, and a
-      # Plus/4's or a PET's after its disk or tape.
+      # VIC-20's are named after its disk, or else the machine, a Plus/4's
+      # or a PET's after its disk or tape, and a CBM-II's after its disk.
       def game_name
         vic20 = @computer.family == :vic20
-        name = vic20 || %i[plus4 pet].include?(@computer.family) ? "" : cartridge_name
+        name = vic20 || %i[plus4 pet cbm2].include?(@computer.family) ? "" : cartridge_name
         disk = disk_path
         name = File.basename(disk, File.extname(disk)) if name.empty? && !disk.empty?
-        name = tape_name if name.empty? && !vic20
+        name = tape_name if name.empty? && !vic20 && @computer.family != :cbm2
         name = name.sub(/\s*[(\[].*\z/, "").strip
         return name unless name.empty?
 
@@ -154,7 +157,7 @@ module Badline
         case @computer.family
         when :plus4 then @computer.cartridge_slots.map { |slot| slot_name(slot) }.uniq.join(", ")
         when :vic20 then @computer.cartridge_name
-        when :pet then ""
+        when :pet, :cbm2 then ""
         else
           cartridge = @computer.address_bus.cartridge
           cartridge.nil? ? "" : cartridge.name

data/lib/badline/frontend/menu/menu_pages.rb

@@ -88,6 +88,14 @@ module Badline
       # Whether the machine is a PET, whose ports page shows its keyboard.
       def pet? = @computer.family == :pet
 
+      # Whether the machine is a CBM-II, whose ports page shows its keyboard
+      # too.
+      def cbm2? = @computer.family == :cbm2
+
+      # Whether the machine is the CBM-II's B series, whose ports page is
+      # its keyboard's alone.
+      def b_series? = cbm2? && !Controls.p500?(@computer)
+
       private
 
       def vic20? = @computer.family == :vic20
@@ -112,7 +120,10 @@ module Badline
         info("DEVICE", drive.nil? ? "FAST LOADING" : "#{drive.model_name}, TRUE DRIVE")
       end
 
+      # The CBM-II has no datasette.
       def draw_datasette
+        return info("TAPE", "") if cbm2?
+
         datasette = @computer.datasette
         tape = datasette.tape
         info("TAPE", tape.nil? ? "" : File.basename(tape.path))
@@ -126,6 +137,7 @@ module Badline
 
       def draw_expansion
         return draw_pet_memory if pet?
+        return info("RAM", "#{@computer.model.ram_kb}K") if cbm2?
 
         info("CARTRIDGE", @media.cartridge_name)
         return info("RAM EXPANSION", RAM_NAMES.fetch(@computer.ram_configuration)) if vic20?
@@ -156,10 +168,19 @@ module Badline
         toggle(plus4? ? "SID CARD" : "SID", :sid, [%w[6581 8580], %i[sid6581 sid8580], model == :mos8580 ? 1 : 0])
       end
 
-      # The PET's memory: its RAM, and the 8096's 64K board.
+      # The PET's memory: its RAM, the 8096's 64K board, and the 8296's
+      # 128K with the jumpers that put RAM under its ROMs.
       def draw_pet_memory
+        model = @computer.model
+        return draw_8296_memory if model.cbm8296?
+
         info("RAM", "#{@computer.ram_kb}K")
-        info("EXPANSION RAM", @computer.model.expansion ? "64K BOARD" : "")
+        info("EXPANSION RAM", model.expansion ? "64K BOARD" : "")
+      end
+
+      def draw_8296_memory
+        info("RAM", "128K, 64K OF IT BANKED")
+        info("JUMPERS", @computer.jumpers.join(", ").upcase)
       end
 
       # Saving now and by name, loading a named save, and the quicksaves
@@ -177,12 +198,14 @@ module Badline
         end
       end
 
-      # The C128 names its model and the mode it runs in first, the Plus/4
-      # and the PET their model and RAM, and the Plus/4 its RAM expansion if
-      # it has one.
+      # The C128 names its model and the mode it runs in first, the Plus/4,
+      # the PET and the CBM-II their model and RAM, the Plus/4 its RAM
+      # expansion if it has one, and the CBM-II its KERNAL, the B series'
+      # 901244 or the P500's 901234.
       def draw_power
         info("MACHINE", "#{@computer.model.name.upcase}, #{@computer.mode.to_s.upcase} MODE") if c128?
-        info("MACHINE", @computer.model_label) if pet?
+        info("MACHINE", @computer.model_label.upcase) if pet? || cbm2?
+        info("KERNAL", "#{Controls.p500?(@computer) ? 901_234 : 901_244}-#{@computer.kernal.upcase}") if cbm2?
         if plus4?
           info("MACHINE", @computer.model_label)
           expansion = @computer.ram_expansion_label