badline 0.17.0 → 0.18.0

data/lib/badline/media/kim1_media.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # What a KIM-1 loads (Media.attach): a MOS papertape, a .ptp or .pap
+    # (Storage::Papertape), at the addresses its records give, or a .bin
+    # of bare bytes, which says nothing of where it goes, at its Loading's
+    # load address.
+    #
+    # Once the monitor runs, the bytes go straight into memory, after
+    # the NMI and IRQ vectors at $17FA and $17FE, which nothing sets at
+    # power-on, are pointed at the monitor's $1C00, so ST and BRK stop
+    # the program and show where (User Manual, section 4.1). A papertape
+    # can go in through the teletype instead, as the monitor's L command
+    # reads it, in real time. The program then starts at its Loading's
+    # start address, or else where it loads, as the user would start it:
+    # AD, the address and GO on the keypad, or the address, a space and G
+    # on the teletype. Without autostart the monitor stops at the
+    # address.
+    #
+    # A .wav, a recording of a KIM tape (Storage::KIMTape), goes in the
+    # cassette deck, for the monitor's LOADT to read once PLAY is down.
+    module KIM1Media
+      PAPERTAPES = Extensions.of(%i[papertape])
+
+      # A .bin, bare bytes.
+      BINARY = ".bin"
+
+      # A recording of a tape.
+      TAPE = ".wav"
+
+      # What a KIM-1 takes.
+      EXTENSIONS = (PAPERTAPES + [BINARY, TAPE]).freeze
+
+      # Where a .bin loads without a load address, as most of the First
+      # Book of KIM's programs do.
+      DEFAULT_LOAD_ADDRESS = 0x0200
+
+      # Where the monitor saves the registers and shows the PC, for the
+      # NMI and IRQ vectors.
+      MONITOR = 0x1c00
+
+      NMI_VECTOR = 0x17fa
+      IRQ_VECTOR = 0x17fe
+
+      # How a KIM-1 loads and starts a program: at `load_address`, a .bin's,
+      # or -1 for DEFAULT_LOAD_ADDRESS, from `start_address`, or -1 for
+      # where it loads, and through the teletype's L command if
+      # `teletype`.
+      class Loading
+        attr_reader :load_address, :start_address
+
+        def initialize(load_address: -1, start_address: -1, teletype: false)
+          @load_address = load_address
+          @start_address = start_address
+          @teletype = teletype
+        end
+
+        def teletype? = @teletype
+      end
+
+      # Loads straight into memory, from where it loads.
+      DIRECT = Loading.new
+
+      class << self
+        # The Loading the command line's `options` ask for, with
+        # --load-address, --start-address and --tty-load.
+        def loading(options)
+          load_address = options.load_address
+          start_address = options.start_address
+          Loading.new(load_address: load_address.nil? ? -1 : load_address,
+                      start_address: start_address.nil? ? -1 : start_address, teletype: options.tty_load?)
+        end
+
+        # Whether a KIM-1 takes the file at `path`.
+        def takes?(path) = EXTENSIONS.include?(File.extname(path).downcase)
+
+        # Loads the program at `path` into the KIM-1 `machine` as
+        # `loading` says, and starts it if `autostart`. Raises
+        # Machine::Unsupported when it loads outside the RAM.
+        def attach(machine, path, loading, autostart:)
+          raise Machine::Unsupported, "doesn't go in a KIM-1" unless takes?(path)
+          return insert_tape(machine, path) if File.extname(path).downcase == TAPE
+
+          papertape = PAPERTAPES.include?(File.extname(path).downcase)
+          tape = papertape ? Storage::Papertape.read(path) : nil
+          records = tape.nil? ? [binary(path, loading.load_address)] : tape.records
+          refuse_outside_ram(machine, records)
+          start = loading.start_address.negative? ? records.first.address : loading.start_address
+          if !tape.nil? && loading.teletype? && machine.tty?
+            machine.teletype.type("L#{tape.text}")
+          else
+            machine.on_init { deposit(machine, records) }
+          end
+          machine.on_init { machine.type_text(start_keys(machine, start, autostart)) }
+          "Loading #{path} at $#{hex(records.first.address)}"
+        end
+
+        private
+
+        def insert_tape(machine, path)
+          machine.tape.insert_tape(Storage::KIMTape.read(path))
+          "Inserted #{path} in the tape deck"
+        end
+
+        def binary(path, load_address)
+          Storage::Papertape::Record.new(load_address.negative? ? DEFAULT_LOAD_ADDRESS : load_address,
+                                         File.binread(path).bytes)
+        end
+
+        def refuse_outside_ram(machine, records)
+          records.each do |record|
+            address = record.address
+            last = address + record.bytes.size - 1
+            raise Machine::Unsupported, "has no bytes to load" if last < address
+            next if last <= 0xffff && (address..last).all? { |byte_address| machine.bus.ram?(byte_address) }
+
+            raise Machine::Unsupported, "loads at $#{hex(address)}-$#{hex(last)}, outside the KIM-1's " \
+                                        "#{machine.bus.ram_kb}K of RAM; --ram 5k or --ram expanded adds more"
+          end
+        end
+
+        def deposit(machine, records)
+          [NMI_VECTOR, IRQ_VECTOR].each do |vector|
+            machine.poke(vector, MONITOR & 0xff)
+            machine.poke(vector + 1, MONITOR >> 8)
+          end
+          records.each do |record|
+            address = record.address
+            record.bytes.each_with_index { |byte, offset| machine.poke(address + offset, byte) }
+          end
+        end
+
+        # What starts the program at `start`, or stops at it without
+        # `autostart`.
+        def start_keys(machine, start, autostart)
+          if machine.tty?
+            opened = "#{hex(start)} "
+            return autostart ? "#{opened}G" : opened
+          end
+
+          keys = "AD #{hex(start).chars.join(' ')}"
+          autostart ? "#{keys} GO" : keys
+        end
+
+        def hex(value) = value.to_s(16).upcase.rjust(4, "0")
+      end
+    end
+  end
+end

data/lib/badline/media/pet_media.rb

@@ -27,8 +27,10 @@ module Badline
         # BASIC 2 and 4 load the first program off the disk and run it.
         # BASIC 1's LOAD finds no device on the IEEE-488 bus, so the first
         # program, which the block gives, goes in as a program file does,
-        # once the KERNAL has booted.
+        # once the KERNAL has booted. The SuperPET's 6809 starts its own
+        # menu instead.
         def disk_autostart(machine)
+          return unless machine.boots_basic?
           return machine.type_text(AUTOSTART) unless machine.model.basic1?
 
           data = yield

data/lib/badline/media/true_drive.rb

@@ -4,17 +4,22 @@ module Badline
   module Media
     # Device 8 as a true drive instead of the KERNAL traps: a 1541, or on
     # the C128 its 1571, or on the Plus/4 a 1551 if it asks for one, or a
-    # 1581, or on the PET or the CBM-II a 2031 on the IEEE-488 bus, or for
-    # a .d80 or .d82 an 8050 or 8250. Once a true drive is plugged in as device 8, disk media go into
-    # it rather than into the traps, so a LOAD runs the DOS and every byte
-    # crosses the serial bus or TCBM. A .g64 holds the
-    # disk's raw GCR, which only a true drive reads, so it plugs one in
-    # when there's none yet. The 1541 reads only .d64 and .g64 images, the
-    # 1571 .d71 and .g71 as well, and the 1581 only .d81, so a .d81 swaps
-    # the drive on device 8 for a 1581 (Drives::Model1581::Slot), and another disk
-    # image swaps a 1581 back for the machine's own drive. The PET and the
-    # CBM-II have no 1581, and their 2031 reads .d64 and .g64 images only.
-    # The traps' other disk media, a .t64 or a host directory, raise Error.
+    # 1581, or on the PET or the CBM-II a drive on the IEEE-488 bus. Once a
+    # true drive is plugged in as device 8, disk media go into it rather
+    # than into the traps, so a LOAD runs the DOS and every byte crosses the
+    # serial bus, TCBM or the IEEE-488 bus. A .g64 holds the disk's raw
+    # GCR, which only a true drive reads, so it plugs one in when there's
+    # none yet. The 1541 reads only .d64 and .g64 images, the 1571 .d71 and
+    # .g71 as well, and the 1581 only .d81, so a .d81 swaps the drive on
+    # device 8 for a 1581 (Drives::Model1581::Slot), and another disk image
+    # swaps a 1581 back for the machine's own drive. On the PET and
+    # the CBM-II an image goes in the drive on device 8 if it reads it, or
+    # else in a drive of the machine's own model, plug_true_drive's, if
+    # that reads it, or else in the model made for it, swapped in
+    # (Drives::IEEEModels): a 2031 for a .d64, an 8050 for a .d80 and an
+    # 8250 for a .d82, in the drive of a dual unit the machine names
+    # (disk_drive_number): drive 1 on a SuperPET running its 6809. The
+    # traps' other disk media, a .t64 or a host directory, raise Error.
     module TrueDrive
       class Error < ArgumentError; end
 
@@ -34,12 +39,12 @@ module Badline
           drive if drive && drive.device == KernalTrap::Routine::DEVICE
         end
 
-        # Whether the path goes in a true drive: a .g64 or .g71 always, and
-        # other disk media, which the traps would mount, when a true drive
+        # Whether the path goes in a true drive: a .g64, .g71 or .d90 always,
+        # and other disk media, which the traps would mount, when a true drive
         # is device 8.
         def takes?(computer, path)
           kind = Extensions.kind(path)
-          return true if kind == :gcr
+          return true if %i[gcr hard_disk].include?(kind)
 
           !drive(computer).nil? && (File.directory?(path) || %i[disk archive ieee_disk].include?(kind))
         end
@@ -49,16 +54,13 @@ module Badline
         # mounted through the traps, so LOAD and SAVE reach the drive too.
         # `read_only` puts it in write-protected.
         def insert(computer, path, read_only: false)
-          swapped = insert_swapping(computer, path, read_only)
-          return swapped if swapped
+          return insert_ieee(computer, path, read_only) if IEEE_FAMILIES.include?(computer.family)
+          return insert_d81(computer, path, read_only) if File.extname(path).casecmp?(".d81")
 
-          pet = IEEE_FAMILIES.include?(computer.family)
           drive = own_drive(computer)
           name = drive&.model_name || default_model(computer)
           types = name == "1571" ? %w[.d64 .g64 .d71 .g71] : %w[.d64 .g64]
           unless types.include?(File.extname(path).downcase)
-            raise Error, "#{path} is not a #{types.join(' or ')} image, which the #{name} reads" if pet
-
             raise Error, "#{path} is not a #{types.join(', ')} or .d81 image, which the #{name} and the 1581 read"
           end
 
@@ -71,39 +73,34 @@ module Badline
         private
 
         # The model plug_true_drive plugs in.
-        def default_model(computer)
-          case computer.family
-          when :c128 then "1571"
-          when :pet, :cbm2 then "2031"
-          else "1541"
-          end
-        end
+        def default_model(computer) = computer.family == :c128 ? "1571" : "1541"
 
-        # The drive on device 8 unless it's a 1581, or an 8050 or 8250,
-        # which a .d64 swaps back out.
+        # The drive on device 8 unless it's a 1581, which a .d64 swaps back
+        # out.
         def own_drive(computer)
           drive = drive(computer)
-          drive unless %w[1581 8050 8250].include?(drive&.model_name)
+          drive unless drive&.model_name == "1581"
         end
 
-        # A .d81 in a 1581, and on the PET or the CBM-II a .d80 or .d82 in
-        # an 8050 or 8250, each swapped in for the drive there, or nil for
-        # the rest.
-        def insert_swapping(computer, path, read_only)
-          extension = File.extname(path).downcase
-          if IEEE_FAMILIES.include?(computer.family)
-            insert_d80(computer, path, read_only) if %w[.d80 .d82].include?(extension)
-          elsif extension == ".d81"
-            insert_d81(computer, path, read_only)
+        # The image in the model Drives::IEEEModels.taking picks, swapped in
+        # for the drive on device 8 unless it's that model already.
+        def insert_ieee(computer, path, read_only)
+          drive = drive(computer)
+          model = Drives::IEEEModels.taking(path, drive&.model_name, computer.true_drive_model)
+          unless model
+            name = computer.true_drive_model
+            types = Drives::IEEEModels::MEDIA.fetch(name)
+            raise Error, "#{path} is not a #{types.join(' or ')} image, which the #{name} reads"
+          end
+
+          drive = computer.plug_ieee_drive(model) unless drive&.model_name == model
+          number = computer.disk_drive_number
+          if number.positive? && drive.is_a?(Drives::Model8050)
+            drive.insert_image(path, drive: number, read_only:)
+            computer.unmount
+            return "Inserted #{path} in the #{model}'s drive #{number} as device 8"
           end
-        end
 
-        # An 8050 for a .d80 and an 8250 for a .d82, swapped in for the
-        # drive on device 8 unless it's that model already.
-        def insert_d80(computer, path, read_only)
-          model = File.extname(path).casecmp?(".d82") ? "8250" : "8050"
-          drive = drive(computer)
-          drive = computer.plug_drive8050(model) unless drive&.model_name == model
           drive.insert_image(path, read_only:)
           computer.unmount
           "Inserted #{path} in the #{model} as device 8"

data/lib/badline/media.rb

@@ -13,6 +13,7 @@ require "badline/media/vic20_media"
 require "badline/media/plus4_media"
 require "badline/media/pet_media"
 require "badline/media/cbm2_media"
+require "badline/media/kim1_media"
 require "badline/media/tune"
 require "badline/media/program"
 
@@ -29,7 +30,8 @@ module Badline
       ".d81" => Storage::D81Image,
       ".t64" => Storage::T64,
       ".d80" => Storage::D80Image,
-      ".d82" => Storage::D82Image
+      ".d82" => Storage::D82Image,
+      ".d67" => Storage::D67Image
     }.freeze
 
     class << self
@@ -56,8 +58,11 @@ module Badline
       # and .d82 disks too, which no other machine takes, and has no
       # cartridges, tunes or true drives (PETMedia), and so does the CBM-II,
       # which takes its own .crt cartridges and no tapes (CBM2Media). The
-      # C128 in C64 mode takes a C64's.
-      def attach(computer, path, autostart: true, subtune: nil, **)
+      # C128 in C64 mode takes a C64's. The KIM-1 takes only its programs,
+      # which load as `kim1`, a KIM1Media::Loading, says (KIM1Media).
+      def attach(computer, path, autostart: true, subtune: nil, kim1: KIM1Media::DIRECT, **)
+        return KIM1Media.attach(computer, path, kim1, autostart:) if computer.family == :kim1
+
         path = DiskList.disk(path)
         refuse_unsupported(computer, path)
 
@@ -128,11 +133,12 @@ module Badline
       private
 
       # The VIC-20 and the 264 series have no SID to play a .sid tune on,
-      # and only the PET and the CBM-II have the IEEE-488 drive a .d80 or
-      # .d82 goes in.
+      # only the PET and the CBM-II have the IEEE-488 drive a .d80, .d82
+      # or .d90 goes in, and only the KIM-1 reads papertape.
       def refuse_unsupported(computer, path)
         family = computer.family
-        if Extensions.kind(path) == :ieee_disk && !%i[pet cbm2].include?(family)
+        raise Machine::Unsupported, "#{path} needs a KIM-1" if Extensions.kind(path) == :papertape
+        if %i[ieee_disk hard_disk].include?(Extensions.kind(path)) && !%i[pet cbm2].include?(family)
           raise ArgumentError, "#{path} needs a PET's or a CBM-II's IEEE-488 drive"
         end
 

data/lib/badline/options/family.rb

@@ -12,10 +12,94 @@ module Badline
       # Where C128 BASIC starts, which a program for the C128 loads at.
       C128_BASIC_START = 0x1c01
 
+      # Whether the KIM-1 talks to a teletype: with --tty or --tty-load,
+      # and always on the terminal with --headless.
+      def tty? = @tty || @tty_load || kim1_terminal?
+
+      # The KIM-1 teletype's baud.
+      def baud = @baud
+
+      # Whether the KIM-1 loads a papertape through its monitor's L
+      # command, with --tty-load.
+      def tty_load? = @tty_load
+
+      # Where the KIM-1 loads a .bin, and where it starts its program, as
+      # --load-address and --start-address give them, or nil.
+      def load_address = @load_address
+
+      def start_address = @start_address
+
+      # Whether the KIM-1 runs on the terminal, its teletype there.
+      def kim1_terminal? = @family == :kim1 && @headless
+
       private
 
-      # Takes `sid`, `c64`, `vic20`, `c128`, `plus4`, `pet` or `cbm2` when
-      # given first.
+      # The KIM-1's keypad, until --tty or --baud name its teletype, and
+      # its programs where they load.
+      def initialize_kim1
+        @tty = false
+        @tty_load = false
+        @baud = 9600
+        @load_address = nil
+        @start_address = nil
+      end
+
+      # The KIM-1 teletype's baud, and where it loads a .bin and starts a
+      # program.
+      def kim1_option(name, flag, value)
+        case name
+        when "--baud" then @baud = baud_for(value)
+        when "--load-address" then @load_address = address(flag, value)
+        else @start_address = address(flag, value)
+        end
+      end
+
+      def kim1_switch(name)
+        if name == "--tty"
+          @tty = true
+        else
+          @tty_load = true
+        end
+      end
+
+      # An address in hex, with or without a $ or 0x before it.
+      def address(flag, value)
+        digits = value.delete_prefix("$").delete_prefix("0x").delete_prefix("0X")
+        raise Error, "invalid argument: #{flag} #{value}" unless digits.match?(/\A[0-9a-fA-F]{1,4}\z/)
+
+        digits.to_i(16)
+      end
+
+      def kim1_ram(value)
+        raise Error, "invalid argument: --ram #{value}" unless KIM1_RAM.key?(value)
+
+        KIM1_RAM[value]
+      end
+
+      # The KIM-1 runs in the window, or with --headless on the terminal,
+      # without the C64's SID and REU. Only a papertape goes in through
+      # the teletype, and only a .bin has a load address to give.
+      def validate_kim1
+        raise Error, "--ntsc needs the C64" if @models.include?("ntsc")
+        raise Error, "--sid needs the C64" unless @sid_model.nil?
+        raise Error, "--reu needs the C64" unless @reu.nil?
+        raise Error, "--audio-out needs a .sid tune" unless @audio_out.nil?
+
+        extension = @media_path.nil? ? "" : File.extname(@media_path).downcase
+        raise Error, "--tty-load needs a .ptp or .pap" if @tty_load && !%w[.ptp .pap].include?(extension)
+        raise Error, "--load-address needs a .bin" unless @load_address.nil? || extension == ".bin"
+      end
+
+      # Only the KIM-1 has a teletype, and programs without a load address.
+      def refuse_kim1_options
+        raise Error, "#{@tty ? '--tty' : '--baud'} needs kim1" if @tty || @baud != 9600
+        raise Error, "--tty-load needs kim1" if @tty_load
+        raise Error, "--load-address needs kim1" unless @load_address.nil?
+        raise Error, "--start-address needs kim1" unless @start_address.nil?
+      end
+
+      # Takes `sid`, `c64`, `vic20`, `c128`, `plus4`, `pet`, `cbm2` or `kim1`
+      # when given first.
       def subcommand(args)
         case args.first
         when "sid" then @sid_command = true
@@ -25,6 +109,7 @@ module Badline
         when "plus4" then @family = :plus4
         when "pet" then @family = :pet
         when "cbm2" then @family = :cbm2
+        when "kim1" then @family = :kim1
         else return
         end
         @family_named = !@sid_command
@@ -38,18 +123,22 @@ module Badline
         when :plus4 then PLUS4_MODELS
         when :pet then PET_MODELS
         when :cbm2 then CBM2_MODELS
+        when :kim1 then KIM1_MODELS
         else MODELS
         end
       end
 
       # Without a family named, a program that loads at C128_BASIC_START is
-      # the C128's, an 8050's or 8250's disk or a PET tape the PET's, and a
-      # cartridge signed as a CBM-II's the CBM-II's. A program that loads
-      # where PET BASIC starts could be a VIC-20's too.
+      # the C128's, an 8050's or 8250's disk or a PET tape the PET's, a
+      # cartridge signed as a CBM-II's the CBM-II's, and a papertape the
+      # KIM-1's. A program that loads where PET BASIC starts could be a
+      # VIC-20's too.
       def pick_family
         return if @family_named || @sid_command || @media_path.nil? || !File.file?(@media_path)
 
-        if pet_media?
+        if Media::Extensions.kind(@media_path) == :papertape
+          @family = :kim1
+        elsif pet_media?
           @family = :pet
         elsif cbm2_cartridge?
           @family = :cbm2
@@ -63,10 +152,11 @@ module Badline
         Media::Extensions.kind(@media_path) == :cartridge && Storage::CRTFile.cbm2?(@media_path)
       end
 
-      # Whether the media is an 8050's or 8250's disk or a PET tape.
+      # Whether the media is an 8050's or 8250's disk, a D9060's or D9090's
+      # hard disk, or a PET tape.
       def pet_media?
         kind = Media::Extensions.kind(@media_path)
-        kind == :ieee_disk || (kind == :tape && Storage::TAP.platform_of(@media_path) == Storage::TAP::PET_PLATFORM)
+        %i[ieee_disk hard_disk].include?(kind) || (kind == :tape && Storage::TAP.platform_of(@media_path) == Storage::TAP::PET_PLATFORM)
       end
     end
   end

data/lib/badline/options/help.rb

@@ -49,10 +49,11 @@ module Badline
     # wrapped as the banner is.
     def media_kinds
       text = "Media can be #{listed(Media::Extensions::PROGRAMS)} program, #{listed(%i[disk])} disk image, " \
-             "#{listed(%i[ieee_disk])} disk image for a PET, #{listed(%i[gcr])} disk image for a true drive, " \
-             "#{listed(%i[disk_list])} list of disk images, " \
+             "#{listed(%i[ieee_disk])} disk image or #{listed(%i[hard_disk])} hard disk for a PET, " \
+             "#{listed(%i[gcr])} disk image for a true drive, #{listed(%i[disk_list])} list of disk images, " \
              "#{listed(%i[archive])} tape archive, #{listed(%i[tape])} tape, #{listed(%i[cartridge])} " \
-             "cartridge, #{listed(%i[tune])} tune, #{listed(%w[.vsf])} snapshot, or a directory to mount as device 8."
+             "cartridge, #{listed(%i[tune])} tune, #{listed(%i[papertape])} papertape for a KIM-1, " \
+             "#{listed(%w[.vsf])} snapshot, or a directory to mount as device 8."
       wrap(text)
     end
 
@@ -87,17 +88,19 @@ module Badline
                #{@program} plus4 [options] [media]
                #{@program} pet [options] [media]
                #{@program} cbm2 [options] [media]
+               #{@program} kim1 [options] [program]
                #{@program} --headless [options] tune.sid
                #{@program} [options] tune.sid --audio-out FILE
                #{@program} sid [options] FILE|DIR...
 
         Commands:
             c64                              Run a C64, the one --model names (the default)
-            vic20                            Run a PAL VIC-20, with the RAM --ram names
+            vic20                            Run a VIC-20, PAL or --ntsc, with the RAM --ram names
             c128                             Run a C128 in C128 mode, the one --model names
             plus4                            Run a Plus/4 or a C16, the one --model names
             pet                              Run a PET or a CBM, the one --model names
             cbm2                             Run a CBM-II, a B series or a P500, the one --model names
+            kim1                             Run a MOS KIM-1, on its keypad and LED display
             sid                              Play .sid tunes and directories of them
 
         #{media_kinds}
@@ -122,33 +125,60 @@ module Badline
         ESC, Page Down RUN/STOP and F4 HELP.
 
         The PET and the CBM take programs, disks, .d80 and .d82 among them,
-        and tapes, and a .d80, a .d82 or a PET tape starts one without
-        `pet`. Their keys type what the host's keys type, Alt with a key
+        and tapes, and a .d80, .d82, .d67 or .d90 or a PET tape starts one
+        without `pet`. Their keys type what the host's keys type, Alt with a key
         presses the PET's SHIFT and the key its unshifted character is on,
         and the pause menu's KEYBOARD page says where the rest are. --basic
         and --editor fit the upgrades Commodore sold, as in --model 2001
         --basic 2. BASIC 1 can't LOAD from a disk drive, though a disk still
         starts its first program, and BASIC 2 can. Their --true-drive makes
         device 8 an emulated 2031 on the IEEE-488 bus, which reads .d64 and
-        .g64 images. The 8032 and the 8096 have two 50 Hz editors:
-        4-80-b-50hz, the default, and 4-80-b-50hz-0283, another chip's,
+        .g64 images, and a .d80 or a .d82 then goes in an emulated 8050 or
+        8250. --drive-type 8050 or 8250 plugs either in instead, and
+        --drive-type 1001 an SFD-1001, which takes a .d82 in its one drive.
+        --drive-type 4040 or 3040 puts a .d64 in a 4040 or a 3040 instead
+        of the 2031, and a .d67, DOS 1's disk, goes in a 2040. A .d90 hard
+        disk always goes in a D9060 or a D9090, by its size. The pause
+        menu's DRIVE 8 page picks the drive type on the bus.
+        The 8032 and the 8096 have two 50 Hz editors: 4-80-b-50hz, the
+        default, and 4-80-b-50hz-0283, another chip's,
         with 64-cycle lines and 313 lines a frame. The 8296 runs its own,
         4-80-b-50hz-8296, and takes the 8032's too. --characters din fits
         it with the DIN character ROM, and --jumpers ram9,rama puts RAM at
-        $9000 and $A000, as xpet's -petram9 and -petramA do.
+        $9000 and $A000, as xpet's -petram9 and -petramA do. --model
+        superpet runs the SuperPET, and --cpu 6809 its Waterloo 6809 side.
+        --bank-ram read write-protects its 64K bank RAM.
 
         The CBM-II takes programs, disks, .d80 and .d82 among them, and
         cartridges, and a cartridge made for it starts one without `cbm2`.
         --kernal 03b fits the 1983 KERNAL in place of 04a, and --60hz runs
         it on 60 Hz mains. Its --true-drive makes device 8 an emulated 2031
         on its IEEE-488 bus, which reads .d64 and .g64 images, and a .d80
-        or a .d82 then goes in an emulated 8050 or 8250. Its keys type what
+        or a .d82 then goes in an emulated 8050 or 8250, and --drive-type
+        plugs in either from the start, as on the PET. Its keys type what
         the host's keys type, F12 is RUN/STOP, Alt with F9 or F10 presses
         its F9 or F10, and the pause menu's KEYBOARD page says where the
         rest are. --model 510 or 510ntsc runs the P500, on the VIC-II with
         KERNAL 02, whose keys are the B series' and whose two joysticks Tab
         switches to.
 
+        The KIM-1 starts in its monitor, on the keypad and the six LED
+        digits, which the window draws with the keys under them. 0-9 and A-F
+        are the hex keys, comma AD, period DA, space or + +, G or Return GO,
+        P PC, S or Esc ST, R RS and T the SST switch, and a click presses a
+        key too. The pause menu's PANEL page sets SST, the TTY/KB jumper and
+        what U3's PB7 and PA0 are wired to. --tty puts the monitor on a
+        teletype at --baud, shown in the window, or with --headless on the
+        terminal, where Ctrl-C quits.
+        It loads .ptp and .pap papertapes, which start a KIM-1 without
+        `kim1`, and .bin files at --load-address. The program goes into RAM,
+        the NMI and IRQ vectors at $17FA and $17FE point at the monitor, and
+        the monitor starts it where it loads, or at --start-address.
+        --tty-load reads a papertape through the monitor's L command
+        instead. --ram 5k fills $0400-$13FF, and --ram expanded $2000-$DFFF
+        too. A .wav recording of a KIM tape goes in the cassette deck, which
+        the pause menu's DATASETTE page plays for LOADT at $1873.
+
         --headless plays a .sid tune on the host's audio device without the
         window, and --audio-out renders it to 16-bit PCM instead. The
         container follows the file's extension, .wav or .aiff. Played on a
@@ -171,10 +201,12 @@ module Badline
         key=NAME presses a key (space, return, a, f1, run_stop, restore, and
         on the C128 esc, help, keypad1 and the rest, on the Plus/4
         esc, help and f1 to f3, on the PET rvs, escape and kp1, and on
-        the CBM-II escape, norm_graph and kp00) or a joystick's
+        the CBM-II escape, norm_graph and kp00, and on the KIM-1 its keys,
+        as 0 to f, ad, da, plus, go, pc, st and rs) or a joystick's
         direction or fire (joy1-up, joy2-fire) for #{Event::HOLD} frames, and
         pushes the C128's caps_lock or forty_eighty, which lock. type=TEXT
-        types it, with \\n for RETURN. insert=FILE swaps in a disk, a list's
+        types it, with \\n for RETURN, or on the KIM-1 presses the keys it
+        names, as in type=AD 0200 DA A9. insert=FILE swaps in a disk, a list's
         first disk, a tape or a cartridge, and eject=disk, tape or
         cartridge takes one out. screenshot=FILE saves the frame as a .bmp,
         with the frame's number in place of %d. menu opens the pause menu,