badline 0.13.0 → 0.14.0

data/lib/badline/kernal_trap/layout.rb

@@ -20,7 +20,11 @@ module Badline
     # +banked+ says whether the 6510 port can bank the KERNAL out, and so
     # whether RAM lies under every ROM and the I/O. +mmu+ says the C128's
     # MMU maps the KERNAL instead, and that the file name and the file's
-    # bytes lie in the banks the KERNAL keeps at FNBANK and BA. Each
+    # bytes lie in the banks the KERNAL keeps at FNBANK and BA.
+    # +rom_select+ says the 264 series' TED selects ROM or RAM and its
+    # latch the ROM banks, so the KERNAL is in while ROM is selected with
+    # the KERNAL's bank, and the ROM reads the file name and the file's
+    # bytes from RAM, under any ROM, through its bank fetch at $07D9. Each
     # serial byte starts a one-shot timer by writing the high byte of its
     # count to +serial_timer+, and the control value TIMER_ONE_SHOT_START
     # to +serial_timer_start+ where the timer has a control register to
@@ -29,16 +33,19 @@ module Badline
     # +serial_timer+. The ROM lets go of each serial line by reading a
     # port, masking the line's bit off and writing it back: ATN at
     # +atn_port+ with +atn_mask+, then the clock and the data line.
+    # +zero_page+ is a ZeroPage, where the KERNAL keeps the file's
+    # parameters and the status the traps read and set.
     Layout = Data.define(:load, :save, :searching_message, :loading_message, :load_byte_loop, :load_done,
                          :file_not_found_exit, :missing_file_name_exit, :saving_message, :clock_release,
                          :data_release, :save_done, :talk, :listen, :second, :tksa, :ciout, :untalk,
                          :unlisten, :acptr, :banked, :serial_timer, :serial_timer_start, :atn_port, :atn_mask,
-                         :clock_port, :clock_mask, :data_port, :data_mask, :mmu) do
+                         :clock_port, :clock_mask, :data_port, :data_mask, :mmu, :rom_select, :zero_page) do
       # Whether the CPU reads the KERNAL ROM at the trapped addresses: on a
-      # banked machine, the 6510 port's banking bits select it, and on the
-      # C128 the MMU.
+      # banked machine, the 6510 port's banking bits select it, on the
+      # C128 the MMU, and on the 264 series the ROM select and bank latch.
       def kernal_mapped?(bus)
         return bus.system_rom_mapped? if mmu
+        return bus.kernal_selected? if rom_select
 
         !banked || bus.io_port.kernal?
       end
@@ -55,15 +62,21 @@ module Badline
       end
 
       # The file name's byte at +address+, in the bank at FNBANK on the
-      # C128.
+      # C128 and in RAM on the 264 series.
       def filename_byte(bus, address)
-        mmu ? bus.peek_bank(bus.peek(FILENAME_BANK), address) : bus.peek(address)
+        return bus.peek_bank(bus.peek(FILENAME_BANK), address) if mmu
+        return bus.ram_view.peek(address) if rom_select
+
+        bus.peek(address)
       end
 
       # The byte at +address+ a SAVE writes or a VERIFY compares, in the bank
-      # at BA on the C128.
+      # at BA on the C128 and in RAM on the 264 series.
       def file_byte(bus, address)
-        mmu ? bus.peek_bank(bus.peek(BANK), address) : bus.peek(address)
+        return bus.peek_bank(bus.peek(BANK), address) if mmu
+        return bus.ram_view.peek(address) if rom_select
+
+        bus.peek(address)
       end
 
       # Starts the timer the ROM times a serial byte with, its count's high
@@ -95,6 +108,32 @@ module Badline
       end
     end
 
+    # The zero-page variables of a KERNAL's file routines, by address:
+    # +status+ (ST), +verify+ (VERCK, 0 for LOAD and 1 for VERIFY),
+    # +start_address+ (SAL), +end_address+ (EAL), +filename_length+
+    # (FNLEN), +secondary_address+ (SA), +device+ (FA), +filename_address+
+    # (FNADR), +save_start+ (STAL) and +load_address+ (MEMUSS, where LOAD
+    # puts a file loaded with secondary address 0). Each two-byte one names
+    # its low byte, and the high byte follows it.
+    ZeroPage = Data.define(:status, :verify, :start_address, :end_address, :filename_length, :secondary_address,
+                           :device, :filename_address, :save_start, :load_address)
+
+    # The C64's file variables. The VIC-20 and C128 KERNALs keep theirs at
+    # the same addresses.
+    C64_ZERO_PAGE = ZeroPage.new(
+      status: 0x90, verify: 0x93, start_address: 0xac, end_address: 0xae, filename_length: 0xb7,
+      secondary_address: 0xb9, device: 0xba, filename_address: 0xbb, save_start: 0xc1, load_address: 0xc3
+    )
+
+    # The 264 series KERNAL's file variables, as its LOAD ($F04A) and SAVE
+    # ($F1A4) use them: SAVE walks SAL at $9B from STAL at $B2 up to EAL at
+    # $9D, and LOAD ends with EAL at $9D, or starts it from MEMUSS at $B4
+    # for secondary address 0.
+    PLUS4_ZERO_PAGE = ZeroPage.new(
+      status: 0x90, verify: 0x93, start_address: 0x9b, end_address: 0x9d, filename_length: 0xab,
+      secondary_address: 0xad, device: 0xae, filename_address: 0xaf, save_start: 0xb2, load_address: 0xb4
+    )
+
     # A CIA's control value that starts its timer: force load, one-shot,
     # start.
     TIMER_ONE_SHOT_START = 0x19
@@ -117,7 +156,7 @@ module Badline
       ciout: 0xeddd, untalk: 0xedef, unlisten: 0xedfe, acptr: 0xee13,
       banked: true, serial_timer: 0xdc07, serial_timer_start: 0xdc0f,
       atn_port: 0xdd00, atn_mask: 0xf7, clock_port: 0xdd00, clock_mask: 0xef, data_port: 0xdd00, data_mask: 0xdf,
-      mmu: false
+      mmu: false, rom_select: false, zero_page: C64_ZERO_PAGE
     )
 
     # The VIC-20 KERNAL, 901486-07 (PAL). The NTSC one, 901486-06, differs
@@ -135,7 +174,7 @@ module Badline
       ciout: 0xeee4, untalk: 0xeef6, unlisten: 0xef04, acptr: 0xef19,
       banked: false, serial_timer: 0x9129, serial_timer_start: nil,
       atn_port: 0x911f, atn_mask: 0x7f, clock_port: 0x912c, clock_mask: 0xfd, data_port: 0x912c, data_mask: 0xdf,
-      mmu: false
+      mmu: false, rom_select: false, zero_page: C64_ZERO_PAGE
     )
 
     # The C128 KERNAL, 318020-05, in C128 mode: the jump table's targets
@@ -156,7 +195,32 @@ module Badline
       ciout: 0xe503, untalk: 0xe515, unlisten: 0xe526, acptr: 0xe43e,
       banked: true, serial_timer: nil, serial_timer_start: nil,
       atn_port: 0xdd00, atn_mask: 0xf7, clock_port: 0xdd00, clock_mask: 0xef, data_port: 0xdd00, data_mask: 0xdf,
-      mmu: true
+      mmu: true, rom_select: false, zero_page: C64_ZERO_PAGE
+    )
+
+    # The 264 series KERNAL, 318004-05 (PAL), the same at every address
+    # here in the NTSC 318005-05: ILOAD's and ISAVE's default targets and
+    # the jump table's targets for the serial primitives, each of which
+    # tries a 1551's TCBM interface for devices 8 and 9 before the serial
+    # bus. LOAD prints SEARCHING FOR at $F160 and LOADING or VERIFYING at
+    # $F189, which ends CLC, retries a byte from $F09F and returns at $F0EB
+    # (LDX $9D, LDY $9E, RTS). FILE NOT FOUND leaves through $F27C and
+    # MISSING FILE NAME through $F288. SAVE prints SAVING at $F228 and
+    # returns at $F226 (CLC, RTS). The port at $01 drives the lines, ATN
+    # from bit 2, the clock from bit 1 ($E2B8 lets it go) and the data line
+    # from bit 0 ($E2C6). Its serial bytes are timed with TED timer 2, but
+    # its timeouts differ from the C64's, so the traps leave the timer
+    # alone.
+    PLUS4_LAYOUT = Layout.new(
+      load: 0xf04a, save: 0xf1a4,
+      searching_message: 0xf160, loading_message: 0xf189, load_byte_loop: 0xf09f, load_done: 0xf0eb,
+      file_not_found_exit: 0xf27c, missing_file_name_exit: 0xf288,
+      saving_message: 0xf228, clock_release: 0xe2b8, data_release: 0xe2c6, save_done: 0xf226,
+      talk: 0xedfa, listen: 0xee2c, second: 0xee4d, tksa: 0xee1a,
+      ciout: 0xecdf, untalk: 0xef3b, unlisten: 0xef23, acptr: 0xec8b,
+      banked: false, serial_timer: nil, serial_timer_start: nil,
+      atn_port: 0x01, atn_mask: 0xfb, clock_port: 0x01, clock_mask: 0xfd, data_port: 0x01, data_mask: 0xfe,
+      mmu: false, rom_select: true, zero_page: PLUS4_ZERO_PAGE
     )
   end
 end

data/lib/badline/kernal_trap/load.rb

@@ -31,8 +31,8 @@ module Badline
       def call
         return unless active?
 
-        @bus.poke(0x93, @cpu.a)
-        @bus.poke(0x90, 0x00)
+        @bus.poke(zero_page.verify, @cpu.a)
+        @bus.poke(zero_page.status, 0x00)
         name = filename
         return @cpu.program_counter = @layout.missing_file_name_exit if Storage.parse_name(name).first.empty?
 
@@ -66,17 +66,17 @@ module Badline
       # until RUN/STOP breaks the load, as on a real drive.
       def finish(data, complete)
         if data.empty?
-          @bus.poke(0x90, EOI | READ_TIMEOUT)
+          @bus.poke(zero_page.status, EOI | READ_TIMEOUT)
           leave_bus(ACPTR_TIMEOUT)
           continue_with(@layout.searching_message, @layout.file_not_found_exit)
         else
           deliver(data)
-          @bus.poke(0x90, @bus.peek(0x90) & ~EOI) unless complete
+          @bus.poke(zero_page.status, @bus.peek(zero_page.status) & ~EOI) unless complete
           leave_bus(ISOUR_TIMEOUT)
           continue_with(@layout.searching_message, @layout.loading_message,
                         complete ? @layout.load_done : @layout.load_byte_loop)
         end
-        @bus.poke(0xb9, LOAD_SECONDARY)
+        @bus.poke(zero_page.secondary_address, LOAD_SECONDARY)
       end
 
       # A load ends with the UNLISTEN that closes the file, a byte sent,
@@ -91,9 +91,9 @@ module Badline
         load? && data.length > 2 && load_address(data) < 0x0334
       end
 
-      # A=0 is LOAD, A=1 is VERIFY, kept at $93 (VERCK)
+      # A=0 is LOAD, A=1 is VERIFY, kept at VERCK
       def load?
-        @bus.peek(0x93).zero?
+        @bus.peek(zero_page.verify).zero?
       end
 
       def deliver(data)
@@ -102,25 +102,23 @@ module Badline
         payload = payload[0, 0x10000 - addr] if addr + payload.length > 0x10000
         if load?
           @layout.store_file(@bus, addr, payload)
-          @bus.poke(0x90, EOI)
+          @bus.poke(zero_page.status, EOI)
         else
           verify(addr, payload)
         end
-        end_addr = (addr + payload.length) & 0xffff
-        @bus.poke(0xae, low_byte(end_addr))
-        @bus.poke(0xaf, high_byte(end_addr))
+        poke_word(zero_page.end_address, (addr + payload.length) & 0xffff)
       end
 
       def verify(addr, payload)
         match = payload.each_with_index.all? { |byte, i| @layout.file_byte(@bus, addr + i) == byte }
-        @bus.poke(0x90, match ? EOI : EOI | VERIFY_MISMATCH)
+        @bus.poke(zero_page.status, match ? EOI : EOI | VERIFY_MISMATCH)
       end
 
-      # Secondary address $B9 zero relocates to the caller-supplied address
-      # stashed at $C3/$C4 (MEMUSS)
+      # Secondary address zero relocates to the caller-supplied address
+      # stashed at MEMUSS
       def load_address(data)
-        if @bus.peek(0xb9).zero?
-          uint16(@bus.peek(0xc3), @bus.peek(0xc4))
+        if @bus.peek(zero_page.secondary_address).zero?
+          peek_word(zero_page.load_address)
         else
           uint16(data[0], data[1].to_i)
         end

data/lib/badline/kernal_trap/routine.rb

@@ -26,6 +26,18 @@ module Badline
         @layout.kernal_mapped?(@bus)
       end
 
+      def zero_page = @layout.zero_page
+
+      # The two-byte value whose low byte is at +address+.
+      def peek_word(address)
+        uint16(@bus.peek(address), @bus.peek(address + 1))
+      end
+
+      def poke_word(address, value)
+        @bus.poke(address, low_byte(value))
+        @bus.poke(address + 1, high_byte(value))
+      end
+
       # The ROM times each byte on the serial bus with a one-shot timer
       # (Layout#time_serial_byte): ISOUR_TIMEOUT for a byte sent,
       # ACPTR_TIMEOUT for one received.

data/lib/badline/kernal_trap/save.rb

@@ -18,7 +18,7 @@ module Badline
     class Save < FileRoutine
       SECONDARY = 0x61
 
-      # ST bit at $90
+      # ST bit
       DEVICE_NOT_PRESENT = 0x80
 
       def initialize(cpu:, bus:, layout:, dos:)
@@ -27,23 +27,15 @@ module Badline
         @saving = false
       end
 
-      def save_state(out)
-        out.boolean(@saving)
-      end
-
-      def load_state(input)
-        @saving = input.boolean?
-      end
-
       def call
         return unless active?
         return finish if @saving
         return unless @dos.saves?
 
-        @bus.poke(0xb9, SECONDARY)
+        @bus.poke(zero_page.secondary_address, SECONDARY)
         return @cpu.program_counter = @layout.missing_file_name_exit if name.empty?
 
-        @bus.poke(0x90, 0x00)
+        @bus.poke(zero_page.status, 0x00)
         @saving = true
         continue_with(@layout.saving_message, @layout.save)
       end
@@ -57,19 +49,17 @@ module Badline
       def finish
         @saving = false
         saved = @dos.save(name, payload, replace: full_filename.start_with?("@"))
-        @bus.poke(0x90, DEVICE_NOT_PRESENT) unless saved
-        @bus.poke(0xac, @bus.peek(0xae))
-        @bus.poke(0xad, @bus.peek(0xaf))
+        @bus.poke(zero_page.status, DEVICE_NOT_PRESENT) unless saved
+        poke_word(zero_page.start_address, peek_word(zero_page.end_address))
         @cpu.y = 0
         @cpu.status.overflow = true
         continue_with(@layout.clock_release, @layout.data_release, @layout.save_done)
       end
 
-      # Start address at $C1/$C2 (STAL), end address (exclusive) at
-      # $AE/$AF (EAL)
+      # Start address at STAL, end address (exclusive) at EAL
       def payload
-        start = uint16(@bus.peek(0xc1), @bus.peek(0xc2))
-        length = (uint16(@bus.peek(0xae), @bus.peek(0xaf)) - start) & 0xffff
+        start = peek_word(zero_page.save_start)
+        length = (peek_word(zero_page.end_address) - start) & 0xffff
         [low_byte(start), high_byte(start)] +
           Array.new(length) { |i| @layout.file_byte(@bus, (start + i) & 0xffff) }
       end

data/lib/badline/kernal_trap/serial.rb

@@ -35,22 +35,6 @@ module Badline
         @buffer = []
       end
 
-      # The frame under way, with the channels and the bytes it gathered.
-      # The device it answers is the machine's to set.
-      def save_state(out)
-        out.boolean(@listening).boolean(@talking).optional_int(@listen_channel).optional_int(@talk_channel)
-        out.int(@frame).blob(@buffer)
-      end
-
-      def load_state(input)
-        @listening = input.boolean?
-        @talking = input.boolean?
-        @listen_channel = input.optional_int
-        @talk_channel = input.optional_int
-        @frame = input.int
-        @buffer = input.blob
-      end
-
       def install
         routines.each do |address, routine|
           @cpu.install_trap(address) { call_routine(routine) if kernal_mapped? }
@@ -205,7 +189,7 @@ module Badline
       def update_status(bits)
         return if bits.zero?
 
-        @bus.poke(0x90, @bus.peek(0x90) | bits)
+        @bus.poke(zero_page.status, @bus.peek(zero_page.status) | bits)
       end
     end
   end

data/lib/badline/kernal_trap.rb

@@ -7,3 +7,5 @@ require "badline/kernal_trap/file_routine"
 require "badline/kernal_trap/load"
 require "badline/kernal_trap/save"
 require "badline/kernal_trap/serial"
+require "badline/kernal_trap/chrout"
+require "badline/kernal_trap/keyed_state"

data/lib/badline/machine/keyboard_buffer.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Badline
+  module Machine
+    # Typing into the KERNAL's keyboard buffer once the machine has booted.
+    # The machine that includes it answers #keyboard_buffer, the Layout of
+    # the KERNAL it runs, and #ram.
+    module KeyboardBuffer
+      # Where a KERNAL keeps its keyboard buffer (KEYD), the count of
+      # characters in it (NDX), and how many it holds.
+      Layout = Data.define(:address, :count, :capacity)
+
+      # The C64's and the VIC-20's.
+      C64_LAYOUT = Layout.new(address: 0x0277, count: 0xc6, capacity: 10)
+
+      # BASIC 7.0's, in C128 mode.
+      C128_LAYOUT = Layout.new(address: 0x034a, count: 0xd0, capacity: 10)
+
+      # The 264 series KERNAL's, which sets its capacity at $053F to 10
+      # ($D86E).
+      PLUS4_LAYOUT = Layout.new(address: 0x0527, count: 0xef, capacity: 10)
+
+      def type_text(text)
+        codes = text.bytes.map { |b| ascii_to_petscii(b) }
+        on_init { @pending_keys = codes }
+      end
+
+      private
+
+      def feed_keyboard
+        buffer = keyboard_buffer
+        return unless ram.peek(buffer.count).zero?
+
+        chunk = @pending_keys.shift(buffer.capacity)
+        ram.write(buffer.address, chunk)
+        ram.poke(buffer.count, chunk.length)
+        @pending_keys = nil if @pending_keys.empty?
+      end
+
+      def ascii_to_petscii(byte)
+        case byte
+        when 0x61..0x7a then byte - 0x20
+        when 0x41..0x5a then byte + 0x80
+        else byte
+        end
+      end
+    end
+  end
+end

data/lib/badline/machine/settling.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Badline
+  module Machine
+    # Brings the machine to the point a snapshot file is saved at: the main
+    # CPU between instructions, or jammed, with no REU transfer holding the
+    # bus. C64, Vic20 and C128 each include it, and answer
+    # #settled_for_snapshot? and #settle_chips_for_snapshot, which brings
+    # what each chip defers up to the cycle without running one.
+    module Settling
+      # The cycles settling may run: the longest instruction stretched by
+      # the VIC's longest hold on the bus, and an REU swap of 64K, two
+      # cycles a byte, stretched the same way.
+      LIMIT = 100 + 0x40000
+
+      # Runs the machine on, through its own #cycle!, to the settle point,
+      # and returns the cycles that took. A settled machine runs none.
+      def settle_for_snapshot!
+        ran = 0
+        while ran < LIMIT && !settled_for_snapshot?
+          cycle!
+          ran += 1
+        end
+        settle_chips_for_snapshot
+        ran
+      end
+    end
+  end
+end

data/lib/badline/machine.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "badline/machine/clocking"
+require "badline/machine/keyboard_buffer"
+require "badline/machine/settling"
 
 module Badline
   # = Machine
@@ -58,10 +60,11 @@ module Badline
     # VIC-20's is "pal", with the RAM expansion `ram` names
     # (Vic20::Bus::RAM_CONFIGURATIONS), unexpanded when nil. A C128's is
     # one of C128::Model::ALL, with its SID `sid_model` when not nil, built
-    # for C64 mode.
+    # for C64 mode. :plus4 is refused until the Plus/4 runs.
     def self.build(family, model:, sid_model: nil, reu: nil, ram: nil)
       return vic20(model, ram) if family == :vic20
       return c128(model, sid_model, :c64) if family == :c128
+      raise ArgumentError, "the Plus/4 isn't emulated yet" if family == :plus4
       raise ArgumentError, "no machine family named #{family}" unless family == :c64
 
       profile = Model.named(model)
@@ -119,7 +122,7 @@ module Badline
 
       extension = File.extname(media).downcase
       return true if extension == ".sid"
-      return false unless %w[.prg .p00].include?(extension)
+      return false unless Media::Extensions::PROGRAMS.include?(extension)
 
       [Media::BASIC_START, Media::BASIC_START - 1].include?(Storage::P00.load_address(media))
     end

data/lib/badline/media/boot_disk.rb

@@ -4,7 +4,8 @@ module Badline
   module Media
     # A C128 boot disk. At power-on the C128 KERNAL reads track 1, sector 0
     # of the disk in device 8 and runs it when it starts with "CBM", as boot
-    # games have it. The 1581's DOS first loads and runs a USR file named
+    # games have it, from a sector image or from the raw GCR of a .g64 or
+    # .g71. The 1581's DOS first loads and runs a USR file named
     # COPYRIGHT CBM 86 when the disk has one, which is how CP/M's 1581 disks
     # hand the KERNAL their boot sector, so a .d81 with that file boots too.
     #
@@ -15,7 +16,7 @@ module Badline
     module BootDisk
       SIGNATURE = "CBM".bytes.freeze
       AUTO_BOOT = "copyright cbm 86"
-      TYPES = Extensions.of(%i[disk])
+      TYPES = Extensions.of(%i[disk gcr])
 
       class << self
         def takes?(computer, path)
@@ -37,6 +38,7 @@ module Badline
         def boot?(path)
           type = File.extname(path).downcase
           return false unless TYPES.include?(type) && File.file?(path)
+          return gcr_signature(path) == SIGNATURE if Extensions.kind(path) == :gcr
 
           image = Media.open_storage(path, { read_only: true })
           block = image.read_block(1, 0)
@@ -44,6 +46,16 @@ module Badline
 
           type == ".d81" && !image.read_file(AUTO_BOOT, type: :usr).nil?
         end
+
+        private
+
+        # The first three bytes of track 1, sector 0 as the drive reads them
+        # off the GCR of a .g64 or .g71, or nil when the sector isn't there.
+        def gcr_signature(path)
+          track = Drives::Model1541::Disk.open(path, read_only: true).track(2)
+          data = track && Drives::Model1541::SectorReader.read(track.bytes, 1)[0]&.data
+          data && data[1, 3]
+        end
       end
     end
   end

data/lib/badline/media/extensions.rb

@@ -28,6 +28,16 @@ module Badline
 
       # What goes in device 8 through the traps.
       MOUNTABLE = of(%i[disk archive])
+
+      # What goes in device 8, a true drive's or the traps', and the lists
+      # of disks to put there.
+      DEVICE8 = of(%i[disk gcr archive disk_list])
+
+      # Programs, which load on their own.
+      PROGRAMS = %w[.prg .p00].freeze
+
+      # Every medium Media.attach takes by its extension.
+      ALL = (KINDS.keys + PROGRAMS).freeze
     end
   end
 end

data/lib/badline/memory.rb

@@ -29,13 +29,10 @@ module Badline
       Array(bytes).each_with_index { |b, i| poke(addr + i, b) }
     end
 
-    def save_state(out)
-      out.blob(@storage)
-    end
+    # Every byte as one record of a keyed snapshot module, under `key`.
+    def save_fields(out, key) = out.bytes(key, @storage)
 
-    def load_state(input)
-      input.blob_into(@storage)
-    end
+    def load_fields(input, key) = input.bytes_into(key, @storage)
 
     # Refills the whole memory as if newly built with `initial`
     def clear!(initial = [])

data/lib/badline/options/family.rb

@@ -12,13 +12,14 @@ module Badline
 
       private
 
-      # Takes `sid`, `c64`, `vic20` or `c128` when given first.
+      # Takes `sid`, `c64`, `vic20`, `c128` or `plus4` when given first.
       def subcommand(args)
         case args.first
         when "sid" then @sid_command = true
         when "c64" then @family = :c64
         when "vic20" then @family = :vic20
         when "c128" then @family = :c128
+        when "plus4" then @family = :plus4
         else return
         end
         @family_named = !@sid_command
@@ -37,7 +38,9 @@ module Badline
       # the C128's.
       def pick_family
         return if @family_named || @sid_command || @media_path.nil?
-        return unless %w[.prg .p00].include?(File.extname(@media_path).downcase) && File.file?(@media_path)
+
+        program = Media::Extensions::PROGRAMS.include?(File.extname(@media_path).downcase)
+        return unless program && File.file?(@media_path)
 
         @family = :c128 if Storage::P00.load_address(@media_path) == C128_BASIC_START
       end

data/lib/badline/options/help.rb

@@ -35,6 +35,34 @@ module Badline
 
     def describe(option) = @native && option.name == "--sound" ? "#{option.text} (default)" : option.text
 
+    # The media the window opens, by their extensions (Media::Extensions),
+    # wrapped as the banner is.
+    def media_kinds
+      text = "Media can be a #{Media::Extensions::PROGRAMS.join('/')} program, a #{listed(%i[disk])} disk image, " \
+             "a #{listed(%i[gcr])} disk image for a true drive, an #{listed(%i[disk_list])} list of disk images, " \
+             "a #{listed(%i[archive])} tape archive, a #{listed(%i[tape])} tape, a #{listed(%i[cartridge])} " \
+             "cartridge, a #{listed(%i[tune])} tune, a .vsf snapshot, or a directory to mount as device 8."
+      wrap(text)
+    end
+
+    def listed(kinds) = Media::Extensions.of(kinds).join("/")
+
+    # The words of `text` in lines of at most 70 characters.
+    def wrap(text)
+      lines = [""]
+      text.split.each do |word|
+        line = lines.last
+        if line.empty?
+          lines[-1] = word
+        elsif line.size + word.size < 70
+          lines[-1] = "#{line} #{word}"
+        else
+          lines << word
+        end
+      end
+      lines.join("\n")
+    end
+
     def banner
       <<~BANNER
         Usage: #{@program} [c64] [options] [media]
@@ -50,11 +78,8 @@ module Badline
             c128                             Run a C128 in C128 mode, the one --model names
             sid                              Play .sid tunes and directories of them
 
-        Media can be a .prg/.p00 program, a .d64/.d71/.d81 disk image, a
-        .g64 disk image for the true 1541, an .m3u or .vfl list of disk
-        images, a .t64 tape archive, a .tap tape, a .crt cartridge, a .sid
-        tune, a .vsf snapshot, or a directory to mount as device 8. It
-        opens in the emulator window. There F11 quicksaves the machine to
+        #{media_kinds}
+        It opens in the emulator window. There F11 quicksaves the machine to
         the next of five slots in badline's data folder, replacing the
         oldest, and F12 restores the newest quicksave or named save. The
         window also autosaves every two minutes of play, which only the
@@ -85,17 +110,18 @@ module Badline
 
         --at and --script run events once a number of frames has run, as
         in --at 3500:key=space or --at 250,500:screenshot=shot%05d.bmp.
-        key=NAME presses a C64 key (space, return, a, f1, run_stop, restore)
-        or a joystick's direction or fire (joy1-up, joy2-fire) for #{Event::HOLD}
-        frames. type=TEXT types it, with \\n for RETURN. 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, and menu=PAGE opens it on snapshots, drive,
-        datasette, expansion, ports, sound or power. Its frames still count,
-        and resume closes it. display=vdc or display=vic shows the C128's
-        80 or 40 column screen, as F8 switches them. reset, freeze and quit
-        take no argument.
+        key=NAME presses a key (space, return, a, f1, run_stop, restore, and
+        on the C128 esc, help, keypad1 and the rest) 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
+        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,
+        and menu=PAGE opens it on snapshots, drive, datasette, expansion,
+        ports, sound or power. Its frames still count, and resume closes
+        it. display=vdc or display=vic shows the C128's 80 or 40 column
+        screen, as F8 switches them. reset, freeze and quit take no argument.
       BANNER
     end
 

data/lib/badline/options/table.rb

@@ -75,6 +75,8 @@ module Badline
                  section: "Testing options", needs: :window),
       Option.new("--save-snapshot FILE", "Save the machine as a .vsf snapshot after the last frame",
                  section: "Testing options", needs: :window),
+      Option.new("--vice", "Add VICE's modules to --save-snapshot's C64 snapshot, for x64sc",
+                 section: "Testing options", needs: :window),
       Option.new("--at FRAME:EVENT", "Run EVENT once FRAME frames have run (see above)",
                  section: "Testing options", needs: :window),
       Option.new("--script FILE", "Run the events in FILE, one FRAME:EVENT a line",

data/lib/badline/options/validation.rb

@@ -59,6 +59,8 @@ module Badline
       end
 
       def validate_family
+        raise Error, "the Plus/4 isn't emulated yet" if @family == :plus4
+
         if @family == :vic20
           validate_vic20
         elsif !@ram.nil?