badline 0.15.1 → 0.16.1

data/lib/badline/drives/model2031/ieee_port.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model2031
+      # VIA 1's side of the IEEE-488 bus (Drives::IEEEBus), through a 75160
+      # for the data lines and a 75161 for the control lines (schematic
+      # 2031038, sheet 2):
+      #
+      #   PA0-7  DIO1-8                   PB4  T/R, high to talk
+      #   PB0    ATN acknowledge (ATNA)   PB5  HD SEL, unused
+      #   PB1    NRFD                     PB6  DAV
+      #   PB2    NDAC                     PB7  ATN in, high while ATN is low
+      #   PB3    EOI                      CA1  ATN in, as PB7
+      #
+      # The ports read and drive the lines' levels, 0 for a low line. T/R
+      # turns the transceivers: talking, the drive drives the data lines,
+      # DAV and EOI, and reads NRFD and NDAC; listening, the other way round.
+      # EOI turns back to the bus while ATN is low. A pin the transceiver
+      # drives the bus from reads the drive's own side, high but for what
+      # the VIA or a jumper pulls low.
+      #
+      # An XOR of ATN in and ATNA drives two 7406s that pull NRFD and NDAC
+      # low on the bus, so the drive answers ATN before the DOS gets to it,
+      # and holds the bus until the DOS acknowledges. ATNA reaches the XOR
+      # only while PB0 is an output, and is low there otherwise, which
+      # leaves the bus alone while the DOS reads the jumpers.
+      #
+      # The device number jumpers are diodes from PB0 and PB1 to CA2: with
+      # CA2 low, a fitted diode pulls its line low, and the DOS reads the
+      # device number off the two at reset, 8 with both fitted. Lifting the
+      # one on PB0 adds 1, and the one on PB1 2.
+      #
+      # The drive takes the controller's lines a host cycle late, as the
+      # serial drives do (Engine::SerialLines): latch_host takes them at the
+      # end of each host cycle.
+      class IEEEPort
+        ATNA = 0x01
+        NRFD = 0x02
+        NDAC = 0x04
+        EOI = 0x08
+        TALK = 0x10
+        DAV = 0x40
+        ATN_IN = 0x80
+
+        attr_reader :bus
+
+        # The lines the controller pulled, as latch_host took them.
+        attr_reader :host
+
+        def initialize(device:, bus:)
+          raise ArgumentError, "a 2031 is device 8 to 11, not #{device}" unless device.between?(8, 11)
+
+          @diodes = ~(device - 8) & 0x03
+          @via = nil
+          @host = 0
+          self.bus = bus
+        end
+
+        # The drive's VIA 1, whose outputs it drives the bus with.
+        attr_writer :via
+
+        def bus=(bus)
+          @bus = bus
+          latch_host
+        end
+
+        # Takes the controller's lines for the drive cycles of the next host
+        # cycle.
+        def latch_host
+          @host = @bus.host_lines
+        end
+
+        # Whether the controller has moved ATN since the last latch_host.
+        def atn_moved? = (@bus.host_lines ^ @host).anybits?(IEEEBus::ATN)
+
+        def atn_low? = @host.anybits?(IEEEBus::ATN)
+
+        # The data lines, while the transceiver listens.
+        def read_a(_lines) = talking? ? 0xff : ~@bus.low_lines(@host) & 0xff
+
+        # The control lines the transceiver turns towards the drive, and
+        # ATN.
+        def read_b(_lines)
+          low = @bus.low_lines(@host)
+          value = 0x7f
+          if talking?
+            value &= ~NRFD if low.anybits?(IEEEBus::NRFD)
+            value &= ~NDAC if low.anybits?(IEEEBus::NDAC)
+            value &= ~EOI if low.anybits?(IEEEBus::EOI) && low.anybits?(IEEEBus::ATN)
+          else
+            value &= ~EOI if low.anybits?(IEEEBus::EOI)
+            value &= ~DAV if low.anybits?(IEEEBus::DAV)
+          end
+          value |= ATN_IN if low.anybits?(IEEEBus::ATN)
+          value & jumpers
+        end
+
+        # The lines the drive pulls low while ATN is low or not, as bus bits.
+        def ieee_low_lines(atn)
+          via = @via
+          lines = via.port_b_output & jumpers
+          low = 0
+          if lines.anybits?(TALK)
+            low |= ~via.port_a_output & IEEEBus::DIO
+            low |= IEEEBus::DAV if lines.nobits?(DAV)
+            low |= IEEEBus::EOI if lines.nobits?(EOI) && !atn
+          else
+            low |= IEEEBus::NRFD if lines.nobits?(NRFD)
+            low |= IEEEBus::NDAC if lines.nobits?(NDAC)
+          end
+          low |= IEEEBus::NRFD | IEEEBus::NDAC if atn != (lines & via.port_b_directions).anybits?(ATNA)
+          low
+        end
+
+        # The controller's lines as the port latched them, under `prefix`.
+        def save_fields(out, prefix) = out.int("#{prefix}host", @host)
+
+        def load_fields(input, prefix)
+          @host = input.int("#{prefix}host", @host)
+        end
+
+        private
+
+        def talking? = @via.port_b_output.anybits?(TALK)
+
+        # PB0 and PB1 as the jumper diodes leave them: pulled low through
+        # each fitted one while CA2 is low.
+        def jumpers = @via.ca2_output ? 0xff : ~@diodes & 0xff
+      end
+    end
+  end
+end

data/lib/badline/drives/model2031/keyed_state.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model2031
+      # The drive's own fields in a keyed snapshot module (BL-D8): its
+      # model, its clock phase and cycle count, the SO pulse due, and the
+      # controller's lines as the IEEE-488 port latched them under ieee.*. A
+      # save settles the drive first, so it is awake; a load forgets its
+      # orbits.
+      module KeyedState
+        def save_fields(out)
+          settle!
+          out.text("model", model_name).int("phase", @phase).int("cycles", @cycles)
+          out.bool("so_pending", @mechanism.so_pending)
+          @serial_port.save_fields(out, "ieee.")
+          out
+        end
+
+        def load_fields(input)
+          settle!
+          input.choice("model", [model_name], model_name)
+          @phase = input.int("phase", @phase)
+          @cycles = input.int("cycles", @cycles)
+          @mechanism.so_pending = input.bool("so_pending", @mechanism.so_pending)
+          @serial_port.load_fields(input, "ieee.")
+        end
+
+        # The drive as modules of its own, named from `name` (BL-D8 for
+        # device 8): its own fields, its RAM, each VIA, the CPU, the
+        # mechanism and the disk, when one is in, as the 1541's.
+        def save_modules(sections, name)
+          sections << Snapshot::Keyed.section(name) { |out| save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-RAM") { |out| @bus.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-VIA1") { |out| @via1.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-VIA2") { |out| @via2.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-CPU") { |out| @cpu.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-MECH") { |out| @mechanism.save_fields(out) }
+          disk = @mechanism.disk
+          sections << Snapshot::Keyed.section("#{name}-DISK") { |out| disk.save_fields(out) } if disk
+          sections
+        end
+
+        # The drive from its modules, `input` being its own. No disk module
+        # means no disk in the drive.
+        def load_modules(modules, input, name)
+          load_fields(input)
+          @bus.load_fields(modules.required("#{name}-RAM"))
+          @via1.load_fields(modules.required("#{name}-VIA1"))
+          @via2.load_fields(modules.required("#{name}-VIA2"))
+          @cpu.load_fields(modules.required("#{name}-CPU"))
+          disk = modules.optional("#{name}-DISK")
+          mechanism = modules.required("#{name}-MECH")
+          @mechanism.load_fields(mechanism,
+                                 disk.nil? ? nil : Model1541::Disk.from_fields(disk, detached: modules.detached?))
+          @via1.restored!
+          @via2.restored!
+          @cpu.restored!
+          forget_orbits
+        end
+      end
+
+      include KeyedState
+    end
+  end
+end

data/lib/badline/drives/model2031/parts.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model2031
+      # VIA 1, facing the IEEE-488 bus (IEEEPort), a class of its own so
+      # its peripheral keeps one type, apart from the serial drives'.
+      class IEEEVIA < Chips::VIA
+        # DDRB, whose PB0 says whether the VIA drives ATNA (IEEEPort).
+        def port_b_directions = @ddrb
+      end
+
+      # The drive CPU's bus, decoded as the 1541's (Model1541::Bus), with
+      # VIA 1 an IEEEVIA.
+      class Bus < Model1541::Bus
+      end
+
+      # The drive's 6502, on the drive's Bus.
+      class CPU
+        include Badline::Chips::CPU::Core
+        include Engine::IdleCPU
+      end
+    end
+  end
+end

data/lib/badline/drives/model2031.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "badline/drives/model1541"
+require "badline/drives/ieee_bus"
+require "badline/drives/model2031/parts"
+require "badline/drives/model2031/ieee_port"
+require "badline/drives/model2031/keyed_state"
+
+module Badline
+  module Drives
+    # The 2031 disk drive of the PET and CBM: the 1541's board with an
+    # IEEE-488 interface in place of the serial one (Commodore schematic
+    # 2031038). A 6502 at 1 MHz runs DOS 2.6 from 16 KB of ROM, with 2 KB
+    # of RAM, VIA 1 at $1800 on the IEEE-488 bus (IEEEPort) and VIA 2 at
+    # $1C00 running the 1541's GCR Mechanism, decoded as the 1541's.
+    #
+    # Drives::Engine::Core clocks it against the host and sleeps through
+    # the DOS's idle loop, as the 1541's, until ATN moves or a timer is due
+    # (Engine::VIAs). The bus reads the lines it pulls without waking it.
+    class Model2031
+      include Engine::Core
+      include Engine::VIAs
+
+      CLOCK_HZ = 1_000_000
+
+      # Where the DOS's idle loop starts over (see Drives::Engine::Idle).
+      IDLE_LOOP = 0xec4d
+
+      # The host cycles by which a 2031 switched on with the machine has run
+      # its DOS's RAM test and ROM checksums and reads its jumpers.
+      BOOT_CYCLES = 1_300_000
+
+      attr_reader :ieee_bus
+
+      def model_name = "2031"
+
+      # +rom+ covers $C000-$FFFF, and defaults to the DOS image in the ROM
+      # path. +device+ is the number the jumpers set, 8 to 11.
+      def initialize(rom: nil, host_clock_hz: CLOCK_HZ, device: 8, debug: false)
+        @device = device
+        @ieee_bus = IEEEBus.new
+        @serial_port = IEEEPort.new(device:, bus: @ieee_bus)
+        @via1 = IEEEVIA.new(start: 0x1800, peripheral: @serial_port)
+        @serial_port.via = @via1
+        @mechanism = Model1541::Mechanism.new
+        @via2 = Model1541::DiskVIA.new(start: 0x1c00, mechanism: @mechanism)
+        @bus = Bus.new(rom: rom || ROM.load("dos2031.rom", 0xc000), via1: @via1, via2: @via2)
+        @cpu = CPU.new(@bus, debug:)
+        @clock_hz = CLOCK_HZ
+        @idle_loop = IDLE_LOOP
+        @host_clock_hz = host_clock_hz
+        @phase = 0
+        @cycles = 0
+        init_idle(debug)
+        @via1.ca1 = false
+        @via1.reset!
+        connect(@ieee_bus)
+      end
+
+      # Plugs the drive into an IEEE-488 bus, leaving the one it was on.
+      def connect(ieee_bus)
+        settle!
+        @ieee_bus.detach(self)
+        @ieee_bus = ieee_bus
+        @serial_port.bus = ieee_bus
+        ieee_bus.attach(self)
+        hear_atn
+      end
+
+      # The lines the drive pulls on the bus while ATN is low or not
+      # (IEEEPort). They hold still while it sleeps, so reading them leaves
+      # it asleep.
+      def ieee_low_lines(atn) = @serial_port.ieee_low_lines(atn)
+
+      private
+
+      # One drive cycle, as the 1541's (Model1541#step): the mechanism, then
+      # ATN on VIA 1's CA1, the VIAs and the CPU.
+      def step
+        so = @mechanism.take_so
+        @mechanism.cycle!
+        @via1.ca1 = @serial_port.atn_low?
+        @via1.cycle!
+        @via2.cycle!
+        @cpu.irq = @via1.irq? || @via2.irq?
+        @cpu.so! if so
+        @cpu.cycle!
+        @cycles += 1
+      end
+    end
+  end
+end

data/lib/badline/drives.rb

@@ -4,5 +4,6 @@
 # 1571 stays out of the core: badline/c128 requires it.
 require "badline/drives/datasette"
 require "badline/drives/serial_bus"
+require "badline/drives/ieee_bus"
 require "badline/drives/model1541"
 require "badline/drives/model1581"

data/lib/badline/frontend/app.rb

@@ -112,7 +112,7 @@ module Badline
       end
 
       def handle_key(scancode, down)
-        if [Keys::TAB, Keys::F8, Keys::F9, Keys::F10].include?(scancode)
+        if [Keys::F8, Keys::F9, Keys::F10].include?(scancode) || (scancode == Keys::TAB && @controls.tab_toggles?)
           handle_toggle(scancode) if down
         elsif down && @snapshots.key(scancode)
           swap(@snapshots.computer)

data/lib/badline/frontend/controls.rb

@@ -7,7 +7,9 @@ module Badline
     # - The keys: every host key goes to the machine's keyboard, or, as Tab
     #   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.
+    #   #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
     #   turns the paddles or moves the mouse, and the host's left and right
@@ -30,6 +32,7 @@ module Badline
         @mouse = Input::Mouse1351.new
         @paddles = Input::Paddles.new
         @held = {}
+        @pet_keyboard = pet_keyboard(computer)
       end
 
       # Routes the input to another machine, the pot device going into its
@@ -37,6 +40,7 @@ module Badline
       def computer=(computer)
         release_all
         @computer = computer
+        @pet_keyboard = pet_keyboard(computer)
         attach_pot_device
       end
 
@@ -48,10 +52,16 @@ module Badline
         release_all
       end
 
+      # Switches between the keyboard and the joysticks, on a machine with
+      # joysticks.
       def toggle_keys
-        self.joystick_mode = !@joystick
+        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
+
       # Plugs in one of POTS, in place of the one before.
       def plug(pot)
         @pot = pot
@@ -106,6 +116,8 @@ 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
+
         @held[scancode] = host_key(scancode) if down || !@held.key?(scancode)
         key = @held[scancode]
         @held.delete(scancode) unless down
@@ -147,7 +159,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.control_ports
+        ports = @computer.family == :pet ? nil : @computer.control_ports
         if ports.nil?
           @pot = :none
           return
@@ -199,7 +211,15 @@ 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.
+      def pet_keyboard(computer)
+        PETKeyboard.new(computer.keyboard, computer.family == :pet ? computer.model.keyboard : :graphics)
+      end
+
       def release_all
+        return @pet_keyboard.release_all if @computer.family == :pet
+
         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|

data/lib/badline/frontend/gamepads.rb

@@ -7,14 +7,15 @@ 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.
+    # reports one added or removed. The PET has no joysticks, and the
+    # controllers steer two that nothing reads.
     class Gamepads
       PORTS = [2, 1].freeze
 
       def initialize(computer, verbose)
         @verbose = verbose
         @controllers = []
-        @ports = [PadPort.new(computer.joystick2), PadPort.new(computer.joystick1)]
+        @ports = [PadPort.new(joystick(computer, 2)), PadPort.new(joystick(computer, 1))]
         @buttons = Array.new(PadPort::BUTTON_COUNT, 0)
         @available = SDL.SDL_InitSubSystem(SDL::INIT_GAMECONTROLLER).zero?
         puts "No game controllers: #{SDL.SDL_GetError}" if @verbose && !@available
@@ -24,7 +25,7 @@ module Badline
       # what they hold on the next poll.
       def computer=(computer)
         @ports.each(&:release)
-        @ports = [PadPort.new(computer.joystick2), PadPort.new(computer.joystick1)]
+        @ports = [PadPort.new(joystick(computer, 2)), PadPort.new(joystick(computer, 1))]
       end
 
       def rescan
@@ -51,6 +52,12 @@ module Badline
 
       private
 
+      def joystick(computer, port)
+        return Input::Joystick.new if computer.family == :pet
+
+        port == 1 ? computer.joystick1 : computer.joystick2
+      end
+
       def open_controller(index)
         controller = SDL.SDL_GameControllerOpen(index)
         # SDL returns NULL when the controller won't open, which Spinel's FFI

data/lib/badline/frontend/keys.rb

@@ -65,6 +65,59 @@ module Badline
         79 => :crsr_right, 80 => :crsr_left, 81 => :crsr_down, 82 => :crsr_up, 229 => :lshift, 75 => :none
       }.freeze
 
+      # The characters the keys other than the letters type on a US
+      # layout, unshifted and then shifted, and the keypad's.
+      US_CHARACTERS = {
+        30 => "1!", 31 => "2@", 32 => "3#", 33 => "4$", 34 => "5%", 35 => "6^", 36 => "7&", 37 => "8*", 38 => "9(",
+        39 => "0)", 45 => "-_", 46 => "=+", 47 => "[{", 48 => "]}", 49 => "\\|", 51 => ";:", 52 => "'\"", 53 => "`~",
+        54 => ",<", 55 => ".>", 56 => "/?", 84 => "//", 85 => "**", 86 => "--", 87 => "++", 89 => "11", 90 => "22",
+        91 => "33", 92 => "44", 93 => "55", 94 => "66", 95 => "77", 96 => "88", 97 => "99", 98 => "00", 99 => "..",
+        103 => "=="
+      }.freeze
+
+      # The PET's keys for the characters a host key types, on either
+      # keyboard without SHIFT: each has a key of its own on the graphics
+      # keyboard, where SHIFT turns it into a graphics character. ↑ and ←
+      # are on ^, and on _ and `.
+      PET_GRAPHICS_CHARACTERS = {
+        "!" => :!, "\"" => :'"', "#" => :"#", "$" => :"$", "%" => :%, "&" => :&, "'" => :"'", "(" => :"(",
+        ")" => :")", "\\" => :"\\", "^" => :up, "_" => :left, "`" => :left, "/" => :/, ":" => :":", "*" => :*,
+        ";" => :";", "?" => :"?", "," => :",", "+" => :+, "@" => :"@", "[" => :"[", "]" => :"]", "<" => :<,
+        ">" => :>, "-" => :-, "=" => :"=", "." => :".", "1" => :"1", "2" => :"2", "3" => :"3", "4" => :"4",
+        "5" => :"5", "6" => :"6", "7" => :"7", "8" => :"8", "9" => :"9", "0" => :"0"
+      }.freeze
+
+      # The business keyboard's: the characters it types without SHIFT,
+      # then those it types with it.
+      PET_BUSINESS_CHARACTERS = {
+        "1" => :"1", "2" => :"2", "3" => :"3", "4" => :"4", "5" => :"5", "6" => :"6", "7" => :"7", "8" => :"8",
+        "9" => :"9", "0" => :"0", "-" => :-, ":" => :":", ";" => :";", "," => :",", "." => :".", "/" => :/,
+        "@" => :"@", "[" => :"[", "]" => :"]", "\\" => :"\\", "^" => :up, "_" => :left, "`" => :left
+      }.freeze
+
+      PET_BUSINESS_SHIFTED = {
+        "!" => :"1", "\"" => :"2", "#" => :"3", "$" => :"4", "%" => :"5", "&" => :"6", "'" => :"7", "(" => :"8",
+        ")" => :"9", "=" => :-, "*" => :":", "+" => :";", "<" => :",", ">" => :".", "?" => :/
+      }.freeze
+
+      # The PET's keys that don't type a character, which keep the host's
+      # SHIFT: RETURN, INST/DEL on Backspace, CLR/HOME on Home, RUN/STOP on
+      # Page Down, and RVS on Control. Esc is RUN/STOP on the graphics
+      # keyboard. The business keyboard's ESC, TAB, REPEAT and keypad are
+      # on Esc, Tab, Page Up and the keypad.
+      PET_KEYS = {
+        40 => :return, 88 => :return, 42 => :delete, 44 => :space, 74 => :clr_home, 78 => :run_stop, 224 => :rvs,
+        228 => :rvs
+      }.freeze
+
+      PET_BUSINESS_KEYS = {
+        41 => :escape, 43 => :tab, 75 => :repeat, 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 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
+
       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
 
@@ -89,6 +142,41 @@ module Badline
       # The 264's key for the scancode: one of PLUS4_OTHERS or the C64's.
       def self.plus4_key(scancode) = PLUS4_OTHERS[scancode] || c64_key(scancode)
 
+      # The PET key for the scancode on the +keyboard+, :graphics or
+      # :business, with the host's SHIFT down if +shift+, and how the
+      # PET's SHIFT goes with it: :on or :off for a key that types the host
+      # key's character or moves the cursor its way only so, and :host to
+      # follow the host's. A letter is the PET's letter, and any other key
+      # the PET key that types the same character, or :none.
+      def self.pet_key(scancode, shift, keyboard)
+        return [LETTERS[scancode - 4], :host] if scancode.between?(4, 29)
+
+        cursor = PET_CURSORS[scancode]
+        return [cursor, [LEFT, UP].include?(scancode) ? :on : :off] unless cursor.nil?
+
+        business = keyboard == :business
+        key = business ? PET_BUSINESS_KEYS[scancode] : nil
+        key = PET_KEYS[scancode] if key.nil?
+        key = :run_stop if key.nil? && scancode == ESCAPE
+        return [key, :host] unless key.nil?
+
+        pet_character(scancode, shift, business)
+      end
+
+      # The PET key that types the character the scancode types on a US
+      # layout, and the SHIFT it takes.
+      def self.pet_character(scancode, shift, business)
+        characters = US_CHARACTERS[scancode]
+        return %i[none host] if characters.nil?
+
+        character = characters[shift ? 1 : 0]
+        unshifted = business ? PET_BUSINESS_CHARACTERS[character] : PET_GRAPHICS_CHARACTERS[character]
+        return [unshifted, :off] unless unshifted.nil?
+
+        shifted = business ? PET_BUSINESS_SHIFTED[character] : nil
+        shifted.nil? ? %i[none host] : [shifted, :on]
+      end
+
       # 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,6 +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
 
           !computer.address_bus.cartridge.nil?
         end

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

@@ -39,6 +39,7 @@ module Badline
         @browsing = kind
         extensions = case kind
                      when :cartridge then @media.cartridge_extensions
+                     when :disk then @media.disk_extensions
                      when :program then programs
                      else EXTENSIONS.fetch(kind)
                      end
@@ -64,7 +65,7 @@ module Badline
       # starts, and says whether it asks. Other files are left alone.
       def drop(path)
         extension = File.extname(path).downcase
-        return @media.insert(:disk, path) && false if EXTENSIONS[:disk].include?(extension)
+        return @media.insert(:disk, path) && false if @media.disk_extensions.include?(extension)
         return @media.insert(:tape, path) && false if EXTENSIONS[:tape].include?(extension)
         return false unless programs.include?(extension)