badline 0.12.0 → 0.13.0

data/lib/badline/media/program.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # A program loading into a C64 or a C128 once it has booted
+    # (Media.attach). The VIC-20 has its own (Vic20Basic).
+    module Program
+      class << self
+        # Loads the program where it says, and RUNs one that loads at the
+        # start of BASIC.
+        def load(computer, data, autostart:)
+          load_addr = computer.load_prg(data)
+          # Run only makes sense for programs at BASIC start, or a byte ahead
+          # of it, where BASIC keeps the zero before its first line. BASIC 7.0
+          # starts at $1C01 and keeps the end of its text at $1210.
+          start, text_end = computer.family == :c128 && computer.mode == :c128 ? [0x1c01, 0x1210] : [BASIC_START, 0x2d]
+          return unless autostart && (load_addr == start || load_addr == start - 1)
+
+          # The end of the program, where BASIC's variables start, and where
+          # the KERNAL's LOAD leaves its end address.
+          end_addr = load_addr + data.length - 2
+          [text_end, 0xae].each { |pointer| computer.ram.write(pointer, [end_addr & 0xff, end_addr >> 8]) }
+          computer.type_text("run\r")
+        end
+      end
+    end
+  end
+end

data/lib/badline/media/true_drive.rb

@@ -9,7 +9,7 @@ module Badline
     # 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 (Drive1581::Slot), and another disk
+    # 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 traps' other
     # disk media, a .t64 or a host directory, raise Error.
     module TrueDrive
@@ -32,9 +32,10 @@ module Badline
         # other disk media, which the traps would mount, when a true drive
         # is device 8.
         def takes?(computer, path)
-          return true if %w[.g64 .g71].include?(File.extname(path).downcase)
+          kind = Extensions.kind(path)
+          return true if kind == :gcr
 
-          !drive(computer).nil? && (File.directory?(path) || MOUNT_TYPES.key?(File.extname(path).downcase))
+          !drive(computer).nil? && (File.directory?(path) || %i[disk archive].include?(kind))
         end
 
         # Puts the image in the drive on device 8, plugging one in that

data/lib/badline/media/tune.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # A .sid tune on a machine with a SID (Media.attach): its data and the
+    # player the tune boots with go in RAM once the KERNAL has booted, and
+    # the autostart types what starts it.
+    module Tune
+      class << self
+        # Plays `subtune`, or the tune's own start subtune, and says what
+        # plays. A tune for more than one SID raises FormatError.
+        def attach(computer, path, autostart:, subtune:)
+          tune = SIDTune::File.new(path)
+          if tune.sids > 1
+            raise SIDTune::File::FormatError, "Written for #{tune.sids} SIDs, which only the SID player plays"
+          end
+
+          subtune = (subtune || tune.start_subtune).clamp(1, tune.subtunes)
+          computer.on_init { start(computer, tune, autostart:, subtune:) }
+          title = tune.name.empty? ? path : tune.name
+          title += " (subtune #{subtune})" if tune.subtunes > 1
+          autostart ? "Playing #{title}" : "Loaded #{title}"
+        end
+
+        private
+
+        def start(computer, tune, autostart:, subtune:)
+          computer.ram.write(tune.load_address, tune.data)
+          tune.boot_memory(subtune:).each { |address, bytes| computer.ram.write(address, bytes) }
+          computer.type_text(tune.boot_command) if autostart
+        end
+      end
+    end
+  end
+end

data/lib/badline/media/vic20_cartridge.rb

@@ -26,12 +26,6 @@ module Badline
           parts.map { |part| rom_chip(part) }
         end
 
-        # A program's bytes, unwrapped from a .p00.
-        def program_bytes(path)
-          bytes = File.binread(path).bytes
-          Storage::P00.wraps?(bytes) ? Storage::P00.data(bytes) : bytes
-        end
-
         private
 
         def load_address(data)
@@ -42,7 +36,7 @@ module Badline
           name = part_names(path, own, address).find { |candidate| File.file?(candidate) }
           return unless name
 
-          part = program_bytes(name)
+          part = Media.program_bytes(name)
           part if load_address(part) == address
         end
 

data/lib/badline/media/vic20_media.rb

@@ -2,45 +2,25 @@
 
 module Badline
   module Media
-    # Media on a VIC-20. A program loads once the KERNAL has booted: a
-    # BASIC program at the start of BASIC, wherever the RAM puts it, and
-    # RUNs. A program that loads into BLK5 at $A000 is a cartridge's ROM
-    # instead, as are the parts of a set that includes one
-    # (Vic20Cartridge), and goes in with a power cycle, as a .crt does.
-    # Disks mount on device 8 through the KERNAL traps, or go in a true
-    # 1541 (TrueDrive), and tapes play on the datasette.
+    # What a VIC-20 does with media of its own (Media.attach). A program
+    # loads once the KERNAL has booted: a BASIC program at the start of
+    # BASIC, wherever the RAM puts it, and RUNs. A program that loads into
+    # BLK5 at $A000 is a cartridge's ROM instead, as are the parts of a set
+    # that includes one (Vic20Cartridge), and goes in with a power cycle,
+    # as a .crt does. Disks mount on device 8 through the KERNAL traps, or
+    # go in a true 1541 (TrueDrive), and tapes play on the datasette.
     module Vic20Media
       # The expansions that fill BLK1, BLK2 and BLK3 one block after
       # another, each with the last address it fills.
       BLOCK_EXPANSIONS = [[0x3fff, :"8k"], [0x5fff, :"16k"], [0x7fff, :"24k"]].freeze
 
       # What a VIC-20 doesn't take.
-      UNSUPPORTED = %w[.sid].freeze
+      UNSUPPORTED = Extensions.of(%i[tune])
 
       # The platform byte of a VIC-20 tape (Storage::TAP#platform).
       TAPE_PLATFORM = 1
 
       class << self
-        def attach(machine, path, autostart:, **options)
-          extension = File.extname(path).downcase
-          raise ArgumentError, "#{path} doesn't go in a VIC-20" if UNSUPPORTED.include?(extension)
-
-          if TrueDrive.takes?(machine, path)
-            attach_true_drive(machine, path, options.fetch(:disk, {}), autostart:)
-          elsif File.directory?(path)
-            machine.mount(Storage::HostDirectory.new(path))
-            "Mounted #{path} as device 8"
-          elsif extension == ".crt"
-            attach_cartridge(machine, path, Storage::CRTFile.new(path, machine: :vic20).chips)
-          elsif extension == ".tap"
-            attach_tape(machine, path, autostart:)
-          elsif MOUNT_TYPES.key?(extension)
-            attach_storage(machine, path, options.fetch(:disk, {}), autostart:)
-          else
-            attach_prg(machine, path, autostart:)
-          end
-        end
-
         # The RAM expansion (Vic20::Bus::RAM_CONFIGURATIONS) a VIC-20 needs
         # for the program at `path`, or for the first program on the disk
         # or in the directory there, by where it loads. A BASIC program
@@ -60,72 +40,50 @@ module Badline
           end
         end
 
-        private
-
-        def expansion_reaching(last)
-          BLOCK_EXPANSIONS.each { |reach, ram| return ram if last <= reach }
-          BLOCK_EXPANSIONS.last.last
-        end
-
+        # The program at `path`, or the first on the disk or in the
+        # directory there, or nil.
         def first_program(path)
-          extension = File.extname(path).downcase
-          if File.directory?(path) || MOUNT_TYPES.key?(extension)
-            open_storage(path).read_file("*")
-          elsif File.file?(path) && !%w[.sid .crt .tap .g64].include?(extension)
-            Vic20Cartridge.program_bytes(path)
+          kind = Extensions.kind(path)
+          if File.directory?(path) || %i[disk archive].include?(kind)
+            Media.open_storage(path).read_file("*")
+          elsif File.file?(path) && !%i[tune cartridge tape gcr].include?(kind)
+            Media.program_bytes(path)
           end
         end
 
-        def open_storage(path, disk = {})
-          return Storage::HostDirectory.new(path) if File.directory?(path)
-
-          storage = MOUNT_TYPES.fetch(File.extname(path).downcase)
-          storage < Storage::DiskImage ? storage.new(path, **disk) : storage.new(path)
-        end
-
-        def attach_cartridge(machine, path, chips)
-          machine.attach_cartridge(chips)
-          "Attached cartridge #{path}"
-        end
-
-        # A tape made for another machine plays all the same, and says so.
-        def attach_tape(machine, path, autostart:)
-          tape = Storage::TAP.new(path)
-          machine.datasette.insert(tape)
-          machine.datasette.play!
-          machine.type_text(TAPE_AUTOSTART) if autostart
-          message = "Inserted #{path} in the datasette"
-          tape.platform == TAPE_PLATFORM ? message : "#{message}, a tape for another machine than the VIC-20"
-        end
-
-        def attach_true_drive(machine, path, disk, autostart:)
-          message = TrueDrive.insert(machine, path, read_only: disk.fetch(:read_only, false))
-          machine.type_text(disk_autostart(first_program(path))) if autostart
-          message
-        end
-
-        def attach_storage(machine, path, disk, autostart:)
-          storage = open_storage(path, disk)
-          machine.mount(storage)
-          machine.type_text(disk_autostart(storage.read_file("*"))) if autostart
-          "Mounted #{path} as device 8"
-        end
-
-        # A BASIC program loads relocated to the start of BASIC, and anything
-        # else where it says.
+        # What loads and runs `data`, the first program on the disk in
+        # device 8: a BASIC program loads relocated to the start of BASIC,
+        # and anything else where it says.
         def disk_autostart(data)
           basic = data && data.length > 2 && Vic20Basic::BASIC_STARTS.key?(data[0] | (data[1] << 8))
           basic ? %(lO"*",8\rrun\r) : AUTOSTART
         end
 
-        def attach_prg(machine, path, autostart:)
-          bytes = Vic20Cartridge.program_bytes(path)
+        # Loads the program, `bytes` from the file at `path`, as Vic20Basic
+        # has it once the KERNAL has booted, or attaches the cartridge it's
+        # a part of (Vic20Cartridge), and says which.
+        def attach_program(machine, path, bytes, autostart:)
           chips = Vic20Cartridge.chips(path, bytes)
-          return attach_cartridge(machine, path, chips) if chips
+          if chips
+            machine.attach_cartridge(chips)
+            return "Attached cartridge #{path}"
+          end
 
           machine.on_init { Vic20Basic.load_program(machine, bytes, autostart:) }
           "Loading #{path}"
         end
+
+        # A tape made for another machine plays all the same, and says so.
+        def tape_message(tape, message)
+          tape.platform == TAPE_PLATFORM ? message : "#{message}, a tape for another machine than the VIC-20"
+        end
+
+        private
+
+        def expansion_reaching(last)
+          BLOCK_EXPANSIONS.each { |reach, ram| return ram if last <= reach }
+          BLOCK_EXPANSIONS.last.last
+        end
       end
     end
   end

data/lib/badline/media.rb

@@ -1,14 +1,17 @@
 # frozen_string_literal: true
 
+require "badline/media/extensions"
 require "badline/media/true_drive"
 require "badline/media/boot_disk"
 require "badline/media/not_disk"
-require "badline/media/queue"
+require "badline/audio/queue"
 require "badline/media/disk_set"
 require "badline/media/disk_list"
 require "badline/media/vic20_basic"
 require "badline/media/vic20_cartridge"
 require "badline/media/vic20_media"
+require "badline/media/tune"
+require "badline/media/program"
 
 module Badline
   module Media
@@ -16,6 +19,7 @@ module Badline
     TAPE_AUTOSTART = %(lO\rrun\r)
     BASIC_START = 0x0801
 
+    # The storage that opens each of Extensions::MOUNTABLE.
     MOUNT_TYPES = {
       ".d64" => Storage::D64Image,
       ".d71" => Storage::D71Image,
@@ -38,13 +42,17 @@ module Badline
       # KERNAL to boot at power-on, with nothing typed (BootDisk).
       #
       # An .m3u or .vfl list of disks attaches the first disk it lists
-      # (DiskList). The VIC-20 takes its own media (Vic20Media), and the
-      # C128 in C64 mode a C64's.
+      # (DiskList). Every machine takes each kind of medium the same way,
+      # except that the VIC-20 (Vic20Media) has cartridges, programs and a
+      # disk autostart of its own, and takes no .sid tunes. The C128 in C64
+      # mode takes a C64's.
       def attach(computer, path, autostart: true, subtune: nil, **)
         path = DiskList.disk(path)
-        return Vic20Media.attach(computer, path, autostart:, **) if computer.family == :vic20
+        if computer.family == :vic20 && Vic20Media::UNSUPPORTED.include?(File.extname(path).downcase)
+          raise ArgumentError, "#{path} doesn't go in a VIC-20"
+        end
 
-        BootDisk.attach(computer, path, **) || attach_c64(computer, path, autostart:, subtune:, **)
+        BootDisk.attach(computer, path, **) || attach_kind(computer, path, autostart:, subtune:, **)
       end
 
       # Swaps the disk in device 8 for a disk image or a host directory,
@@ -73,109 +81,104 @@ module Badline
       # The SID a machine for `path` should be built with. A .sid tune names
       # its own; everything else gets `otherwise`.
       def sid_model(path, otherwise: :mos6581)
-        return otherwise unless path && File.extname(path).downcase == ".sid"
+        return otherwise unless path && Extensions.kind(path) == :tune
 
-        Storage::SIDFile.new(path).sid_model
+        SIDTune::File.new(path).sid_model
       end
 
-      private
+      # What the medium at `path` is to `computer`, which attach goes by:
+      # :true_drive for a disk that goes in a true drive (TrueDrive),
+      # :directory, :storage for a disk image or a .t64 that the traps
+      # mount, and otherwise its kind by its extension (Extensions).
+      def kind(computer, path)
+        return :true_drive if TrueDrive.takes?(computer, path)
+        return :directory if File.directory?(path)
 
-      def attach_c64(computer, path, autostart:, subtune:, **options)
-        if TrueDrive.takes?(computer, path)
-          attach_true_drive(computer, path, options.fetch(:disk, {}), autostart:)
-        elsif File.directory?(path)
-          computer.mount(Storage::HostDirectory.new(path))
-          "Mounted #{path} as device 8"
-        elsif File.extname(path).downcase == ".crt"
-          attach_cartridge(computer, path, options.fetch(:cartridge, {}))
-        elsif File.extname(path).downcase == ".sid"
-          attach_sid(computer, path, autostart:, subtune:)
-        elsif File.extname(path).downcase == ".tap"
-          attach_tape(computer, path, autostart:)
-        elsif MOUNT_TYPES.key?(File.extname(path).downcase)
-          attach_storage(computer, path, options.fetch(:disk, {}), autostart:)
-        else
-          attach_prg(computer, path, autostart:)
-        end
+        kind = Extensions.kind(path)
+        %i[disk archive].include?(kind) ? :storage : kind
       end
 
-      def disk?(path)
-        storage = MOUNT_TYPES[File.extname(path).downcase]
-        File.directory?(path) || (!storage.nil? && storage < Storage::DiskImage)
-      end
-
-      # Disk images take the `disk` options. A .t64 is read-only whatever
-      # it's given.
-      def open_storage(path, disk)
+      # What device 8 serves through the traps for a host directory, a disk
+      # image or a .t64. Disk images take the `disk` options. A .t64 is
+      # read-only whatever it's given.
+      def open_storage(path, disk = {})
         return Storage::HostDirectory.new(path) if File.directory?(path)
 
-        storage = MOUNT_TYPES[File.extname(path).downcase]
+        storage = MOUNT_TYPES.fetch(File.extname(path).downcase)
         storage < Storage::DiskImage ? storage.new(path, **disk) : storage.new(path)
       end
 
-      def attach_cartridge(computer, path, options)
-        computer.attach_cartridge(Cartridge.from_file(path, **options))
-        "Attached cartridge #{path}"
+      # A program file's bytes, unwrapped from a .p00.
+      def program_bytes(path)
+        bytes = File.binread(path).bytes
+        Storage::P00.wraps?(bytes) ? Storage::P00.data(bytes) : bytes
       end
 
-      def attach_sid(computer, path, autostart:, subtune:)
-        tune = Storage::SIDFile.new(path)
-        if tune.sids > 1
-          raise Storage::SIDFile::FormatError, "Written for #{tune.sids} SIDs, which only the SID player plays"
-        end
-
-        subtune = (subtune || tune.start_subtune).clamp(1, tune.subtunes)
-        computer.on_init { start_tune(computer, tune, autostart:, subtune:) }
-        title = tune.name.empty? ? path : tune.name
-        title += " (subtune #{subtune})" if tune.subtunes > 1
-        autostart ? "Playing #{title}" : "Loaded #{title}"
-      end
+      private
 
-      def start_tune(computer, tune, autostart:, subtune:)
-        computer.ram.write(tune.load_address, tune.data)
-        tune.boot_memory(subtune:).each { |address, bytes| computer.ram.write(address, bytes) }
-        computer.type_text(tune.boot_command) if autostart
+      def attach_kind(computer, path, autostart:, subtune:, **options)
+        disk = options.fetch(:disk, {})
+        case kind(computer, path)
+        when :true_drive then attach_true_drive(computer, path, disk, autostart:)
+        when :directory then mount(computer, path, disk, autostart: false)
+        when :storage then mount(computer, path, disk, autostart:)
+        when :cartridge then attach_cartridge(computer, path, options.fetch(:cartridge, {}))
+        when :tune then Tune.attach(computer, path, autostart:, subtune:)
+        when :tape then attach_tape(computer, path, autostart:)
+        else attach_prg(computer, path, autostart:)
+        end
       end
 
-      def attach_tape(computer, path, autostart:)
-        computer.datasette.insert(Storage::TAP.new(path))
-        computer.datasette.play!
-        computer.type_text(TAPE_AUTOSTART) if autostart
-        "Inserted #{path} in the datasette"
-      end
+      def disk?(path) = File.directory?(path) || Extensions.kind(path) == :disk
 
       def attach_true_drive(computer, path, disk, autostart:)
         message = TrueDrive.insert(computer, path, read_only: disk.fetch(:read_only, false))
-        computer.type_text(AUTOSTART) if autostart
+        computer.type_text(disk_autostart(computer) { Vic20Media.first_program(path) }) if autostart
         message
       end
 
-      def attach_storage(computer, path, disk, autostart:)
-        computer.mount(open_storage(path, disk))
-        computer.type_text(AUTOSTART) if autostart
+      def mount(computer, path, disk, autostart:)
+        storage = open_storage(path, disk)
+        computer.mount(storage)
+        computer.type_text(disk_autostart(computer) { storage.read_file("*") }) if autostart
         "Mounted #{path} as device 8"
       end
 
-      def attach_prg(computer, path, autostart:)
-        bytes = File.binread(path).bytes
-        bytes = Storage::P00.data(bytes) if Storage::P00.wraps?(bytes)
-        computer.on_init { start_prg(computer, bytes, autostart:) }
-        "Loading #{path}"
+      # What loads and runs the first program on the disk in device 8. A
+      # VIC-20 goes by that program, which the block gives
+      # (Vic20Media.disk_autostart).
+      def disk_autostart(computer)
+        computer.family == :vic20 ? Vic20Media.disk_autostart(yield) : AUTOSTART
+      end
+
+      # A VIC-20 cartridge is its ROM chips.
+      def attach_cartridge(computer, path, options)
+        if computer.family == :vic20
+          computer.attach_cartridge(Storage::CRTFile.new(path, machine: :vic20).chips)
+        else
+          computer.attach_cartridge(C64::Cartridge.from_file(path, **options))
+        end
+        "Attached cartridge #{path}"
       end
 
-      def start_prg(computer, data, autostart:)
-        load_addr = computer.load_prg(data)
-        # Run only makes sense for programs at BASIC start, or a byte ahead
-        # of it, where BASIC keeps the zero before its first line. BASIC 7.0
-        # starts at $1C01 and keeps the end of its text at $1210.
-        start, text_end = computer.family == :c128 && computer.mode == :c128 ? [0x1c01, 0x1210] : [BASIC_START, 0x2d]
-        return unless autostart && (load_addr == start || load_addr == start - 1)
-
-        # The end of the program, where BASIC's variables start, and where
-        # the KERNAL's LOAD leaves its end address.
-        end_addr = load_addr + data.length - 2
-        [text_end, 0xae].each { |pointer| computer.ram.write(pointer, [end_addr & 0xff, end_addr >> 8]) }
-        computer.type_text("run\r")
+      # A VIC-20 says when the tape was made for another machine
+      # (Vic20Media.tape_message).
+      def attach_tape(computer, path, autostart:)
+        tape = Storage::TAP.new(path)
+        computer.datasette.insert(tape)
+        computer.datasette.play!
+        computer.type_text(TAPE_AUTOSTART) if autostart
+        message = "Inserted #{path} in the datasette"
+        computer.family == :vic20 ? Vic20Media.tape_message(tape, message) : message
+      end
+
+      # A VIC-20 has programs of its own (Vic20Media.attach_program).
+      def attach_prg(computer, path, autostart:)
+        bytes = program_bytes(path)
+        return Vic20Media.attach_program(computer, path, bytes, autostart:) if computer.family == :vic20
+
+        computer.on_init { Program.load(computer, bytes, autostart:) }
+        "Loading #{path}"
       end
     end
   end

data/lib/badline/model.rb

@@ -7,7 +7,7 @@ module Badline
   # each was sold with, its video standard, its KERNAL and whether it has
   # a datasette. The names are x64sc's.
   module Model
-    # Each field but the name is a keyword Computer.new takes.
+    # Each field but the name is a keyword C64.new takes.
     Profile = Data.define(:name, :vic_model, :cia_model, :sid_model, :region, :kernal, :datasette, :board)
 
     # The breadbin PAL C64: the 6569 VIC-II, 6526 CIAs and the 6581 SID.

data/lib/badline/options/event.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "badline/media/extensions"
+
 module Badline
   class Options
     # One event of --at or --script: what to do, with its argument, once
@@ -23,7 +25,7 @@ module Badline
 
       # What insert takes: disk images, tapes and cartridges, or an .m3u
       # or .vfl list of disks or a directory to mount as device 8.
-      INSERTABLE = %w[.d64 .d71 .d81 .g64 .t64 .tap .crt .m3u .vfl].freeze
+      INSERTABLE = Media::Extensions.of(%i[disk gcr archive tape cartridge disk_list])
 
       attr_reader :frame, :action, :argument
 

data/lib/badline/roms/README

@@ -20,7 +20,7 @@ The character generator ROM.
 kernal-sx64.rom
 ---------------
 The SX-64's KERNAL, 251104-04. It boots with the SX-64's banner and
-colours, and loads from device 8 rather than tape. Computer.new(kernal:
+colours, and loads from device 8 rather than tape. C64.new(kernal:
 :sx64) fits it, as --model sx64 does.
 
 Downloaded from
@@ -32,7 +32,7 @@ kernal-pet64.rom
 The KERNAL of the PET 64, 4064 and Educator 64, 901246-01. It boots
 with the "**** COMMODORE 4064  BASIC V2.0 ****" banner and a white
 cursor, and its interrupt routine keeps the border, background and
-sprite colours black unless bit 7 of $0286 is set. Computer.new(kernal:
+sprite colours black unless bit 7 of $0286 is set. C64.new(kernal:
 :pet64) fits it, as --model pet64 does.
 
 Downloaded from
@@ -45,7 +45,7 @@ The C64GS's BASIC and KERNAL, 390852-01, 16 KB: BASIC for $A000-$BFFF
 followed by the KERNAL for $E000-$FFFF. Its BASIC is 901226-01's but
 for 30 unused bytes. Its KERNAL is 901227-03's with most changes in
 $F72C-$FC92, the cassette routines' place, and many jumps redirected to
-I/O error 5. Computer.new(kernal: :gs) fits both, as --model c64gs does.
+I/O error 5. C64.new(kernal: :gs) fits both, as --model c64gs does.
 
 Downloaded from
 https://www.zimmers.net/anonftp/pub/cbm/firmware/computers/c64/64gs.390852-01.bin
@@ -54,7 +54,7 @@ MD5 049e657afafbdd802e8c6a4f88f3d730.
 dos1541.rom
 -----------
 The 1541 disk drive's DOS 2.6, 16 KB for $C000-$FFFF: 325302-01
-($C000-$DFFF) followed by 901229-05 ($E000-$FFFF). Drive1541 loads it.
+($C000-$DFFF) followed by 901229-05 ($E000-$FFFF). Drives::Model1541 loads it.
 
 Both halves downloaded from
 https://www.zimmers.net/anonftp/pub/cbm/firmware/drives/new/1541/
@@ -64,7 +64,7 @@ SHA-1 ab16f56989b27d89babe5f89c5a8cb3da71a82f0.
 dos1571.rom
 -----------
 The 1571 disk drive's DOS 3.0, 310654-05, 32 KB for $8000-$FFFF.
-Drive1571 loads it.
+Drives::Model1571 loads it.
 
 Downloaded from
 https://www.zimmers.net/anonftp/pub/cbm/firmware/drives/new/1571/1571-rom.310654-05.bin
@@ -73,7 +73,7 @@ SHA-1 f1be619c106641a685f6609e4d43d6fc9eac1e70.
 dos1581.rom
 -----------
 The 1581 disk drive's DOS, 318045-02, 32 KB for $8000-$FFFF.
-Drive1581 loads it.
+Drives::Model1581 loads it.
 
 Downloaded from
 https://www.zimmers.net/anonftp/pub/cbm/firmware/drives/new/1581/1581-rom.318045-02.bin

data/lib/badline/sdl.rb

@@ -58,6 +58,7 @@ module Badline
     ffi_func :SDL_ClearQueuedAudio, [:uint32], :void
     ffi_func :SDL_PushEvent, [:ptr], :int
     ffi_func :SDL_GetKeyName, [:int], :str
+    ffi_func :SDL_StopTextInput, [], :void
 
     ffi_buffer :rect, 16
     ffi_write_i32 :rect_x, 0

data/lib/badline/{storage/sid_file.rb → sid_tune/file.rb}

@@ -3,10 +3,10 @@
 require "digest"
 
 module Badline
-  module Storage
+  module SIDTune
     # PSID/RSID tunes: a memory image plus the addresses of the routines
     # that initialise it and produce one frame of music.
-    class SIDFile
+    class File
       include IntegerHelper
 
       class FormatError < StandardError; end
@@ -147,7 +147,7 @@ module Badline
       attr_reader :format
 
       def initialize(path)
-        @bytes = File.binread(path).bytes
+        @bytes = ::File.binread(path).bytes
         @format = @bytes[0, 4].pack("C*")
         raise FormatError, "Missing PSID or RSID signature" unless %w[PSID RSID].include?(@format)
         raise FormatError, "Truncated header" if truncated?

data/lib/badline/{storage → sid_tune}/hvsc.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Badline
-  module Storage
+  module SIDTune
     # The layout of an HVSC collection: tunes in directories under its root,
     # and databases about them in `DOCUMENTS`. A tune's HVSC path is its path
     # from the root, as `/MUSICIANS/H/Hubbard_Rob/Commando.sid`.
@@ -10,15 +10,15 @@ module Badline
         # The named file in the DOCUMENTS directory of a collection above the
         # tune, or else of the one `$HVSC_BASE` points at.
         def document(tune_path, name)
-          candidates(tune_path).map { |dir| File.join(dir, "DOCUMENTS", name) }
-                               .find { |path| File.file?(path) }
+          candidates(tune_path).map { |dir| ::File.join(dir, "DOCUMENTS", name) }
+                               .find { |path| ::File.file?(path) }
         end
 
         # The tune's HVSC path in the collection that holds the document, or
         # nil when the tune lies outside it.
         def path(tune_path, document)
-          root = File.dirname(File.expand_path(document), 2)
-          tune = File.expand_path(tune_path)
+          root = ::File.dirname(::File.expand_path(document), 2)
+          tune = ::File.expand_path(tune_path)
           tune.start_with?("#{root}/") ? tune[root.length..] : nil
         end
 
@@ -26,10 +26,10 @@ module Badline
 
         def candidates(tune_path)
           dirs = []
-          dir = File.dirname(File.expand_path(tune_path))
+          dir = ::File.dirname(::File.expand_path(tune_path))
           until dirs.last == dir
             dirs << dir
-            dir = File.dirname(dir)
+            dir = ::File.dirname(dir)
           end
           base = ENV.fetch("HVSC_BASE", nil)
           dirs << base if base