badline 0.7.0 → 0.8.0

data/lib/badline/frontend/confirmation.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The pause menu's question before something power cycles the machine:
+    # a cartridge going in or out, or Quick open starting a file. CANCEL
+    # has the focus, so Return alone changes nothing.
+    class Confirmation
+      TITLES = { cartridge: "INSERT A CARTRIDGE", remove: "REMOVE THE CARTRIDGE", start: "QUICK OPEN" }.freeze
+      WARNINGS = { cartridge: "INSERTING IT POWER CYCLES THE MACHINE.", remove: "REMOVING IT POWER CYCLES THE MACHINE.",
+                   start: "THIS STARTS A NEW MACHINE." }.freeze
+      ANSWERS = { cartridge: "INSERT", remove: "REMOVE", start: "START" }.freeze
+
+      def initialize(painter, buttons)
+        @painter = painter
+        @buttons = buttons
+        @kind = :start
+        @path = ""
+        @open = false
+      end
+
+      def open? = @open
+
+      # Asks about `kind`, :cartridge, :remove or :start, for the file at
+      # `path`.
+      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?
+        painter.text(left, top + 44, WARNINGS.fetch(@kind), PauseMenu::TEXT)
+        painter.text(left, top + 56, "ANYTHING NOT SAVED IS LOST.", PauseMenu::TEXT)
+        @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

data/lib/badline/frontend/menu_dialogs.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The pause menu's screens that take over its panel: the file browser
+    # INSERT and Quick open bring up, and the question before a cartridge
+    # or Quick open power cycles the machine. A disk or tape picked goes
+    # straight in.
+    class MenuDialogs
+      EXTENSIONS = {
+        disk: PauseMenu::DISKS, tape: %w[.tap], cartridge: %w[.crt],
+        program: %w[.d64 .d71 .d81 .g64 .t64 .tap .crt .prg .p00 .sid]
+      }.freeze
+      TITLES = { disk: "INSERT A DISK", tape: "INSERT A TAPE", cartridge: "INSERT A CARTRIDGE",
+                 program: "QUICK OPEN" }.freeze
+
+      ESCAPE = 41
+      RETURN = 40
+      SPACE = 44
+
+      # The machine Quick open started.
+      attr_reader :computer
+
+      def initialize(painter, buttons, media, options)
+        media_path = options.media_path.to_s
+        @buttons = buttons
+        @media = media
+        @options = options
+        @browser = FileBrowser.new(painter, buttons)
+        @confirmation = Confirmation.new(painter, buttons)
+        @browsing = nil
+        @browse_from = media_path.empty? ? Dir.pwd : File.dirname(File.expand_path(media_path))
+        @computer = nil
+      end
+
+      def open? = !@browsing.nil? || @confirmation.open?
+
+      # Opens the browser on the files for `kind`: :disk, :tape, :cartridge
+      # or :program.
+      def browse(kind)
+        @browsing = kind
+        @browser.open(@browse_from, EXTENSIONS.fetch(kind))
+      end
+
+      def ask_remove = @confirmation.ask(:remove, @media.cartridge_name)
+
+      # Puts a dropped disk or tape in its device, or asks before a
+      # cartridge or a program starts, and says whether it asks. Other
+      # files are left alone.
+      def drop(path)
+        extension = File.extname(path).downcase
+        return @media.insert(:disk, path) && false if EXTENSIONS[:disk].include?(extension)
+        return @media.insert(:tape, path) && false if EXTENSIONS[:tape].include?(extension)
+        return false unless EXTENSIONS[:program].include?(extension)
+
+        @confirmation.ask(extension == ".crt" ? :cartridge : :start, path)
+        true
+      end
+
+      # Handles a key, and returns :resume or :swap once a question is
+      # answered yes, or nil.
+      def key(scancode)
+        return browsed(@browser.key(scancode)) unless @browsing.nil?
+        return answer(:cancel) if scancode == ESCAPE
+        return answer(@buttons.focus) if [RETURN, SPACE].include?(scancode)
+
+        direction = PauseMenu::ARROWS[scancode]
+        @buttons.shift(direction == :up ? -1 : 1, 1) if %i[up down].include?(direction)
+        nil
+      end
+
+      # Handles a click on the browser's list at `top`, or on a question's
+      # answer, `action`.
+      def click(action, top) = action == :browse ? browsed(@browser.click(top)) : answer(action)
+
+      def scroll(rows) = @browser.scroll(rows)
+
+      def draw(left, top, width)
+        return @browser.draw(left, top, width, TITLES.fetch(@browsing)) unless @browsing.nil?
+
+        @confirmation.draw(left, top)
+      end
+
+      private
+
+      # Puts the disk or tape picked in, or asks before a cartridge or
+      # Quick open power cycles the machine, and leaves the browser, as Esc
+      # does.
+      def browsed(picked)
+        return nil if picked.nil?
+
+        kind = @browsing
+        @browse_from = @browser.directory
+        @browsing = nil
+        return nil if picked == :cancel
+
+        if %i[disk tape].include?(kind)
+          @media.insert(kind, picked)
+        else
+          @confirmation.ask(kind == :cartridge ? :cartridge : :start, picked)
+        end
+        nil
+      end
+
+      # Does what the question asked about if `action` is :confirm, and
+      # returns :resume, or :swap for a new machine.
+      def answer(action)
+        question = @confirmation.close
+        return nil unless action == :confirm
+
+        path = question[1]
+        case question[0]
+        when :cartridge then @media.attach_cartridge(path) ? :resume : nil
+        when :remove then @media.remove_cartridge && :resume
+        else
+          @computer = @media.start(@options, path)
+          @computer.nil? ? nil : :swap
+        end
+      end
+    end
+  end
+end