badline 0.11.1 → 0.12.1

data/lib/badline/frontend/audio_device.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # An SDL audio device on SDL's queue: signed 16-bit samples, `channels`
+    # of them interleaved per frame, go in at the device's rate and SDL
+    # plays them out behind us. When #open fails the device stays closed,
+    # with the reason in SDL_GetError for the caller to report.
+    class AudioDevice
+      attr_reader :rate
+
+      def initialize(channels:, rate:, samples:)
+        @channels = channels
+        @rate = rate
+        @samples = samples
+        @device = 0
+        @buffer = IO::Buffer.new(4096)
+      end
+
+      def open? = @device != 0
+
+      # With `exact_rate` false SDL may pick the device's own rate instead,
+      # which #rate then reports.
+      def open(exact_rate)
+        return unless SDL.SDL_InitSubSystem(SDL::INIT_AUDIO).zero?
+
+        SDL.spec_freq(SDL.wanted, @rate)
+        SDL.spec_format(SDL.wanted, SDL::AUDIO_S16LSB)
+        SDL.spec_channels(SDL.wanted, @channels)
+        SDL.spec_samples(SDL.wanted, @samples)
+        allowed_changes = exact_rate ? 0 : SDL::ALLOW_FREQUENCY_CHANGE
+        @device = SDL.SDL_OpenAudioDevice(nil, 0, SDL.wanted, SDL.obtained, allowed_changes)
+        @rate = SDL.read_i32(SDL.obtained) if open?
+      end
+
+      # Returns SDL_QueueAudio's result, negative on failure.
+      def queue(samples)
+        count = samples.size
+        bytes = count * 2
+        @buffer.resize(bytes) if bytes > @buffer.size
+        buffer = @buffer
+        i = 0
+        while i < count
+          buffer.set_value(:s16, i * 2, samples[i])
+          i += 1
+        end
+        SDL.SDL_QueueAudio(@device, buffer, bytes)
+      end
+
+      def queued_seconds = SDL.SDL_GetQueuedAudioSize(@device) / (2.0 * @channels * @rate)
+
+      def start = SDL.SDL_PauseAudioDevice(@device, 0)
+
+      def pause = SDL.SDL_PauseAudioDevice(@device, 1)
+
+      def clear = SDL.SDL_ClearQueuedAudio(@device)
+
+      def close
+        return unless open?
+
+        SDL.SDL_CloseAudioDevice(@device)
+        SDL.SDL_QuitSubSystem(SDL::INIT_AUDIO)
+        @device = 0
+      end
+    end
+  end
+end

data/lib/badline/frontend/audio_sink.rb

@@ -2,72 +2,38 @@
 
 module Badline
   module Frontend
-    # The host's audio device for --headless and the SID player, fed through
-    # SDL's queue: stereo signed 16-bit samples, the left and right
-    # interleaved, go in at the device's rate and SDL plays them out behind
-    # us. It answers what Audio::Playback asks of a sink.
+    # The host's audio device for --headless and the SID player: a stereo
+    # AudioDevice, the left and right samples interleaved, that raises on
+    # SDL's failures. It answers what Audio::Playback asks of a sink.
     class AudioSink
       class Error < Audio::Playback::DeviceError; end
 
-      attr_reader :rate
-
       # With `exact_rate` false SDL may pick the device's own rate instead,
       # which #rate then reports.
       def initialize(rate:, exact_rate: false, buffer: 1024)
-        @device = 0
-        @rate = rate
-        @buffer = IO::Buffer.new(4096)
-        check(SDL.SDL_InitSubSystem(SDL::INIT_AUDIO))
-        open_device(rate, exact_rate ? 0 : SDL::ALLOW_FREQUENCY_CHANGE, buffer)
-      end
-
-      def queue(samples)
-        count = samples.size
-        bytes = count * 2
-        @buffer.resize(bytes) if bytes > @buffer.size
-        buffer = @buffer
-        i = 0
-        while i < count
-          buffer.set_value(:s16, i * 2, samples[i])
-          i += 1
-        end
-        check(SDL.SDL_QueueAudio(@device, buffer, bytes))
+        @device = AudioDevice.new(channels: 2, rate:, samples: buffer)
+        @device.open(exact_rate)
+        raise Error, SDL.SDL_GetError unless @device.open?
       end
 
-      def queued_seconds = SDL.SDL_GetQueuedAudioSize(@device) / (4.0 * @rate)
-
-      def start = SDL.SDL_PauseAudioDevice(@device, 0)
-
-      def pause = SDL.SDL_PauseAudioDevice(@device, 1)
-
-      def clear = SDL.SDL_ClearQueuedAudio(@device)
+      def rate = @device.rate
 
-      def close
-        return if @device.zero?
+      def queue(samples)
+        result = @device.queue(samples)
+        raise Error, SDL.SDL_GetError if result.negative?
 
-        SDL.SDL_CloseAudioDevice(@device)
-        SDL.SDL_QuitSubSystem(SDL::INIT_AUDIO)
-        @device = 0
+        result
       end
 
-      private
+      def queued_seconds = @device.queued_seconds
 
-      def open_device(rate, allowed_changes, buffer)
-        SDL.spec_freq(SDL.wanted, rate)
-        SDL.spec_format(SDL.wanted, SDL::AUDIO_S16LSB)
-        SDL.spec_channels(SDL.wanted, 2)
-        SDL.spec_samples(SDL.wanted, buffer)
-        @device = SDL.SDL_OpenAudioDevice(nil, 0, SDL.wanted, SDL.obtained, allowed_changes)
-        raise Error, SDL.SDL_GetError if @device.zero?
+      def start = @device.start
 
-        @rate = SDL.read_i32(SDL.obtained)
-      end
+      def pause = @device.pause
 
-      def check(result)
-        raise Error, SDL.SDL_GetError if result.negative?
+      def clear = @device.clear
 
-        result
-      end
+      def close = @device.close
     end
   end
 end

data/lib/badline/frontend/boot.rb

@@ -16,13 +16,10 @@ module Badline
         return 1
       end
 
-      begin
-        computer = boot(options)
-      rescue Media::TrueDrive::Error, Storage::SIDFile::FormatError, Storage::T64::FormatError,
-             Storage::TAP::FormatError, Storage::CRTFile::FormatError, Storage::G64Image::FormatError,
-             Cartridge::UnsupportedTypeError, Snapshot::FormatError, Media::DiskList::Error,
-             Datasette::Missing, Unsupported => e
-        warn "#{options.program}: #{options.media_path}: #{e.message}"
+      computer = nil
+      problem = media_problem { computer = boot(options) }
+      unless problem.empty?
+        warn "#{options.program}: #{options.media_path}: #{problem}"
         return 1
       end
       timeline = Timeline.new(options)
@@ -30,6 +27,19 @@ module Badline
       timeline.failed? ? 1 : 0
     end
 
+    # Runs the block and returns the message of the error it raised over
+    # media that won't go in or start, or an empty string. Other errors,
+    # a bare ArgumentError among them, go through.
+    def self.media_problem
+      yield
+      ""
+    rescue Machine::Unsupported, Media::TrueDrive::Error, Media::DiskList::Error, Media::NotDisk, Datasette::Missing,
+           SystemCallError, Storage::SIDFile::FormatError, Storage::T64::FormatError, Storage::TAP::FormatError,
+           Storage::CRTFile::FormatError, Storage::G64Image::FormatError, Cartridge::UnsupportedTypeError,
+           Snapshot::FormatError => e
+      e.message
+    end
+
     # The machine a .vsf snapshot holds, built as the saved one was, or a
     # new one built from the options with the media attached.
     def self.boot(options)
@@ -43,11 +53,10 @@ module Badline
       start(options, media, options.writable?)
     end
 
-    # A new machine built from the options, with `media`, if not nil,
-    # attached and started as the command line does, its disk writable if
-    # `writable`. The family and model give the machine, and a .sid tune
-    # or --sid the SID. The VIC-20 raises Unsupported for a .sid
-    # tune.
+    # 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
+    # Machine::Unsupported for a .sid tune.
     def self.start(options, media, writable)
       computer = build(options, media)
       Media::TrueDrive.plug(computer) if options.true_drive?
@@ -58,62 +67,10 @@ module Badline
       computer
     end
 
+    # The machine the options name, built for `media`, which says the RAM
+    # expansion a VIC-20 gets for it.
     def self.build(options, media)
-      case options.family
-      when :vic20 then vic20(options, media)
-      when :c128 then c128(options, media)
-      else c64(options, media)
-      end
-    end
-
-    def self.c64(options, media)
-      sid_model = options.sid_model || Media.sid_model(media, otherwise: nil)
-      Machine.build(:c64, model: options.model, sid_model:, reu: options.reu)
+      Machine.for_options(options, media) { |line| puts line }
     end
-
-    # A C128 in C128 mode. With --c64, or media only C64 mode runs, a .sid
-    # tune or a program that loads at the C64's BASIC start, C= is held
-    # through the reset, so the C128 KERNAL starts C64 mode.
-    def self.c128(options, media)
-      sid_model = options.sid_model || Media.sid_model(media, otherwise: nil)
-      machine = C128.new(model: options.model, sid_model:, mode: :c128)
-      machine.hold_commodore_key if options.c64_mode? || c64_media?(media)
-      machine
-    end
-
-    def self.c64_media?(media)
-      return false if media.nil? || !File.file?(media)
-
-      extension = File.extname(media).downcase
-      return true if extension == ".sid"
-      return false unless %w[.prg .p00].include?(extension)
-
-      bytes = File.binread(media).bytes
-      bytes = Storage::P00.data(bytes) if Storage::P00.wraps?(bytes)
-      bytes.length >= 2 && [Media::BASIC_START, Media::BASIC_START - 1].include?(bytes[0] | (bytes[1] << 8))
-    end
-
-    # A VIC-20 with the RAM --ram names, or else the RAM `media` needs
-    # (Media::Vic20Media.ram_for), which it says. Raises Unsupported for
-    # media a VIC-20 doesn't take.
-    def self.vic20(options, media)
-      ram = options.ram
-      unless media.nil?
-        unsupported = Media::Vic20Media::UNSUPPORTED.include?(File.extname(media).downcase)
-        raise Unsupported, "doesn't go in a VIC-20" if unsupported
-
-        ram ||= vic20_ram(media)
-      end
-      Machine.build(:vic20, model: options.model, ram:)
-    end
-
-    def self.vic20_ram(media)
-      ram = Media::Vic20Media.ram_for(media)
-      puts "RAM expansion: #{ram}"
-      ram
-    end
-
-    # Media the machine the options name doesn't take.
-    class Unsupported < ArgumentError; end
   end
 end

data/lib/badline/frontend/buttons.rb

@@ -2,17 +2,17 @@
 
 module Badline
   module Frontend
-    # The SID player's buttons: each is drawn where it goes on every frame,
-    # and remembers its place, so a click finds the action under it. The
-    # one under the pointer lights up, and one that's on is drawn reversed.
-    # They take the player's colours unless given others: the text, the text
-    # under the pointer, the background and, if any, a fill behind each
-    # button.
+    # The buttons of the SID player and the pause menu: each is drawn where
+    # it goes on every frame, and remembers its place, so a click finds the
+    # action under it. The one under the pointer lights up, and one that's
+    # on is drawn reversed. They take their colours from the caller: the
+    # text, the text under the pointer, the background and, if any, a fill
+    # behind each button.
     class Buttons
       PAD = 2
       HEIGHT = Painter::GLYPH + (PAD * 2)
 
-      def initialize(painter, colors = [SIDView::TEXT, SIDView::BRIGHT, PlayerScreen::BACKGROUND])
+      def initialize(painter, colors)
         @painter = painter
         @text = colors[0]
         @bright = colors[1]

data/lib/badline/frontend/keys.rb

@@ -6,7 +6,27 @@ module Badline
     # keys, the C128's own keys and, in joystick mode, the joystick
     # directions.
     module Keys
+      RETURN = 40
+      ESCAPE = 41
+      BACKSPACE = 42
       TAB = 43
+      SPACE = 44
+      F8 = 65
+      F9 = 66
+      F10 = 67
+      F11 = 68
+      F12 = 69
+      HOME = 74
+      PAGE_UP = 75
+      END_KEY = 77
+      PAGE_DOWN = 78
+      RIGHT = 79
+      LEFT = 80
+      DOWN = 81
+      UP = 82
+
+      # The arrow keys, which move through the menus.
+      DIRECTIONS = { RIGHT => :right, LEFT => :left, DOWN => :down, UP => :up }.freeze
 
       LETTERS = %i[a b c d e f g h i j k l m n o p q r s t u v w x y z].freeze
       DIGITS = %i[1 2 3 4 5 6 7 8 9 0].freeze
@@ -36,14 +56,6 @@ module Badline
         63 => :forty_eighty, 72 => :forty_eighty, 78 => :run_stop
       }.freeze
 
-      ESCAPE = 41
-
-      F8 = 65
-      F9 = 66
-      F10 = 67
-      F11 = 68
-      F12 = 69
-
       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
 
@@ -65,6 +77,19 @@ module Badline
         C128_OTHERS[scancode] || c64_key(scancode)
       end
 
+      # 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)
+        if scancode.between?(4, 29)
+          letter = (97 + scancode - 4).chr
+          shift ? letter.upcase : letter
+        elsif scancode.between?(30, 39)
+          "1234567890"[scancode - 30]
+        else
+          ""
+        end
+      end
+
       def self.arrows(scancode) = ARROWS[scancode] || :none
 
       def self.wasd(scancode) = WASD[scancode] || :none

data/lib/badline/frontend/media_slots.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The machine's media slots as the pause menu and the --at events
+    # both take media out of them: device 8, a true drive there or else
+    # the KERNAL traps, and the expansion port.
+    module MediaSlots
+      class << self
+        # Whether device 8 has a disk in.
+        def disk?(computer)
+          drive = Media::TrueDrive.drive(computer)
+          drive.nil? ? computer.mounted? : !drive.disk.nil?
+        end
+
+        # The expanded path of the disk in device 8, however it went in, or
+        # an empty one.
+        def disk_path(computer)
+          drive = Media::TrueDrive.drive(computer)
+          unless drive.nil?
+            disk = drive.disk
+            return disk.nil? ? "" : disk.path.to_s
+          end
+
+          path = computer.mounted_path
+          path.empty? ? path : File.expand_path(path)
+        end
+
+        def eject_disk(computer)
+          drive = Media::TrueDrive.drive(computer)
+          drive.nil? ? computer.unmount : drive.insert(nil)
+        end
+
+        # Takes the cartridge out with the power off.
+        def remove_cartridge(computer)
+          computer.address_bus.detach_cartridge
+          computer.power_cycle!
+        end
+      end
+    end
+  end
+end

data/lib/badline/frontend/{confirmation.rb → menu/confirmation.rb}

@@ -43,11 +43,11 @@ module Badline
 
       def draw(left, top)
         painter = @painter
-        painter.text(left, top, TITLES.fetch(@kind), PauseMenu::BRIGHT)
-        painter.text(left, top + 20, Painter.fit(File.basename(@path), 40), PauseMenu::TEXT) unless @path.empty?
+        painter.text(left, top, TITLES.fetch(@kind), MenuTheme::BRIGHT)
+        painter.text(left, top + 20, Painter.fit(File.basename(@path), 40), MenuTheme::TEXT) unless @path.empty?
         warning = WARNINGS.fetch(@kind)
-        painter.text(left, top + 44, warning[0], PauseMenu::TEXT)
-        painter.text(left, top + 56, warning[1], PauseMenu::TEXT) unless warning[1].empty?
+        painter.text(left, top + 44, warning[0], MenuTheme::TEXT)
+        painter.text(left, top + 56, warning[1], MenuTheme::TEXT) unless warning[1].empty?
         @buttons.row([left, top + 80, MenuPages::ROW_WIDTH], "CANCEL", :cancel)
         @buttons.row([left, top + 80 + Buttons::HEIGHT + 2, MenuPages::ROW_WIDTH], ANSWERS.fetch(@kind), :confirm)
       end

data/lib/badline/frontend/{file_browser.rb → menu/file_browser.rb}

@@ -12,19 +12,6 @@ module Badline
       ROWS = 12
       COLUMNS = 40
 
-      RETURN = 40
-      ESCAPE = 41
-      BACKSPACE = 42
-      HOME = 74
-      PAGE_UP = 75
-      END_KEY = 77
-      PAGE_DOWN = 78
-      RIGHT = 79
-      LEFT = 80
-      DOWN = 81
-      UP = 82
-      DIGITS = "1234567890"
-
       attr_reader :directory
 
       def initialize(painter, buttons)
@@ -60,9 +47,9 @@ module Badline
       # Handles a key, and returns the path of a file picked, :cancel when
       # Esc leaves the browser, or nil.
       def key(scancode)
-        return :cancel if scancode == ESCAPE
-        return pick if [RETURN, RIGHT].include?(scancode)
-        return up if [LEFT, BACKSPACE].include?(scancode)
+        return :cancel if scancode == Keys::ESCAPE
+        return pick if [Keys::RETURN, Keys::RIGHT].include?(scancode)
+        return up if [Keys::LEFT, Keys::BACKSPACE].include?(scancode)
 
         select(@selected + step(scancode)) unless step(scancode).zero?
         jump(scancode)
@@ -83,14 +70,14 @@ module Badline
       end
 
       def draw(left, top, width, title)
-        @painter.text(left, top, title, PauseMenu::BRIGHT)
-        @painter.text(left, top + ROW + 2, shown_directory, PauseMenu::DIM)
+        @painter.text(left, top, title, MenuTheme::BRIGHT)
+        @painter.text(left, top + ROW + 2, shown_directory, MenuTheme::DIM)
         @list_top = top + (ROW * 2) + 8
         @buttons.area([left, @list_top, width, ROW * ROWS], :browse)
         draw_rows(left, width)
         draw_bar(left + width - 2) if @names.size > ROWS
         @painter.text(left, @list_top + (ROW * ROWS) + 6, "RETURN: OPEN  LEFT: BACK  ESC: CANCEL",
-                      PauseMenu::DIM)
+                      MenuTheme::DIM)
       end
 
       private
@@ -109,10 +96,10 @@ module Badline
           name = label(index)
           top = @list_top + (row * ROW)
           if index == @selected
-            @painter.box(left - 2, top - 2, width - 4, ROW, PauseMenu::TEXT)
-            @painter.text(left, top, name, PauseMenu::PANEL)
+            @painter.box(left - 2, top - 2, width - 4, ROW, MenuTheme::TEXT)
+            @painter.text(left, top, name, MenuTheme::PANEL)
           else
-            @painter.text(left, top, name, index < @folders ? PauseMenu::BRIGHT : PauseMenu::TEXT)
+            @painter.text(left, top, name, index < @folders ? MenuTheme::BRIGHT : MenuTheme::TEXT)
           end
         end
       end
@@ -121,8 +108,8 @@ module Badline
         height = ROW * ROWS
         size = [(height * ROWS) / @names.size, 4].max
         offset = ((height - size) * @top) / [@names.size - ROWS, 1].max
-        @painter.box(left, @list_top - 2, 2, height, PauseMenu::EDGE)
-        @painter.box(left, @list_top - 2 + offset, 2, size, PauseMenu::TEXT)
+        @painter.box(left, @list_top - 2, 2, height, MenuTheme::EDGE)
+        @painter.box(left, @list_top - 2 + offset, 2, size, MenuTheme::TEXT)
       end
 
       def label(index)
@@ -133,12 +120,12 @@ module Badline
 
       def step(scancode)
         case scancode
-        when UP then -1
-        when DOWN then 1
-        when PAGE_UP then -ROWS
-        when PAGE_DOWN then ROWS
-        when HOME then -@names.size
-        when END_KEY then @names.size
+        when Keys::UP then -1
+        when Keys::DOWN then 1
+        when Keys::PAGE_UP then -ROWS
+        when Keys::PAGE_DOWN then ROWS
+        when Keys::HOME then -@names.size
+        when Keys::END_KEY then @names.size
         else 0
         end
       end
@@ -154,10 +141,7 @@ module Badline
       # Selects the next name after the one selected that starts with the
       # key's letter or digit.
       def jump(scancode)
-        char = if scancode.between?(4, 29) then (97 + scancode - 4).chr
-               elsif scancode.between?(30, 39) then DIGITS[scancode - 30]
-               else ""
-               end
+        char = Keys.character(scancode, false)
         return if char.empty? || @names.empty?
 
         @names.size.times do |offset|

data/lib/badline/frontend/{menu_dialogs.rb → menu/menu_dialogs.rb}

@@ -14,10 +14,6 @@ module Badline
       TITLES = { disk: "INSERT A DISK", tape: "INSERT A TAPE", cartridge: "INSERT A CARTRIDGE",
                  program: "QUICK OPEN", snapshot: "LOAD A SAVE" }.freeze
 
-      ESCAPE = 41
-      RETURN = 40
-      SPACE = 44
-
       # The machine Quick open started or a save loaded.
       attr_reader :computer
 
@@ -78,10 +74,10 @@ module Badline
         if @name_field.open? && !@confirmation.open?
           return named(@name_field.key(scancode, SDL.event_mod(SDL.event).anybits?(SDL::KMOD_SHIFT)))
         end
-        return answer(:cancel) if scancode == ESCAPE
-        return answer(@buttons.focus) if [RETURN, SPACE].include?(scancode)
+        return answer(:cancel) if scancode == Keys::ESCAPE
+        return answer(@buttons.focus) if [Keys::RETURN, Keys::SPACE].include?(scancode)
 
-        direction = PauseMenu::ARROWS[scancode]
+        direction = Keys::DIRECTIONS[scancode]
         @buttons.shift(direction == :up ? -1 : 1, 1) if %i[up down].include?(direction)
         nil
       end

data/lib/badline/frontend/{menu_media.rb → menu/menu_media.rb}

@@ -25,40 +25,22 @@ module Badline
 
       def writable? = @writable
 
-      # The expanded path of the disk in device 8, however it went in, or
-      # an empty one.
-      def disk_path
-        drive = @computer.true_drive
-        unless drive.nil?
-          disk = drive.disk
-          return disk.nil? ? "" : disk.path.to_s
-        end
-
-        path = @computer.mounted_path
-        path.empty? ? path : File.expand_path(path)
-      end
+      def disk_path = MediaSlots.disk_path(@computer)
 
-      def inserted?
-        drive = @computer.true_drive
-        drive.nil? ? @computer.mounted? : !drive.disk.nil?
-      end
+      def inserted? = MediaSlots.disk?(@computer)
 
       # Puts a disk in device 8 or a tape in the datasette, `kind` :disk or
       # :tape, and says whether it went in. A list puts its first disk in.
       def insert(kind, path)
-        @problem = ""
-        if kind == :disk
-          disk = Media::DiskList.disk(path)
-          Media.insert_disk(@computer, disk, read_only: !@writable)
-          list(path)
-        else
-          @computer.datasette.insert(Storage::TAP.new(path))
+        succeeds? do
+          if kind == :disk
+            disk = Media::DiskList.disk(path)
+            Media.insert_disk(@computer, disk, read_only: !@writable)
+            list(path)
+          else
+            @computer.datasette.insert(Storage::TAP.new(path))
+          end
         end
-        true
-      rescue ArgumentError, SystemCallError, Storage::TAP::FormatError, Storage::T64::FormatError,
-             Storage::G64Image::FormatError => e
-        @problem = e.message
-        false
       end
 
       # Does what the Drive page's :eject_disk, :previous_disk, :next_disk,
@@ -72,10 +54,7 @@ module Badline
         end
       end
 
-      def eject_disk
-        drive = @computer.true_drive
-        drive.nil? ? @computer.unmount : drive.insert(nil)
-      end
+      def eject_disk = MediaSlots.eject_disk(@computer)
 
       # Sets whether disks are writable, for the disk in the drive too,
       # which goes in again as the notch now says.
@@ -111,12 +90,7 @@ module Badline
       # Swaps the cartridge for the one at `path`, which power cycles the
       # machine, and says whether it went in.
       def attach_cartridge(path)
-        @problem = ""
-        Media.attach(@computer, path)
-        true
-      rescue ArgumentError, SystemCallError, Storage::CRTFile::FormatError, Cartridge::UnsupportedTypeError => e
-        @problem = e.message
-        false
+        succeeds? { Media.attach(@computer, path) }
       end
 
       # What a save of the machine is named after: the cartridge, the disk,
@@ -147,27 +121,28 @@ module Badline
       end
 
       # Takes the cartridge out with the power off.
-      def remove_cartridge
-        @computer.address_bus.detach_cartridge
-        @computer.power_cycle!
-      end
+      def remove_cartridge = MediaSlots.remove_cartridge(@computer)
 
       # A new machine started on `path`, as the command line would, or nil
       # when it won't start.
       def start(options, path)
-        @problem = ""
-        computer = Frontend.start(options, path, @writable)
-        list(path)
-        computer
-      rescue ArgumentError, SystemCallError, Media::TrueDrive::Error, Storage::SIDFile::FormatError,
-             Storage::T64::FormatError, Storage::TAP::FormatError, Storage::CRTFile::FormatError,
-             Storage::G64Image::FormatError, Cartridge::UnsupportedTypeError => e
-        @problem = e.message
-        nil
+        computer = nil
+        started = succeeds? do
+          computer = Frontend.start(options, path, @writable)
+          list(path)
+        end
+        started ? computer : nil
       end
 
       private
 
+      # Runs the block, keeps the media error it raised as the problem, and
+      # says whether there was none.
+      def succeeds?(&)
+        @problem = Frontend.media_problem(&)
+        @problem.empty?
+      end
+
       # Keeps `path` as the list the set comes from, if it's a list.
       def list(path)
         return unless Media::DiskList.list?(path)