badline 0.13.0 → 0.15.0

data/lib/badline/drives/model1581/keyed_state.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1581
+      class WD1772
+        PHASE_NAMES = %w[idle spin_up stepped settled search read_data write_gate write_data read_track track_index
+                         write_track motor_idle index_interrupt settle_search read_address write_track_start
+                         starting].freeze
+        MODE_NAMES = %w[read write address verify_track].freeze
+
+        # The controller in a keyed snapshot module (BL-D8-FDC): its own
+        # cycle count, the step of the command running and what the search
+        # is for by name, the registers and lines, the command's counters,
+        # and when its next step, its deadline and the next ID field fall,
+        # in its cycles from now, each absent when it never does.
+        def save_fields(out)
+          out.int("now", @now).text("phase", PHASE_NAMES.fetch(@phase)).text("mode", MODE_NAMES.fetch(@mode))
+          [["due_in", @due], ["deadline_in", @deadline], ["id_in", @id_at]].each do |key, at|
+            out.int(key, at - @now) unless at == NEVER
+          end
+          out.int("command", @command).int("track", @track).int("sector", @sector).int("data", @data)
+          out.int("status", @status).int("steps", @steps).int("count", @count).int("after_spin_up", @after_spin_up)
+          out.int("found", @found).int("index", @index).int("crc", @crc).int("write_id", @write_id).int("size", @size)
+          save_flag_fields(out)
+          out.bytes("bytes", @bytes).ints("syncs", @syncs.map { |sync| sync ? 1 : 0 })
+        end
+
+        def load_fields(input)
+          @now = input.int("now", @now)
+          @phase = PHASE_NAMES.index(input.choice("phase", PHASE_NAMES, "idle")).to_i
+          @mode = MODE_NAMES.index(input.choice("mode", MODE_NAMES, "read")).to_i
+          @due = at_fields(input, "due_in")
+          @deadline = at_fields(input, "deadline_in")
+          @id_at = at_fields(input, "id_in")
+          load_register_fields(input)
+          load_flag_fields(input)
+          @bytes = input.bytes("bytes", "".b).bytes
+          @syncs = input.ints("syncs", []).map { |sync| sync == 1 }
+        end
+
+        private
+
+        def at_fields(input, key)
+          cycles = input.optional_int(key)
+          cycles.nil? ? NEVER : @now + cycles
+        end
+
+        def load_register_fields(input)
+          @command = input.byte("command", @command)
+          @track = input.byte("track", @track)
+          @sector = input.byte("sector", @sector)
+          @data = input.byte("data", @data)
+          @status = input.byte("status", @status)
+          @steps = input.int("steps", @steps)
+          @count = input.int("count", @count)
+          @after_spin_up = input.int("after_spin_up", @after_spin_up)
+          @found = input.int("found", @found)
+          @index = input.int("index", @index)
+          @crc = input.int("crc", @crc)
+          @write_id = input.int("write_id", @write_id)
+          @size = input.int("size", @size)
+        end
+
+        def save_flag_fields(out)
+          out.bool("type1", @type1).bool("drq", @drq).bool("intrq", @intrq).bool("motor_on", @motor_on)
+          out.bool("inward", @inward).bool("crc_good", @crc_good).bool("gate_open", @gate_open).bool("late", @late)
+          out.bool("settling", @settling)
+        end
+
+        def load_flag_fields(input)
+          @type1 = input.bool("type1", @type1)
+          @drq = input.bool("drq", @drq)
+          @intrq = input.bool("intrq", @intrq)
+          @motor_on = input.bool("motor_on", @motor_on)
+          @inward = input.bool("inward", @inward)
+          @crc_good = input.bool("crc_good", @crc_good)
+          @gate_open = input.bool("gate_open", @gate_open)
+          @late = input.bool("late", @late)
+          @settling = input.bool("settling", @settling)
+        end
+      end
+
+      class Mechanism
+        # The head, the motor and the disk-change switch in a keyed snapshot
+        # module (BL-D8-MECH), with the disk's angle as it stands `now`, on
+        # the controller's clock.
+        def save_fields(out, now)
+          out.int("cylinder", @cylinder).int("side", @side).int("angle", angle(now)).bool("motor", @motor)
+          out.bool("changed", @changed)
+        end
+
+        # Puts `disk` under the head without flushing the one there, as a
+        # snapshot load replaces it.
+        def load_fields(input, disk, now)
+          @disk = disk
+          @cylinder = input.int("cylinder", @cylinder)
+          @side = input.masked("side", @side, 1)
+          @angle = input.int("angle", @angle)
+          @since = now
+          @motor = input.bool("motor", @motor)
+          @changed = input.bool("changed", @changed)
+        end
+      end
+
+      class Disk
+        # A disk's fields in a keyed snapshot module (BL-D8-DISK): the image
+        # file's path and how it was opened, the image as last flushed,
+        # embedded, each track the head wrote since the disk went in, sector
+        # by sector as the WD1772 sees them, and the tracks written since the
+        # last flush.
+        module KeyedState
+          # The image's path, expanded, and whether it was opened read-only,
+          # for a disk from Disk.open. Nil for a disk made another way.
+          attr_reader :path, :read_only
+
+          # Notes the image's path and how it was opened.
+          def opened(path, read_only)
+            @path = File.expand_path(path)
+            @read_only = read_only
+            self
+          end
+
+          def save_fields(out)
+            path = @path
+            out.text("path", path) if path
+            out.bool("read_only", @read_only == true)
+            image = @image
+            out.text("image.path", image.path.to_s).bytes("image", image.contents) if image
+            changed = @changed.keys.sort
+            out.ints("changed", changed)
+            changed.each { |index| save_track_fields(out, "track#{index}.", @tracks[index]) }
+            out.ints("written", @written.keys)
+          end
+
+          def load_track_fields(input)
+            @changed.clear
+            input.ints("changed", []).each do |index|
+              @tracks[index] = load_track_sectors(input, "track#{index}.")
+              @changed[index] = true
+            end
+            @written.clear
+            input.ints("written", []).each { |index| @written[index] = true }
+            self
+          end
+
+          private
+
+          def save_track_fields(out, prefix, track)
+            out.int("#{prefix}sectors", track.sectors.length)
+            track.sectors.each_with_index do |sector, number|
+              save_field_fields(out, "#{prefix}sector#{number}.id.", sector.id)
+              data = sector.data
+              save_field_fields(out, "#{prefix}sector#{number}.data.", data) if data
+            end
+          end
+
+          def save_field_fields(out, prefix, field)
+            out.int("#{prefix}mark", field.mark).bytes("#{prefix}bytes", field.bytes)
+            out.bool("#{prefix}good", field.good).bool("#{prefix}deleted", field.deleted)
+          end
+
+          def load_track_sectors(input, prefix)
+            Track.new(Array.new(input.int("#{prefix}sectors", 0)) do |number|
+              id = load_field_fields(input, "#{prefix}sector#{number}.id.")
+              data = input.optional_int("#{prefix}sector#{number}.data.mark")
+              Track::Sector.new(id, data.nil? ? nil : load_field_fields(input, "#{prefix}sector#{number}.data."))
+            end)
+          end
+
+          def load_field_fields(input, prefix)
+            Track::Field.new(input.int("#{prefix}mark", 0), input.bytes("#{prefix}bytes", "".b).bytes,
+                             input.bool("#{prefix}good", true), input.bool("#{prefix}deleted", false))
+          end
+        end
+
+        include KeyedState
+
+        # The disk a keyed snapshot module describes: its embedded image,
+        # with the tracks the module holds laid over it. The image takes
+        # writes back to its file only while that file is there and the
+        # reader isn't `detached`. With no image, the disk is the tracks
+        # alone.
+        def self.from_fields(input, detached: false)
+          path = input.text("path", "")
+          read_only = input.bool("read_only", false)
+          bytes = input.bytes("image", "".b).bytes
+          image_path = input.text("image.path", "")
+          disk = bytes.empty? ? Disk.new : Disk.new(image_from(image_path, bytes, read_only || detached))
+          disk.opened(path, read_only || bytes.empty?) unless path.empty?
+          disk.load_track_fields(input)
+        end
+
+        def self.image_from(path, bytes, read_only)
+          Storage::D81Image.new(File.file?(path) ? path : "", read_only:, bytes:)
+        end
+      end
+
+      class Bus
+        # The drive's RAM and the byte last on its data bus, in a keyed
+        # snapshot module (BL-D8-RAM).
+        def save_fields(out)
+          out.int("data", @data).bytes("ram", @ram.read(0, @ram.length))
+        end
+
+        def load_fields(input)
+          @data = input.byte("data", @data)
+          ram = @ram.read(0, @ram.length)
+          @ram.write(0, input.bytes_into("ram", ram))
+          @watching = false
+        end
+      end
+
+      # The drive's own fields in a keyed snapshot module (BL-D8): its
+      # model, its clock phase and cycle count, the ATN level it last saw
+      # and the host's lines as the serial port latched them. The fast
+      # serial direction and the ports' lines come from the 8520 once it
+      # is loaded.
+      module KeyedState
+        def save_fields(out)
+          settle!
+          out.text("model", model_name).int("phase", @phase).int("cycles", @cycles).bool("atn", @atn)
+          @serial_port.save_fields(out, "serial.")
+          out
+        end
+
+        def load_fields(input)
+          settle!
+          input.choice("model", [model_name], model_name)
+          @phase = input.int("phase", @phase)
+          @cycles = input.int("cycles", @cycles)
+          @atn = input.bool("atn", @atn)
+          @serial_port.load_fields(input, "serial.")
+        end
+
+        def restored!
+          @fast_serial_out = @cia.port_b_lines.anybits?(FAST_SERIAL_OUT)
+          ports_written
+          push_fast_output(@fast_serial_out ? fast_pins : 0)
+          forget_orbits
+        end
+
+        # The drive as modules of its own, as the 1541's, with the 8520 and
+        # the WD1772 in place of the VIAs.
+        def save_modules(sections, name)
+          sections << Snapshot::Keyed.section(name) { |out| save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-RAM") { |out| @bus.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-CIA") { |out| @cia.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-CPU") { |out| @cpu.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-FDC") { |out| @fdc.save_fields(out) }
+          now = @fdc.now
+          sections << Snapshot::Keyed.section("#{name}-MECH") { |out| @mechanism.save_fields(out, now) }
+          disk = @mechanism.disk
+          sections << Snapshot::Keyed.section("#{name}-DISK") { |out| disk.save_fields(out) } if disk
+          sections
+        end
+
+        # The drive from its modules, `input` being its own. The mechanism
+        # takes the disk's angle on the WD1772's clock, so it loads after
+        # the controller.
+        def load_modules(modules, input, name)
+          load_fields(input)
+          @bus.load_fields(modules.required("#{name}-RAM"))
+          @cia.load_fields(modules.required("#{name}-CIA"))
+          @cpu.load_fields(modules.required("#{name}-CPU"))
+          @fdc.load_fields(modules.required("#{name}-FDC"))
+          disk = modules.optional("#{name}-DISK")
+          mechanism = modules.required("#{name}-MECH")
+          @mechanism.load_fields(mechanism, disk.nil? ? nil : Disk.from_fields(disk, detached: modules.detached?),
+                                 @fdc.now)
+          @cia.restored!
+          @cpu.restored!
+          restored!
+        end
+      end
+
+      include KeyedState
+    end
+  end
+end

data/lib/badline/drives/model1581/mechanism.rb

@@ -92,27 +92,6 @@ module Badline
         def write(track)
           @disk&.write(@cylinder, @side, track)
         end
-
-        # The disk (Disk#save_state) and the motor, the head and the turn.
-        def save_state(out)
-          out.boolean(!@disk.nil?)
-          @disk&.save_state(out)
-          out.int(@cylinder).int(@side).int(@angle).int(@since).boolean(@motor).boolean(@changed)
-        end
-
-        # Puts the state back, reusing the disk in when it's the one the state
-        # names (Disk::SavedState.load). A disk taken out is flushed.
-        def load_state(input)
-          disk = input.boolean? ? Disk::SavedState.load(input, @disk) : nil
-          flush unless disk.equal?(@disk)
-          @disk = disk
-          @cylinder = input.int
-          @side = input.int
-          @angle = input.int
-          @since = input.int
-          @motor = input.boolean?
-          @changed = input.boolean?
-        end
       end
     end
   end

data/lib/badline/drives/model1581/slot.rb

@@ -55,24 +55,6 @@ module Badline
 
         # Whether the 1581 is device 8.
         def drive1581_on_device8? = @drive1581&.device == KernalTrap::Routine::DEVICE
-
-        # The 1581 on the serial bus, with its device number.
-        def save_drive1581(out)
-          out.boolean(!@drive1581.nil?)
-          return unless @drive1581
-
-          out.int(@drive1581.device)
-          @drive1581.save_state(out)
-        end
-
-        def load_drive1581(input)
-          return detach_drive1581 unless input.boolean?
-
-          device = input.int
-          detach_drive1581 if @drive1581 && @drive1581.device != device
-          attach_drive1581(Model1581.new(device:)) unless @drive1581
-          @drive1581.load_state(input)
-        end
       end
     end
   end

data/lib/badline/drives/model1581/wd1772.rb

@@ -6,7 +6,6 @@ require "badline/drives/model1581/wd1772/stepping"
 require "badline/drives/model1581/wd1772/sectors"
 require "badline/drives/model1581/wd1772/sector_writes"
 require "badline/drives/model1581/wd1772/tracks"
-require "badline/drives/model1581/wd1772/saved_state"
 
 module Badline
   module Drives
@@ -45,7 +44,6 @@ module Badline
         include Sectors
         include SectorWrites
         include Tracks
-        include SavedState
 
         BYTE = 64
         START = 32

data/lib/badline/drives/model1581.rb

@@ -9,7 +9,8 @@ require "badline/drives/model1581/wd1772"
 require "badline/drives/model1581/cpu"
 require "badline/drives/model1581/serial_port"
 require "badline/drives/model1581/bus"
-require "badline/drives/model1581/saved_state"
+require "badline/drives/model1581/keyed_state"
+require "badline/drives/model1581/slot"
 
 module Badline
   module Drives
@@ -39,7 +40,6 @@ module Badline
     class Model1581
       include Engine::Core
       include Engine::FastSerial
-      include SavedState
 
       CLOCK_HZ = 2_000_000
 

data/lib/badline/drives.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# The drives and the serial bus badline/core's machines share. The C128's
+# 1571 stays out of the core: badline/c128 requires it.
+require "badline/drives/datasette"
+require "badline/drives/serial_bus"
+require "badline/drives/model1541"
+require "badline/drives/model1581"

data/lib/badline/frontend/app.rb

@@ -21,7 +21,7 @@ module Badline
         @timeline = timeline
         @snapshots = Snapshots.new(computer, options)
         @screens = Screens.new(computer)
-        @led = DriveLed.for(computer)
+        @led = DriveLed.new(computer)
         @controls = Controls.new(computer)
         @window = MachineWindow.new(@screens.screen, vsync: @pacer.vsync?)
         @pacer.fit(@window.refresh_rate) if @pacer.vsync?
@@ -128,7 +128,7 @@ module Badline
         @computer = computer
         @screens.computer = computer
         fit_window
-        @led = DriveLed.for(computer)
+        @led = DriveLed.new(computer)
         @controls.computer = computer
         @gamepads.computer = computer
         @sound.switch(computer.sound_source, computer.timing.clock_hz)
@@ -220,7 +220,7 @@ module Badline
         renderer = @window.renderer
         SDL.SDL_RenderClear(renderer)
         SDL.SDL_RenderCopy(renderer, @window.texture, nil, nil)
-        @led&.draw(renderer, @window.width, @window.height)
+        @led.draw(renderer, @window.width, @window.height)
         @timeline.screenshots(@frames + 1).each { |path| Screenshot.write(renderer, path) }
         SDL.SDL_RenderPresent(renderer)
       end

data/lib/badline/frontend/boot.rb

@@ -10,7 +10,7 @@ module Badline
     # attach, an --at key names nothing or an event fails, which it warns
     # about.
     def self.run(options)
-      error = Timeline.error(options.timeline)
+      error = Timeline.error(options.timeline, options.family)
       unless error.empty?
         warn "#{options.program}: #{error}"
         return 1
@@ -55,11 +55,13 @@ module Badline
 
     # A new machine built from the options (Machine.for_options), with
     # `media`, if not nil, attached and started as the command line does,
-    # its disk writable if `writable`. The VIC-20 raises
+    # its disk writable if `writable`, after the Plus/4's cartridges the
+    # options put in its slots. The VIC-20 and the Plus/4 raise
     # Machine::Unsupported for a .sid tune.
     def self.start(options, media, writable)
       computer = build(options, media)
       Media::TrueDrive.plug(computer) if options.true_drive?
+      options.cartridges.each { |slot, path| puts Media.attach(computer, path, cartridge: { slot: }) }
       unless media.nil?
         puts Media.attach(computer, media, autostart: options.autostart?, subtune: options.subtune,
                                            disk: { read_only: !writable })

data/lib/badline/frontend/controls.rb

@@ -29,6 +29,7 @@ module Badline
         @arrows_port = 2
         @mouse = Input::Mouse1351.new
         @paddles = Input::Paddles.new
+        @held = {}
       end
 
       # Routes the input to another machine, the pot device going into its
@@ -73,10 +74,8 @@ module Badline
       def key(scancode, down)
         if joystick_mode? && Keys.joystick?(scancode)
           joystick_key(scancode, down)
-        elsif @computer.family == :c128
-          c128_key(Keys.c128_key(scancode, @computer.mode), down)
         else
-          c64_key(Keys.c64_key(scancode), down)
+          machine_key(scancode, down)
         end
       end
 
@@ -104,6 +103,27 @@ module Badline
 
       private
 
+      # A host key lets go of the key it pressed, though the C128 has
+      # switched between C64 and C128 mode since and maps it elsewhere.
+      def machine_key(scancode, down)
+        @held[scancode] = host_key(scancode) if down || !@held.key?(scancode)
+        key = @held[scancode]
+        @held.delete(scancode) unless down
+        if @computer.family == :c128
+          c128_key(key, down)
+        else
+          c64_key(key, down)
+        end
+      end
+
+      def host_key(scancode)
+        case @computer.family
+        when :c128 then Keys.c128_key(scancode, @computer.mode)
+        when :plus4 then Keys.plus4_key(scancode)
+        else Keys.c64_key(scancode)
+        end
+      end
+
       # RESTORE isn't in the key matrix, so it goes to the machine instead.
       def c64_key(key, down)
         if key == :restore
@@ -180,8 +200,8 @@ module Badline
       end
 
       def release_all
-        Keys::ARROWS.each_key { |scancode| @computer.keyboard.release(Keys.c64_key(scancode)) }
-        Keys::WASD.each_key { |scancode| @computer.keyboard.release(Keys.c64_key(scancode)) }
+        Keys::ARROWS.each_key { |scancode| @computer.keyboard.release(host_key(scancode)) }
+        Keys::WASD.each_key { |scancode| @computer.keyboard.release(host_key(scancode)) }
         Keys::ARROWS.each_value do |direction|
           @computer.joystick1.release(direction)
           @computer.joystick2.release(direction)

data/lib/badline/frontend/drive_led.rb

@@ -2,48 +2,71 @@
 
 module Badline
   module Frontend
-    # The true drive's red LED, drawn over the bottom right corner of the
-    # border: bright while the DOS lights it, as it does while a file is
-    # open or after an error, and dim otherwise.
+    # The true drive's LEDs, drawn over the bottom right corner of the
+    # border: the red activity LED, bright while the DOS lights it, as it
+    # does while a file is open or after an error, and dim otherwise, and
+    # left of it the green power LED, which a 1581 flashes after an error.
+    # They follow whichever true drive the machine has, one plugged in
+    # after start among them, and are drawn only while it has one.
     class DriveLed
       WIDTH = 12
       HEIGHT = 4
 
+      # The power LED's distance left of the activity LED.
+      POWER_OFFSET = WIDTH + 4
+
       LIT = [0xff, 0x20, 0x20].freeze
       DARK = [0x40, 0x00, 0x00].freeze
+      POWER_LIT = [0x20, 0xff, 0x20].freeze
+      POWER_DARK = [0x00, 0x40, 0x00].freeze
 
-      # The LED of the machine's true drive, or nil without one.
-      def self.for(computer)
-        drive = computer.true_drive
-        drive ? new(drive) : nil
-      end
-
-      # Sets SDL.led_rect to where the LED goes on a screen `width` by
-      # `height`.
-      def self.place(width, height)
+      # Sets SDL.led_rect to where the activity LED goes on a screen `width`
+      # by `height`, or with `offset` that many pixels left of it.
+      def self.place(width, height, offset = 0)
         rect = SDL.led_rect
-        SDL.rect_x(rect, width - WIDTH - 8)
+        SDL.rect_x(rect, width - WIDTH - 8 - offset)
         SDL.rect_y(rect, height - HEIGHT - 6)
         SDL.rect_w(rect, WIDTH)
         SDL.rect_h(rect, HEIGHT)
       end
 
-      def initialize(drive)
-        @drive = drive
+      def initialize(computer)
+        @computer = computer
       end
 
-      def lit? = @drive.led_on?
+      # Whether the machine has a true drive, and so LEDs to draw.
+      def shown? = !@computer.true_drive.nil?
+
+      def lit?
+        drive = @computer.true_drive
+        drive.nil? ? false : drive.led_on?
+      end
+
+      def power_lit?
+        drive = @computer.true_drive
+        drive.nil? ? false : drive.power_led_on?
+      end
 
       def color = lit? ? LIT : DARK
 
-      # Fills the LED's rectangle on a screen `width` by `height` in its
-      # colour, then puts back the black that RenderClear clears with.
+      def power_color = power_lit? ? POWER_LIT : POWER_DARK
+
+      # Fills the LEDs' rectangles on a screen `width` by `height` in their
+      # colours, then puts back the black that RenderClear clears with.
       def draw(renderer, width, height)
-        DriveLed.place(width, height)
-        rgb = color
+        return unless shown?
+
+        fill(renderer, width, height, 0, color)
+        fill(renderer, width, height, POWER_OFFSET, power_color)
+        SDL.SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255)
+      end
+
+      private
+
+      def fill(renderer, width, height, offset, rgb)
+        DriveLed.place(width, height, offset)
         SDL.SDL_SetRenderDrawColor(renderer, rgb[0], rgb[1], rgb[2], 255)
         SDL.SDL_RenderFillRect(renderer, SDL.led_rect)
-        SDL.SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255)
       end
     end
   end

data/lib/badline/frontend/keys.rb

@@ -3,8 +3,8 @@
 module Badline
   module Frontend
     # SDL scancodes follow key positions on a US layout. They map onto the C64
-    # keys, the C128's own keys and, in joystick mode, the joystick
-    # directions.
+    # keys, the C128's and the 264's own keys and, in joystick mode, the
+    # joystick directions.
     module Keys
       RETURN = 40
       ESCAPE = 41
@@ -56,6 +56,15 @@ module Badline
         63 => :forty_eighty, 72 => :forty_eighty, 78 => :run_stop
       }.freeze
 
+      # The 264's keys where they differ from the C64's: ESC on Esc, with
+      # RUN/STOP on Page Down as on the C128, F1-F3 on F1-F3, HELP on F4,
+      # Insert or Help, a cursor key on each arrow, and either SHIFT on the
+      # one SHIFT. Page Up, RESTORE on the C64, presses nothing.
+      PLUS4_OTHERS = {
+        41 => :esc, 78 => :run_stop, 58 => :f1, 59 => :f2, 60 => :f3, 61 => :help, 73 => :help, 117 => :help,
+        79 => :crsr_right, 80 => :crsr_left, 81 => :crsr_down, 82 => :crsr_up, 229 => :lshift, 75 => :none
+      }.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
 
@@ -77,6 +86,9 @@ module Badline
         C128_OTHERS[scancode] || c64_key(scancode)
       end
 
+      # The 264's key for the scancode: one of PLUS4_OTHERS or the C64's.
+      def self.plus4_key(scancode) = PLUS4_OTHERS[scancode] || c64_key(scancode)
+
       # The character the key types on a US layout: a letter, a capital
       # with `shift`, or a digit, and "" for any other key.
       def self.character(scancode, shift)

data/lib/badline/frontend/media_slots.rb

@@ -31,8 +31,18 @@ module Badline
           drive.nil? ? computer.unmount : drive.insert(nil)
         end
 
-        # Takes the cartridge out with the power off.
+        # Whether the expansion port has a cartridge in, on the Plus/4 in
+        # either cartridge's slots.
+        def cartridge?(computer)
+          return !computer.cartridge_slots.empty? if computer.family == :plus4
+
+          !computer.address_bus.cartridge.nil?
+        end
+
+        # Takes the cartridge out with the power off, on the Plus/4 both.
         def remove_cartridge(computer)
+          return computer.detach_cartridges if computer.family == :plus4
+
           computer.address_bus.detach_cartridge
           computer.power_cycle!
         end

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

@@ -8,8 +8,8 @@ module Badline
     # name. A disk or tape picked goes straight in, and a save loads.
     class MenuDialogs
       EXTENSIONS = {
-        disk: %w[.d64 .d71 .d81 .g64 .t64 .m3u .vfl], tape: %w[.tap], cartridge: %w[.crt],
-        program: %w[.d64 .d71 .d81 .g64 .t64 .m3u .vfl .tap .crt .prg .p00 .sid], snapshot: %w[.vsf]
+        disk: Media::Extensions::DEVICE8, tape: Media::Extensions.of(%i[tape]),
+        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
@@ -37,7 +37,8 @@ module Badline
       # :program, or :snapshot, which starts in the saves folder.
       def browse(kind)
         @browsing = kind
-        @browser.open(kind == :snapshot ? Badline.data_folder("saves") : @browse_from, EXTENSIONS.fetch(kind))
+        extensions = kind == :cartridge ? @media.cartridge_extensions : EXTENSIONS.fetch(kind)
+        @browser.open(kind == :snapshot ? Badline.data_folder("saves") : @browse_from, extensions)
       end
 
       # Asks for a save's name, starting from `name`.