badline 0.16.1 → 0.18.0

data/lib/badline/frontend/app.rb

@@ -105,22 +105,37 @@ module Badline
           @controls.mouse_motion(SDL.event_xrel(SDL.event), SDL.event_yrel(SDL.event))
         when SDL::MOUSEBUTTONDOWN, SDL::MOUSEBUTTONUP
           @controls.mouse_button(SDL.event_button(SDL.event), type == SDL::MOUSEBUTTONDOWN)
+          click_panel(type == SDL::MOUSEBUTTONDOWN) if @computer.family == :kim1 && !@computer.tty?
         when SDL::CONTROLLERDEVICEADDED, SDL::CONTROLLERDEVICEREMOVED
           @gamepads.rescan
         when SDL::DROPFILE then resume(false) unless @menu.drop(@computer, @controls, @sound)
         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
 
+      # A click on the KIM-1's panel presses the key under the pointer, and
+      # its release lets go.
+      def click_panel(down)
+        event = SDL.event
+        @controls.panel_click(@screens.kim1_panel.key_at(SDL.event_x(event), SDL.event_y(event)), down)
+      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
@@ -39,8 +39,9 @@ module Badline
       ""
     rescue Machine::Unsupported, Media::TrueDrive::Error, Media::DiskList::Error, Media::NotDisk, Drives::Datasette::Missing,
            SystemCallError, SIDTune::File::FormatError, Storage::T64::FormatError, Storage::TAP::FormatError,
+           Storage::KIMTape::FormatError,
            Storage::CRTFile::FormatError, Storage::G64Image::FormatError, C64::Cartridge::UnsupportedTypeError,
-           Snapshot::FormatError => e
+           Storage::Papertape::FormatError, Snapshot::FormatError => e
       e.message
     end
 
@@ -83,7 +84,7 @@ module Badline
       options.cartridges.each { |slot, path| puts Media.attach(computer, path, cartridge: { slot: }) }
       unless media.nil?
         puts Media.attach(computer, media, autostart: options.autostart?, subtune: options.subtune,
-                                           disk: { read_only: !writable })
+                                           disk: { read_only: !writable }, kim1: Media::KIM1Media.loading(options))
       end
       computer
     end

data/lib/badline/frontend/controls.rb

@@ -8,10 +8,13 @@ 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. The KIM-1's host keys press its panel's (Keys::KIM1_KEYS),
+    #   and so does a click on one the window draws.
+    # - 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 +27,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 != :kim1 && (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
@@ -32,6 +50,8 @@ module Badline
         @mouse = Input::Mouse1351.new
         @paddles = Input::Paddles.new
         @held = {}
+        @clicked = ""
+        @shifts = 0
         @pet_keyboard = pet_keyboard(computer)
       end
 
@@ -58,9 +78,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)
@@ -100,6 +130,18 @@ module Badline
         paddles? ? @paddles.move(delta_x, delta_y) : @mouse.move(delta_x, delta_y)
       end
 
+      # Presses the KIM-1 key KIM1Panel names `name` for a click on it, or
+      # lets go of the key the last click pressed.
+      def panel_click(name, down)
+        if down
+          @clicked = name
+          kim1_key(name, true) unless name.empty?
+        else
+          kim1_key(@clicked, false) unless @clicked.empty?
+          @clicked = ""
+        end
+      end
+
       def mouse_button(button, down)
         name = MOUSE_BUTTONS[button]
         return unless name && pot_device?
@@ -116,7 +158,11 @@ 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
+        if Controls.symbolic?(@computer)
+          @pet_keyboard.positional = @computer.family == :pet && @computer.apl_characters? if down
+          return @pet_keyboard.key(scancode, down)
+        end
+        return kim1_input(scancode, down) if @computer.family == :kim1
 
         @held[scancode] = host_key(scancode) if down || !@held.key?(scancode)
         key = @held[scancode]
@@ -154,12 +200,45 @@ module Badline
         end
       end
 
+      # The keys type on the teletype with the KIM-1's jumper fitted, and
+      # press the panel's keys without it.
+      def kim1_input(scancode, down)
+        return kim1_key(Keys.kim1_key(scancode), down) unless @computer.tty?
+        return shift(down) if [225, 229].include?(scancode)
+
+        text = Keys.kim1_teletype(scancode, @shifts.positive?)
+        @computer.teletype.type(text) if down && !text.empty?
+      end
+
+      def shift(down)
+        @shifts += down ? 1 : -1
+        @shifts = 0 if @shifts.negative?
+      end
+
+      # ST pulls NMI and RS resets as they go down, and T flips the SST
+      # switch. The other keys stay down until let go.
+      def kim1_key(name, down)
+        case name
+        when "" then nil
+        when "ST" then @computer.press_stop if down
+        when "RS" then @computer.press_reset if down
+        when "SST" then @computer.sst = !@computer.sst if down
+        else
+          if down
+            @computer.press_key(name)
+          elsif @computer.panel.held == name
+            @computer.release_key
+          end
+        end
+      end
+
       def paddles? = POTS.index(@pot) >= 3
 
       # 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
+        portless = Controls.symbolic?(@computer) || @computer.family == :kim1
+        ports = Controls.p500?(@computer) || !portless ? @computer.control_ports : nil
         if ports.nil?
           @pot = :none
           return
@@ -211,17 +290,30 @@ 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, on a keyboard of its own for the KIM-1, which has
+      # none.
       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
+        keyboard = computer.family == :kim1 ? Input::Keyboard.new : computer.keyboard
+        PETKeyboard.new(keyboard, layout)
       end
 
       def release_all
-        return @pet_keyboard.release_all if @computer.family == :pet
+        return @computer.release_key if @computer.family == :kim1
+
+        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,54 @@ 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
+
+      # The KIM-1's keys, by the names KIM1::Panel::KEYS gives them, with
+      # ST, RS and the SST switch: the hex keys on the digits, the keypad's
+      # and A-F, AD on comma, DA on period, + on space, = and the keypad's
+      # +, GO on G, Return and Enter, PC on P, ST on S and Esc, RS on R and
+      # SST on T.
+      KIM1_KEYS = {
+        4 => "A", 5 => "B", 6 => "C", 7 => "D", 8 => "E", 9 => "F", 30 => "1", 31 => "2", 32 => "3", 33 => "4",
+        34 => "5", 35 => "6", 36 => "7", 37 => "8", 38 => "9", 39 => "0", 89 => "1", 90 => "2", 91 => "3",
+        92 => "4", 93 => "5", 94 => "6", 95 => "7", 96 => "8", 97 => "9", 98 => "0", 54 => "AD", 55 => "DA",
+        44 => "+", 46 => "+", 87 => "+", 10 => "GO", 40 => "GO", 88 => "GO", 19 => "PC", 22 => "ST", 41 => "ST",
+        21 => "RS", 23 => "SST"
+      }.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 +225,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)
@@ -190,6 +262,29 @@ module Badline
         end
       end
 
+      # What the KIM-1's teletype sends for the keys that type no
+      # character: RETURN, RUBOUT on Backspace and Delete, and LINE FEED on
+      # Down.
+      KIM1_TELETYPE_KEYS = { 40 => "\r", 88 => "\r", 42 => "\x7f", 76 => "\x7f", 81 => "\n" }.freeze
+
+      # What the KIM-1's teletype sends for the scancode, with the host's
+      # SHIFT down if `shift`: a key of KIM1_TELETYPE_KEYS, or the
+      # character the key types on a US layout, or an empty string.
+      def self.kim1_teletype(scancode, shift)
+        sent = KIM1_TELETYPE_KEYS[scancode]
+        return sent unless sent.nil?
+        return " " if scancode == SPACE
+        return character(scancode, shift) if scancode.between?(4, 29)
+
+        characters = US_CHARACTERS[scancode]
+        return "" if characters.nil?
+
+        characters[shift ? 1 : 0]
+      end
+
+      # The KIM-1 key for the scancode, or an empty string.
+      def self.kim1_key(scancode) = KIM1_KEYS[scancode] || ""
+
       def self.arrows(scancode) = ARROWS[scancode] || :none
 
       def self.wasd(scancode) = WASD[scancode] || :none

data/lib/badline/frontend/kim1_panel.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The KIM-1's panel as the window shows it, in place of a video chip's
+    # picture: the six LED digits, the keypad laid out as the board's
+    # (User Manual, figure 3.6), the SST switch, and the host keys that
+    # press each. It answers what a Screen reads of a video chip: a palette
+    # index a pixel, the lines changed, and the palette.
+    #
+    # Each frame #follow takes the cycles each segment was lit
+    # (KIM1::Panel#lit_cycles). A segment lit FULL_DUTY of the time, as
+    # the monitor lights each digit, shows at full brightness, and one lit
+    # less dimmer, through a square root, as the eye sees it. The level
+    # follows over SMOOTHING_CYCLES, the eye's persistence, so the frames'
+    # beat against the program's scan doesn't flicker.
+    class KIM1Panel
+      WIDTH = 384
+      HEIGHT = 272
+
+      BOARD = 0
+      LED = 1
+      LED_LEVELS = 16
+      WINDOW = 17
+      KEY = 18
+      KEY_HELD = 19
+      KEY_TEXT = 20
+      HINT = 21
+      TITLE = 22
+      SWITCH_ON = 23
+
+      # The board's green, the LED segments from unlit to full, the black
+      # behind them, the keys, and the text.
+      PALETTE = ([0x123c22] + Array.new(LED_LEVELS) do |level|
+        red = 0x2c + (((0xff - 0x2c) * level) / (LED_LEVELS - 1))
+        rest = 0x08 + ((0x28 * level) / (LED_LEVELS - 1))
+        (red << 16) | (rest << 8) | rest
+      end + [0x000000, 0xe8e0c8, 0x8c8470, 0x101010, 0xa8c8b0, 0xffffff, 0xffd040] +
+                 Array.new(8, 0)).freeze
+
+      FULL_DUTY = 0.15
+      SMOOTHING_CYCLES = 40_000.0
+
+      # Where the digits go: the left edge of each, and their top.
+      DIGIT_LEFT = [56, 100, 144, 188, 252, 296].freeze
+      DIGIT_TOP = 30
+      THICKNESS = 4
+      LENGTH = 20
+
+      # Each segment's place in a digit, a to g: left, top, width, height.
+      SEGMENTS = [
+        [THICKNESS, 0, LENGTH, THICKNESS],
+        [THICKNESS + LENGTH, THICKNESS, THICKNESS, LENGTH],
+        [THICKNESS + LENGTH, (2 * THICKNESS) + LENGTH, THICKNESS, LENGTH],
+        [THICKNESS, (2 * THICKNESS) + (2 * LENGTH), LENGTH, THICKNESS],
+        [0, (2 * THICKNESS) + LENGTH, THICKNESS, LENGTH],
+        [0, THICKNESS, THICKNESS, LENGTH],
+        [THICKNESS, THICKNESS + LENGTH, LENGTH, THICKNESS]
+      ].freeze
+
+      # The keypad, top row first, as on the board, with the SST switch at
+      # the end of the first row.
+      KEYPAD = [%w[GO ST RS SST], %w[AD DA PC +], %w[C D E F], %w[8 9 A B], %w[4 5 6 7], %w[0 1 2 3]].freeze
+      KEYPAD_LEFT = 24
+      KEYPAD_TOP = 100
+      KEY_WIDTH = 40
+      KEY_HEIGHT = 22
+      KEY_GAP = 6
+
+      # The host keys that press the panel's.
+      HINTS = ["0-9, A-F: HEX", "COMMA: AD", "PERIOD: DA", "SPACE, +: +", "G, RETURN: GO", "P: PC",
+               "S, ESC: ST", "R: RS", "T: SST", "CLICK: KEY", "F9: MENU"].freeze
+      HINT_LEFT = 216
+      HINT_TOP = 104
+      HINT_LINE = 13
+
+      attr_reader :display, :dirty_lines
+
+      def initialize
+        @display = Array.new(WIDTH * HEIGHT, BOARD)
+        @dirty_lines = Array.new(HEIGHT, true)
+        @font = ROM.read("character.rom")
+        @brightness = Array.new(KIM1::Panel::DIGITS * 7, 0.0)
+        @levels = Array.new(KIM1::Panel::DIGITS * 7, -1)
+        @held = ""
+        @sst = false
+        @cycles = 0
+        draw_board
+      end
+
+      def width = WIDTH
+
+      def height = HEIGHT
+
+      def palette = PALETTE
+
+      # The whole picture: the window has nothing to crop.
+      def crop = [0, 0, WIDTH, HEIGHT]
+
+      def clear_dirty_lines!
+        @dirty_lines.map! { false }
+      end
+
+      # Brings the picture up to the KIM-1 `computer`: the digits from the
+      # segments' lit cycles since the last frame, and the key held and
+      # the SST switch.
+      def follow(computer)
+        cycles = computer.cycles
+        elapsed = cycles - @cycles
+        @cycles = cycles
+        lit = computer.panel.lit_cycles
+        light(lit, elapsed) if elapsed.positive?
+        held = computer.panel.held.to_s
+        draw_keys(held, computer.sst) if held != @held || computer.sst != @sst
+      end
+
+      # The name of the panel's key at the window pixel `left`, `top`, as
+      # KIM1::Panel::KEYS names it, ST, RS or SST, or an empty string.
+      def key_at(left, top)
+        across = left - KEYPAD_LEFT
+        down = top - KEYPAD_TOP
+        column = across / (KEY_WIDTH + KEY_GAP)
+        row = down / (KEY_HEIGHT + KEY_GAP)
+        return "" if across.negative? || down.negative? || column > 3 || row >= KEYPAD.size
+        return "" if across % (KEY_WIDTH + KEY_GAP) >= KEY_WIDTH || down % (KEY_HEIGHT + KEY_GAP) >= KEY_HEIGHT
+
+        KEYPAD[row][column]
+      end
+
+      # The brightness, 0 to 1, of each segment, seven to a digit.
+      def brightness = @brightness.dup
+
+      private
+
+      def light(lit, elapsed)
+        smoothing = 1.0 - Math.exp(-elapsed / SMOOTHING_CYCLES)
+        lit.each_with_index do |cycles, index|
+          duty = cycles.fdiv(elapsed) / FULL_DUTY
+          target = Math.sqrt([duty, 1.0].min)
+          level = @brightness[index] + (smoothing * (target - @brightness[index]))
+          @brightness[index] = level
+          shade = (level * (LED_LEVELS - 1)).round
+          next if shade == @levels[index]
+
+          @levels[index] = shade
+          draw_segment(index / 7, index % 7, LED + shade)
+        end
+      end
+
+      def draw_board
+        text(16, 8, "MOS KIM-1", TITLE)
+        box(40, 22, 304, 64, WINDOW)
+        DIGIT_LEFT.each_index { |digit| 7.times { |segment| draw_segment(digit, segment, LED) } }
+        @levels.map! { 0 }
+        HINTS.each_with_index { |hint, line| text(HINT_LEFT, HINT_TOP + (line * HINT_LINE), hint, HINT) }
+        draw_keys("", false)
+      end
+
+      def draw_segment(digit, segment, color)
+        place = SEGMENTS[segment]
+        box(DIGIT_LEFT[digit] + place[0], DIGIT_TOP + place[1], place[2], place[3], color)
+      end
+
+      def draw_keys(held, sst)
+        @held = held
+        @sst = sst
+        KEYPAD.each_with_index do |names, row|
+          names.each_with_index do |name, column|
+            on = name == "SST" ? sst : name == held
+            draw_key(KEYPAD_LEFT + (column * (KEY_WIDTH + KEY_GAP)), KEYPAD_TOP + (row * (KEY_HEIGHT + KEY_GAP)),
+                     name, on)
+          end
+        end
+      end
+
+      def draw_key(left, top, name, on)
+        face = on ? KEY_HELD : KEY
+        face = on ? SWITCH_ON : KEY if name == "SST"
+        box(left, top, KEY_WIDTH, KEY_HEIGHT, face)
+        text(left + ((KEY_WIDTH - (name.size * 8)) / 2), top + ((KEY_HEIGHT - 8) / 2), name, KEY_TEXT)
+      end
+
+      def box(left, top, width, height, color)
+        height.times do |row|
+          line = top + row
+          @display.fill(color, (line * WIDTH) + left, width)
+          @dirty_lines[line] = true
+        end
+      end
+
+      # Draws `string` from `left`, `top` in the character ROM's second set.
+      def text(left, top, string, color)
+        string.bytes.each_with_index do |byte, index|
+          glyph(left + (index * 8), top, Painter::SCREEN_CODES[byte & 0x7f], color)
+        end
+      end
+
+      def glyph(left, top, code, color)
+        8.times do |row|
+          bits = @font[0x800 + (code * 8) + row]
+          line = top + row
+          8.times { |dot| @display[(line * WIDTH) + left + dot] = color if bits.anybits?(0x80 >> dot) }
+          @dirty_lines[line] = true
+        end
+      end
+    end
+  end
+end

data/lib/badline/frontend/media_slots.rb

@@ -26,6 +26,13 @@ module Badline
           path.empty? ? path : File.expand_path(path)
         end
 
+        # The model of the true drive on device 8, or an empty one for the
+        # traps.
+        def drive_model(computer)
+          drive = Media::TrueDrive.drive(computer)
+          drive.nil? ? "" : drive.model_name
+        end
+
         def eject_disk(computer)
           drive = Media::TrueDrive.drive(computer)
           drive.nil? ? computer.unmount : drive.insert(nil)
@@ -35,7 +42,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 kim1].include?(computer.family)
 
           !computer.address_bus.cartridge.nil?
         end