badline 0.17.0 → 0.18.0

data/lib/badline/frontend/keys.rb

@@ -153,6 +153,19 @@ module Badline
         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
 
@@ -249,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 %i[pet cbm2].include?(computer.family)
+          return false if %i[pet cbm2 kim1].include?(computer.family)
 
           !computer.address_bus.cartridge.nil?
         end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The pause menu's list of the true drives a PET or a CBM-II takes on
+    # device 8, which the DRIVE 8 page's DRIVE TYPE row brings up: a row
+    # for each model, the disks it reads at its right, and the one on the
+    # bus said so. Up and Down move along the list, Return or a click picks
+    # a model, and Left or Esc goes back to the page.
+    class DriveTypes
+      MODELS = %w[2031 2040 3040 4040 1001 8050 8250 9060 9090].freeze
+      ACTIONS = %i[type2031 type2040 type3040 type4040 type1001 type8050 type8250 type9060 type9090].freeze
+
+      def initialize(painter, buttons)
+        @painter = painter
+        @buttons = buttons
+        @open = false
+        @model = ""
+      end
+
+      def open? = @open
+
+      # Opens the list with the focus on `model`, the drive on the bus, or
+      # on the first if there's none.
+      def open(model)
+        @model = model
+        @open = true
+        index = MODELS.index(model)
+        @buttons.focus = ACTIONS[index.nil? ? 0 : index]
+      end
+
+      def close
+        @open = false
+      end
+
+      # The model `action` picks, or nil.
+      def model_for(action)
+        index = ACTIONS.index(action)
+        index.nil? ? nil : MODELS[index]
+      end
+
+      # Draws the list `width` wide.
+      def draw(left, top, width)
+        @painter.text(left, top, "DRIVE 8 TYPE", MenuTheme::BRIGHT)
+        top += 20
+        MODELS.each_with_index do |model, index|
+          media = Drives::IEEEModels::MEDIA.fetch(model).join(" ").upcase
+          label = model == @model ? "#{model}, ON THE BUS" : model
+          @buttons.row([left, top, width], label, ACTIONS[index], media)
+          top += Buttons::HEIGHT + 2
+        end
+        @painter.text(left, top + 6, "RETURN: PICK  LEFT, ESC: BACK", MenuTheme::DIM)
+      end
+    end
+  end
+end

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

@@ -4,12 +4,14 @@ module Badline
   module Frontend
     # The pause menu's screens that take over its panel: the file browser
     # INSERT, Quick open and LOAD bring up, the question before a cartridge
-    # or Quick open power cycles the machine, and the prompt for a save's
-    # name. A disk or tape picked goes straight in, and a save loads.
+    # or Quick open power cycles the machine, the prompt for a save's name,
+    # and the list of a PET's or a CBM-II's drive types. A disk or tape
+    # picked goes straight in, a save loads, and a drive type picked goes on
+    # the bus.
     class MenuDialogs
       EXTENSIONS = {
-        disk: Media::Extensions::DEVICE8, tape: Media::Extensions.of(%i[tape]),
-        cartridge: Media::Extensions.of(%i[cartridge]), program: Media::Extensions::ALL, snapshot: %w[.vsf]
+        disk: Media::Extensions::DEVICE8, cartridge: Media::Extensions.of(%i[cartridge]),
+        program: Media::Extensions::ALL, snapshot: %w[.vsf]
       }.freeze
       TITLES = { disk: "INSERT A DISK", tape: "INSERT A TAPE", cartridge: "INSERT A CARTRIDGE",
                  program: "QUICK OPEN", snapshot: "LOAD A SAVE" }.freeze
@@ -25,13 +27,14 @@ module Badline
         @browser = FileBrowser.new(painter, buttons)
         @confirmation = Confirmation.new(painter, buttons)
         @name_field = NameField.new(painter)
+        @drive_types = DriveTypes.new(painter, buttons)
         @snapshots = snapshots
         @browsing = nil
         @browse_from = media_path.empty? ? Dir.pwd : File.dirname(File.expand_path(media_path))
         @computer = nil
       end
 
-      def open? = !@browsing.nil? || @confirmation.open? || @name_field.open?
+      def open? = !@browsing.nil? || @confirmation.open? || @name_field.open? || @drive_types.open?
 
       # Opens the browser on the files for `kind`: :disk, :tape, :cartridge,
       # :program, or :snapshot, which starts in the saves folder.
@@ -40,12 +43,16 @@ module Badline
         extensions = case kind
                      when :cartridge then @media.cartridge_extensions
                      when :disk then @media.disk_extensions
+                     when :tape then @media.tape_extensions
                      when :program then programs
                      else EXTENSIONS.fetch(kind)
                      end
         @browser.open(kind == :snapshot ? Badline.data_folder("saves") : @browse_from, extensions)
       end
 
+      # Lists the drive types, with `model` the one on the bus.
+      def pick_drive(model) = @drive_types.open(model)
+
       # Asks for a save's name, starting from `name`.
       def ask_name(name) = @name_field.open("SAVE AS", name)
 
@@ -66,7 +73,7 @@ module Badline
       def drop(path)
         extension = File.extname(path).downcase
         return @media.insert(:disk, path) && false if @media.disk_extensions.include?(extension)
-        return @media.insert(:tape, path) && false if EXTENSIONS[:tape].include?(extension)
+        return @media.insert(:tape, path) && false if @media.tape_extensions.include?(extension)
         return false unless programs.include?(extension)
 
         @confirmation.ask(@media.cartridge_extensions.include?(extension) ? :cartridge : :start, path)
@@ -77,6 +84,7 @@ module Badline
       # answered yes, or nil.
       def key(scancode)
         return browsed(@browser.key(scancode)) unless @browsing.nil?
+        return drive_key(scancode) if @drive_types.open?
         if @name_field.open? && !@confirmation.open?
           return named(@name_field.key(scancode, SDL.event_mod(SDL.event).anybits?(SDL::KMOD_SHIFT)))
         end
@@ -88,15 +96,21 @@ module Badline
         nil
       end
 
-      # Handles a click on the browser's list at `top`, or on a question's
-      # answer, `action`.
-      def click(action, top) = action == :browse ? browsed(@browser.click(top)) : answer(action)
+      # Handles a click on the browser's list at `top`, on a question's
+      # answer, `action`, or on a drive type.
+      def click(action, top)
+        return browsed(@browser.click(top)) if action == :browse
+        return picked(action) if @drive_types.open?
+
+        answer(action)
+      end
 
       def scroll(rows) = @browser.scroll(rows)
 
       def draw(left, top, width)
         return @browser.draw(left, top, width, TITLES.fetch(@browsing)) unless @browsing.nil?
         return @confirmation.draw(left, top) if @confirmation.open?
+        return @drive_types.draw(left, top, width) if @drive_types.open?
 
         @name_field.draw(left, top, width)
       end
@@ -104,12 +118,16 @@ module Badline
       private
 
       # What Quick open and a drop start: every medium, and the cartridges
-      # the machine takes.
-      def programs = (EXTENSIONS[:program] + @media.cartridge_extensions).uniq
+      # the machine takes, or on the KIM-1 its programs.
+      def programs
+        return Media::KIM1Media::EXTENSIONS if @media.kim1?
+
+        (EXTENSIONS[:program] + @media.cartridge_extensions).uniq
+      end
 
-      # Puts the disk or tape picked in, or asks before a cartridge or
-      # Quick open power cycles the machine, and leaves the browser, as Esc
-      # does.
+      # Puts the disk or tape picked in, a tape Quick open picks on the
+      # KIM-1 too, or asks before a cartridge or Quick open power cycles the
+      # machine, and leaves the browser, as Esc does.
       def browsed(picked)
         return nil if picked.nil?
 
@@ -121,12 +139,41 @@ module Badline
 
         if %i[disk tape].include?(kind)
           @media.insert(kind, picked)
+        elsif @media.kim1? && @media.tape_extensions.include?(File.extname(picked).downcase)
+          @media.insert(:tape, picked)
         else
           @confirmation.ask(kind == :cartridge ? :cartridge : :start, picked)
         end
         nil
       end
 
+      # Up and Down move along the drive types, Return or Space picks one,
+      # and Left or Esc goes back to the page.
+      def drive_key(scancode)
+        return picked(@buttons.focus) if [Keys::RETURN, Keys::SPACE].include?(scancode)
+
+        direction = Keys::DIRECTIONS[scancode]
+        if scancode == Keys::ESCAPE || direction == :left
+          @drive_types.close
+          @buttons.focus = :drive_type
+        elsif %i[up down].include?(direction)
+          @buttons.shift(direction == :up ? -1 : 1, 1)
+        end
+        nil
+      end
+
+      # Puts the drive type `action` stands for on the bus, and goes back
+      # to the page.
+      def picked(action)
+        model = @drive_types.model_for(action)
+        return nil if model.nil?
+
+        @drive_types.close
+        @buttons.focus = :drive_type
+        @media.drive_type(model)
+        nil
+      end
+
       # Saves the machine under the name typed once Return takes it, and
       # asks first when a save has that name already.
       def named(result)

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

@@ -37,15 +37,22 @@ module Badline
 
       def writable? = @writable
 
+      def kim1? = @computer.family == :kim1
+
       def disk_path = MediaSlots.disk_path(@computer)
 
       def inserted? = MediaSlots.disk?(@computer)
 
-      # Puts a disk in device 8 or a tape in the datasette, `kind` :disk or
-      # :tape, and says whether it went in. A list puts its first disk in.
+      # Puts a disk in device 8 or a tape in the datasette or the KIM-1's
+      # deck, `kind` :disk or :tape, and says whether it went in. A list
+      # puts its first disk in.
       def insert(kind, path)
         succeeds? do
-          if kind == :disk
+          if @computer.family == :kim1
+            raise Machine::Unsupported, "the KIM-1 takes no disks" if kind == :disk
+
+            @computer.tape.insert_tape(Storage::KIMTape.read(path))
+          elsif kind == :disk
             disk = Media::DiskList.disk(path)
             Media.insert_disk(@computer, disk, read_only: !@writable)
             list(path)
@@ -70,6 +77,21 @@ module Badline
 
       def eject_disk = MediaSlots.eject_disk(@computer)
 
+      # Puts a true drive of `model` on the PET's or the CBM-II's bus as
+      # device 8, in place of the drive or the traps there, with the disk
+      # device 8 had in it if the model reads it, and says whether it went
+      # on. The disk comes out first, so what was written reaches its file.
+      def drive_type(model)
+        return true if MediaSlots.drive_model(@computer) == model
+
+        succeeds? do
+          path = disk_path
+          eject_disk
+          @computer.plug_ieee_drive(model)
+          Media::TrueDrive.insert(@computer, path, read_only: !@writable) if Drives::IEEEModels.reads?(model, path)
+        end
+      end
+
       # Sets whether disks are writable, for the disk in the drive too,
       # which goes in again as the notch now says.
       def writable(writable)
@@ -101,19 +123,25 @@ module Badline
         insert(:disk, set[index + step])
       end
 
+      # The extensions of the tapes the datasette takes, or the KIM-1's
+      # deck: .wav recordings.
+      def tape_extensions = kim1? ? [Media::KIM1Media::TAPE] : Media::Extensions.of(%i[tape])
+
       # The extensions of the cartridges the machine takes: .crt, on the
-      # 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.
+      # Plus/4 raw .bin ROM images too, and none on the PET or the KIM-1,
+      # or on the CBM-II, whose cartridge goes in from the command line.
       def cartridge_extensions
-        extensions = Media::Extensions.of(%i[pet cbm2].include?(@computer.family) ? %i[none] : %i[cartridge])
+        extensions = Media::Extensions.of(%i[pet cbm2 kim1].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 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.
+      # the 8050's and 8250's disk images and the hard disks' 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 %i[pet cbm2].include?(@computer.family)
+        if %i[pet cbm2].include?(@computer.family)
+          return Media::Extensions.of(%i[disk ieee_disk hard_disk archive disk_list])
+        end
 
         Media::Extensions::DEVICE8
       end
@@ -132,13 +160,15 @@ module Badline
       # 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 cbm2].include?(@computer.family) ? "" : cartridge_name
+        name = vic20 || %i[plus4 pet cbm2 kim1].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 && @computer.family != :cbm2
+        name = tape_name if name.empty? && !vic20 && !%i[cbm2 kim1].include?(@computer.family)
         name = name.sub(/\s*[(\[].*\z/, "").strip
         return name unless name.empty?
 
+        return "KIM-1" if @computer.family == :kim1
+
         vic20 ? "VIC-20" : "BASIC"
       end
 
@@ -157,7 +187,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, :cbm2 then ""
+        when :pet, :cbm2, :kim1 then ""
         else
           cartridge = @computer.address_bus.cartridge
           cartridge.nil? ? "" : cartridge.name