badline 0.7.0 → 0.9.0

data/lib/badline/frontend/boot.rb

@@ -20,7 +20,8 @@ module Badline
         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 => e
+             Cartridge::UnsupportedTypeError, Snapshot::FormatError, Media::DiskList::Error,
+             Datasette::Missing => e
         warn "#{options.program}: #{options.media_path}: #{e.message}"
         return 1
       end
@@ -39,12 +40,23 @@ module Badline
         return computer
       end
 
-      computer = Computer.new(sid_model: options.sid_model || Media.sid_model(media), reu: options.reu,
-                              region: options.ntsc? ? Region::NTSC : Region::PAL)
+      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 model gives the chips, and a .sid tune or --sid the
+    # SID.
+    def self.start(options, media, writable)
+      model = Model.named(options.model)
+      computer = Computer.new(vic_model: model.vic_model, cia_model: model.cia_model,
+                              sid_model: options.sid_model || Media.sid_model(media, otherwise: model.sid_model),
+                              region: model.region, reu: options.reu, kernal: model.kernal,
+                              datasette: model.datasette)
       Media::TrueDrive.plug(computer) if options.true_drive?
       unless media.nil?
         puts Media.attach(computer, media, autostart: options.autostart?, subtune: options.subtune,
-                                           disk: { read_only: options.read_only? })
+                                           disk: { read_only: !writable })
       end
       computer
     end

data/lib/badline/frontend/buttons.rb

@@ -5,27 +5,43 @@ module Badline
     # 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.
     class Buttons
       PAD = 2
       HEIGHT = Painter::GLYPH + (PAD * 2)
 
-      def initialize(painter)
+      def initialize(painter, colors = [SIDView::TEXT, SIDView::BRIGHT, PlayerScreen::BACKGROUND])
         @painter = painter
+        @text = colors[0]
+        @bright = colors[1]
+        @back = colors[2]
+        @fill = colors.size > 3 ? colors[3] : -1
         @lefts = []
         @tops = []
         @widths = []
         @heights = []
         @actions = []
+        @focusable = []
+        @toggles = {}
         @pointer_x = -1
         @pointer_y = -1
+        @focus = nil
       end
 
+      # The action of the button the keys have moved to, which lights up as
+      # the one under the pointer does, or nil.
+      attr_accessor :focus
+
       def forget
         @lefts.clear
         @tops.clear
         @widths.clear
         @heights.clear
         @actions.clear
+        @focusable.clear
+        @toggles.clear
       end
 
       def point(left, top)
@@ -38,11 +54,54 @@ module Badline
       def text(left, top, label, action, on: false)
         width = Painter.width(label) + (PAD * 2)
         place(left, top, width, HEIGHT, action)
-        @painter.box(left, top, width, HEIGHT, SIDView::TEXT) if on
-        @painter.text(left + PAD, top + PAD, label, on ? PlayerScreen::BACKGROUND : color(@actions.size - 1))
+        @painter.box(left, top, width, HEIGHT, @fill) if !on && @fill >= 0
+        @painter.box(left, top, width, HEIGHT, action == @focus ? @bright : @text) if on
+        @painter.text(left + PAD, top + PAD, label, on ? @back : color(@actions.size - 1))
         width
       end
 
+      # Draws a button as #text does, without the fill.
+      def plain(left, top, label, action, on: false)
+        fill = @fill
+        @fill = -1
+        width = text(left, top, label, action, on:)
+        @fill = fill
+        width
+      end
+
+      # Draws a button as wide as `box`, its left and top and width, with
+      # `label` at its left and `value`, if any, at its right, as a menu's
+      # row.
+      def row(box, label, action, value = "")
+        left = box[0]
+        top = box[1]
+        width = box[2]
+        place(left, top, width, HEIGHT, action)
+        @painter.box(left, top, width, HEIGHT, @fill) if @fill >= 0
+        color = color(@actions.size - 1)
+        @painter.text(left + PAD, top + PAD, label, color)
+        @painter.text(left + width - PAD - Painter.width(value), top + PAD, value, color) unless value.empty?
+      end
+
+      # Draws a row as #row does, with its choices at its right, `choices`
+      # holding their labels, their actions and the index of the one on.
+      # A click picks a choice, and pressing the row, `action`, picks the
+      # next, which #resolve gives.
+      def toggle(box, label, action, choices)
+        row(box, label, action)
+        labels = choices[0]
+        @toggles[action] = choices[1][(choices[2] + 1) % labels.size]
+        right = box[0] + box[2] - PAD
+        index = labels.size - 1
+        while index >= 0
+          width = Painter.width(labels[index]) + (PAD * 2)
+          right -= width
+          choice(right, box[1], labels[index], choices[1][index], index == choices[2])
+          right -= 2
+          index -= 1
+        end
+      end
+
       # Draws an icon button `scale` times the size of a glyph, and returns
       # its width.
       def icon(left, top, name, action, scale: 1)
@@ -58,17 +117,42 @@ module Badline
         place(box[0], box[1], box[2], box[3], action)
       end
 
-      # The action of the button at `left`, `top`, or nil.
+      # The action of the button at `left`, `top`, or nil: a toggle's
+      # choice before the row it sits on.
       def action_at(left, top)
+        found = nil
         index = 0
         while index < @actions.size
-          return @actions[index] if inside?(index, left, top)
+          if inside?(index, left, top)
+            return @actions[index] unless @focusable[index]
 
+            found ||= @actions[index]
+          end
           index += 1
         end
-        nil
+        found
       end
 
+      # Moves the focus `delta` buttons on, among those drawn from the
+      # `first` on, stopping at either end.
+      def shift(delta, first)
+        return if @actions.size <= first
+
+        focusable = []
+        (first...@actions.size).each { |index| focusable << @actions[index] if @focusable[index] }
+        return if focusable.empty?
+
+        from = focusable.index(@focus)
+        @focus = focusable[from.nil? ? 0 : (from + delta).clamp(0, focusable.size - 1)]
+      end
+
+      # The action pressing a button stands for: for a toggle's row, its
+      # next choice's.
+      def resolve(action) = @toggles.fetch(action, action)
+
+      # The action of the button drawn `index`th, or nil.
+      def action(index) = @actions[index]
+
       private
 
       def place(left, top, width, height, action)
@@ -77,9 +161,19 @@ module Badline
         @widths << width
         @heights << height
         @actions << action
+        @focusable << true
+      end
+
+      # A choice of a toggle, which a click picks but the keys pass by.
+      def choice(left, top, label, action, on)
+        width = Painter.width(label) + (PAD * 2)
+        place(left, top, width, HEIGHT, action)
+        @focusable[-1] = false
+        @painter.box(left, top, width, HEIGHT, @text) if on
+        @painter.text(left + PAD, top + PAD, label, on ? @back : color(@actions.size - 1))
       end
 
-      def color(index) = inside?(index, @pointer_x, @pointer_y) ? SIDView::BRIGHT : SIDView::TEXT
+      def color(index) = inside?(index, @pointer_x, @pointer_y) || @actions[index] == @focus ? @bright : @text
 
       def inside?(index, left, top)
         left >= @lefts[index] && left < @lefts[index] + @widths[index] &&

data/lib/badline/frontend/confirmation.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The pause menu's question before something power cycles the machine
+    # or replaces a file: a cartridge going in or out, Quick open starting a
+    # file, or a save overwriting one of the same name. CANCEL has the
+    # focus, so Return alone changes nothing.
+    class Confirmation
+      TITLES = { cartridge: "INSERT A CARTRIDGE", remove: "REMOVE THE CARTRIDGE", start: "QUICK OPEN",
+                 overwrite: "SAVE AS" }.freeze
+      LOST = "ANYTHING NOT SAVED IS LOST."
+      WARNINGS = { cartridge: ["INSERTING IT POWER CYCLES THE MACHINE.", LOST],
+                   remove: ["REMOVING IT POWER CYCLES THE MACHINE.", LOST],
+                   start: ["THIS STARTS A NEW MACHINE.", LOST],
+                   overwrite: ["OVERWRITE EXISTING SAVE?", ""] }.freeze
+      ANSWERS = { cartridge: "INSERT", remove: "REMOVE", start: "START", overwrite: "OVERWRITE" }.freeze
+
+      def initialize(painter, buttons)
+        @painter = painter
+        @buttons = buttons
+        @kind = :start
+        @path = ""
+        @open = false
+      end
+
+      def open? = @open
+
+      # Asks about `kind`, :cartridge, :remove, :start or :overwrite, for the
+      # file at `path`, or the save named so.
+      def ask(kind, path)
+        @kind = kind
+        @path = path
+        @open = true
+        @buttons.focus = :cancel
+      end
+
+      # Puts the question away, and returns its kind and path.
+      def close
+        @open = false
+        [@kind, @path]
+      end
+
+      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?
+        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?
+        @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
+    end
+  end
+end

data/lib/badline/frontend/controls.rb

@@ -2,53 +2,72 @@
 
 module Badline
   module Frontend
-    # Routes host input to the machine in one of the input modes, which Tab
-    # steps through and shift-Tab steps back through:
+    # Routes host input to the machine. Two settings decide where it goes:
     #
-    # - keyboard: every host key goes to the C64 keyboard.
-    # - joystick: the arrow cluster and space drive one joystick and WASD
-    #   and left shift the other. The arrows start on joystick 2, and F9
-    #   swaps them.
-    # - mouse1, mouse2: the host mouse is a 1351 mouse on control port 1 or
-    #   2, and paddles1, paddles2 a pair of paddles there. Motion turns the
-    #   paddles or moves the mouse, and the host's left and right buttons go
-    #   to whichever lines the device puts them on.
+    # - The keys: every host key goes to the C64 keyboard, or, as Tab
+    #   switches, the arrow cluster and space drive one joystick and WASD
+    #   and left shift the other. The arrows start on joystick 2, and
+    #   #swap_ports swaps them.
+    # - A pot device the pause menu plugs into a control port: a 1351
+    #   mouse or a pair of paddles, which the host mouse drives. Motion
+    #   turns the paddles or moves the mouse, and the host's left and right
+    #   buttons go to whichever lines the device puts them on.
     class Controls
-      MODES = %i[keyboard joystick mouse1 mouse2 paddles1 paddles2].freeze
-      TAGS = ["", "JOY", "MOUSE 1", "MOUSE 2", "PADDLE 1", "PADDLE 2"].freeze
+      POTS = %i[none mouse1 mouse2 paddles1 paddles2].freeze
+      TAGS = ["", "MOUSE 1", "MOUSE 2", "PADDLE 1", "PADDLE 2"].freeze
 
       # SDL mouse button numbers.
       MOUSE_BUTTONS = { 1 => :left, 3 => :right }.freeze
 
-      attr_reader :mode, :arrows_port
+      # The pot device plugged in, one of POTS.
+      attr_reader :pot, :arrows_port
 
       def initialize(computer)
         @computer = computer
-        @mode = :keyboard
+        @joystick = false
+        @pot = :none
         @arrows_port = 2
         @mouse = Input::Mouse1351.new
         @paddles = Input::Paddles.new
       end
 
-      # Routes the input to another machine, the mode's mouse or paddles
-      # going into its port.
+      # Routes the input to another machine, the pot device going into its
+      # port.
       def computer=(computer)
         release_all
         @computer = computer
         attach_pot_device
       end
 
-      def joystick_mode? = @mode == :joystick
+      def joystick_mode? = @joystick
+
+      # Sends the keys to the joysticks, or with false to the keyboard.
+      def joystick_mode=(joystick)
+        @joystick = joystick
+        release_all
+      end
+
+      def toggle_keys
+        self.joystick_mode = !@joystick
+      end
+
+      # Plugs in one of POTS, in place of the one before.
+      def plug(pot)
+        @pot = pot
+        release_all
+        attach_pot_device
+      end
 
       # Whether the host mouse drives a pot device, and so should be held
       # in relative mode.
-      def pot_device? = MODES.index(@mode) >= 2
+      def pot_device? = @pot != :none
 
-      # The title bar's tag for the mode, empty for the keyboard.
+      # The title bar's tag for the settings, empty for the keyboard alone.
       def tag
-        return "JOY #{@arrows_port}" if joystick_mode?
-
-        TAGS[MODES.index(@mode)]
+        tags = []
+        tags << "JOY #{@arrows_port}" if @joystick
+        tags << TAGS[POTS.index(@pot)] if pot_device?
+        tags.join(", ")
       end
 
       def key(scancode, down)
@@ -59,13 +78,6 @@ module Badline
         end
       end
 
-      # Steps to the next mode, or back with a negative step.
-      def cycle_mode(step)
-        @mode = MODES[(MODES.index(@mode) + step) % MODES.size]
-        release_all
-        attach_pot_device
-      end
-
       def swap_ports
         @arrows_port = 3 - @arrows_port
         release_all
@@ -99,9 +111,9 @@ module Badline
         end
       end
 
-      def paddles? = MODES.index(@mode) >= 4
+      def paddles? = POTS.index(@pot) >= 3
 
-      # A fresh device on the mode's port, and none on the other.
+      # A fresh pot device on its port, and none on the other.
       def attach_pot_device
         ports = @computer.control_ports
         ports.device1 = nil
@@ -133,7 +145,7 @@ module Badline
         end
       end
 
-      def port_one? = %i[mouse1 paddles1].include?(@mode)
+      def port_one? = %i[mouse1 paddles1].include?(@pot)
 
       def joystick_key(scancode, down)
         direction = Keys.arrows(scancode)

data/lib/badline/frontend/file_browser.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The pause menu's file browser, which lists a folder's subfolders and
+    # the files a device takes, folders first, each by name. The keys move
+    # through the list, open a folder or pick a file, go up a folder, and
+    # jump to the next name starting with a letter or digit. A click picks
+    # the row under it, and the wheel scrolls.
+    class FileBrowser
+      ROW = 12
+      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)
+        @painter = painter
+        @buttons = buttons
+        @open = false
+        @directory = Dir.pwd
+        @extensions = []
+        @names = []
+        @folders = 0
+        @selected = 0
+        @top = 0
+        @list_top = 0
+      end
+
+      def open? = @open
+
+      # What a name sorts by: lower case, with its numbers padded, so disk 2
+      # comes before disk 10.
+      def self.order(name) = name.downcase.gsub(/\d+/) { |digits| digits.rjust(10, "0") }
+
+      # Lists `directory` for the files with one of `extensions`.
+      def open(directory, extensions)
+        @open = true
+        @extensions = extensions
+        enter(directory)
+      end
+
+      def close
+        @open = false
+      end
+
+      # 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)
+
+        select(@selected + step(scancode)) unless step(scancode).zero?
+        jump(scancode)
+        nil
+      end
+
+      # Picks the row at `top`, as Return would.
+      def click(top)
+        row = (top - @list_top) / ROW
+        return nil if row.negative? || @top + row >= @names.size
+
+        @selected = @top + row
+        pick
+      end
+
+      def scroll(rows)
+        @top = (@top + rows).clamp(0, [@names.size - ROWS, 0].max)
+      end
+
+      def draw(left, top, width, title)
+        @painter.text(left, top, title, PauseMenu::BRIGHT)
+        @painter.text(left, top + ROW + 2, shown_directory, PauseMenu::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)
+      end
+
+      private
+
+      # The folder's path, cut at the start to fit.
+      def shown_directory
+        length = @directory.length
+        length > COLUMNS ? "...#{@directory[length - COLUMNS + 3, COLUMNS - 3]}" : @directory
+      end
+
+      def draw_rows(left, width)
+        ROWS.times do |row|
+          index = @top + row
+          break if index >= @names.size
+
+          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)
+          else
+            @painter.text(left, top, name, index < @folders ? PauseMenu::BRIGHT : PauseMenu::TEXT)
+          end
+        end
+      end
+
+      def draw_bar(left)
+        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)
+      end
+
+      def label(index)
+        name = @names[index]
+        name += "/" if index < @folders
+        Painter.fit(name, COLUMNS)
+      end
+
+      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
+        else 0
+        end
+      end
+
+      def select(index)
+        return if @names.empty?
+
+        @selected = index.clamp(0, @names.size - 1)
+        @top = @selected if @selected < @top
+        @top = @selected - ROWS + 1 if @selected >= @top + ROWS
+      end
+
+      # 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
+        return if char.empty? || @names.empty?
+
+        @names.size.times do |offset|
+          index = (@selected + 1 + offset) % @names.size
+          next unless @names[index].downcase.start_with?(char)
+
+          select(index)
+          break
+        end
+      end
+
+      def pick
+        return nil if @names.empty?
+
+        path = File.join(@directory, @names[@selected])
+        return path unless @selected < @folders
+
+        @names[@selected] == ".." ? up : enter(path)
+      end
+
+      def up
+        parent = File.dirname(@directory)
+        return nil if parent == @directory
+
+        from = File.basename(@directory)
+        enter(parent)
+        index = @names.index(from)
+        select(index) unless index.nil?
+        nil
+      end
+
+      def enter(directory)
+        @directory = File.expand_path(directory)
+        folders = []
+        files = []
+        children(@directory).each do |name|
+          next if name.start_with?(".")
+
+          if File.directory?(File.join(@directory, name))
+            folders << name
+          elsif @extensions.include?(File.extname(name).downcase)
+            files << name
+          end
+        end
+        listing(folders, files)
+        nil
+      end
+
+      def listing(folders, files)
+        folders = folders.sort_by { |name| FileBrowser.order(name) }
+        folders.unshift("..") unless File.dirname(@directory) == @directory
+        @folders = folders.size
+        @names = folders + files.sort_by { |name| FileBrowser.order(name) }
+        @selected = 0
+        @top = 0
+      end
+
+      def children(directory)
+        Dir.children(directory)
+      rescue SystemCallError
+        []
+      end
+    end
+  end
+end

data/lib/badline/frontend/frame_report.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The --verbose report every 50 frames: the frame rate, the time each
+    # stage of a frame took on average, the slowest frame's work, and how
+    # the sound's queue fared.
+    class FrameReport
+      STAGES = %w[events emulate audio blit present wait].freeze
+
+      def initialize(sound)
+        @sound = sound
+        @reported_samples = 0
+        clear
+      end
+
+      # Adds a frame's stamps, one as each stage starts and one after the
+      # last.
+      def add(stamps)
+        STAGES.size.times { |stage| @spent[stage] += stamps[stage + 1] - stamps[stage] }
+        took = stamps[-2] - stamps.first
+        @slowest = took if took > @slowest
+      end
+
+      # Reports the 50 frames added over the last `seconds`, and starts
+      # over.
+      def show(seconds)
+        stages = STAGES.each_with_index.map { |name, stage| "#{name} #{(@spent[stage] * 20).round(2)}" }
+        puts "#{(50 / seconds).round(1)} fps, per frame ms: #{stages.join(' ')}, " \
+             "slowest work #{(@slowest * 1000).round(2)}"
+        show_sound(seconds) if @sound.on?
+        clear
+      end
+
+      private
+
+      def clear
+        @spent = Array.new(STAGES.size, 0.0)
+        @slowest = 0.0
+      end
+
+      def show_sound(seconds)
+        sound = @sound
+        rate = (sound.queued - @reported_samples) / seconds
+        queue = sound.high.zero? ? "empty" : "#{(sound.low * 1000).round(1)}-#{(sound.high * 1000).round(1)} ms"
+        puts "  sound #{rate.round} samples/s, queue #{queue}, #{sound.underruns} underruns, #{sound.dropped} dropped"
+        sound.reset_levels
+        @reported_samples = sound.queued
+      end
+    end
+  end
+end