badline 0.6.1 → 0.8.0

data/lib/badline/frontend/buttons.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+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.
+    class Buttons
+      PAD = 2
+      HEIGHT = Painter::GLYPH + (PAD * 2)
+
+      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)
+        @pointer_x = left
+        @pointer_y = top
+      end
+
+      # Draws a button labelled `label` with its top left at `left`, `top`,
+      # and returns its width.
+      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, @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)
+        size = (Painter::GLYPH * scale) + (PAD * 2)
+        place(left, top, size, size, action)
+        @painter.icon(name, left + PAD, top + PAD, color(@actions.size - 1), scale:)
+        size
+      end
+
+      # Makes a box drawn elsewhere clickable, such as the bar showing the
+      # time played.
+      def area(box, action)
+        place(box[0], box[1], box[2], box[3], action)
+      end
+
+      # 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
+          if inside?(index, left, top)
+            return @actions[index] unless @focusable[index]
+
+            found ||= @actions[index]
+          end
+          index += 1
+        end
+        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)
+        @lefts << left
+        @tops << top
+        @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) || @actions[index] == @focus ? @bright : @text
+
+      def inside?(index, left, top)
+        left >= @lefts[index] && left < @lefts[index] + @widths[index] &&
+          top >= @tops[index] && top < @tops[index] + @heights[index]
+      end
+    end
+  end
+end

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/filter_view.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # Draws the SID's filter as the player shows it: its modes, cutoff,
+    # resonance and volume, and its response across the audible range on
+    # the chip playing, whose cutoff curve the two models don't share.
+    class FilterView
+      TEXT = SIDView::TEXT
+      BRIGHT = SIDView::BRIGHT
+      DIM = SIDView::DIM
+      BOX = SIDView::BOX
+
+      MODES = ["LP", "BP", "HP", "3 OFF"].freeze
+
+      LEFT = SIDView::LEFT
+      CURVE_LEFT = 224
+      WIDTH = SIDView::WAVE_WIDTH
+      HEIGHT = SIDView::PANEL_HEIGHT
+
+      # The lowest and highest frequencies on the curve's axis.
+      LOW_HZ = 30.0
+      HIGH_HZ = 16_000.0
+
+      def initialize(painter)
+        @painter = painter
+        @curve = Array.new(WIDTH + 1, 0)
+      end
+
+      def draw(history, frame, top, model)
+        cutoff = (history.register(frame, 0x15) & 0x07) | (history.register(frame, 0x16) << 3)
+        resonance = history.register(frame, 0x17) >> 4
+        mode_volume = history.register(frame, 0x18)
+        hertz = SID::Filter::W0.fetch(model)[cutoff] / (2 * Math::PI * SID::Filter::SCALE)
+        paint = @painter
+        paint.text(LEFT, top, "FILTER", BRIGHT)
+        x = LEFT + 64
+        MODES.each_with_index do |name, bit|
+          x += paint.text(x, top, name, mode_volume[bit + 4] == 1 ? BRIGHT : DIM) + 8
+        end
+        paint.text(LEFT, top + 16, format("CUTOFF $%<cutoff>03X", cutoff:), TEXT)
+        paint.text(LEFT, top + 28, format("  %<hertz>d HZ", hertz: hertz.round), TEXT)
+        paint.text(LEFT, top + 40, format("RES %<res>X  VOL %<vol>X", res: resonance, vol: mode_volume & 0x0f), TEXT)
+        draw_curve(hertz, resonance, mode_volume, top)
+      end
+
+      private
+
+      # The gain for the modes selected on a logarithmic axis, with the
+      # cutoff marked.
+      def draw_curve(cutoff_hertz, resonance, mode_volume, top)
+        paint = @painter
+        paint.box(CURVE_LEFT, top, WIDTH, HEIGHT, BOX)
+        return paint.text(CURVE_LEFT + 8, top + 8, "NO MODE", DIM) if mode_volume.nobits?(0x70)
+
+        quality = 0.707 + (resonance / 15.0)
+        cutoff = [cutoff_hertz, 1.0].max
+        points = @curve
+        x = 0
+        while x <= WIDTH
+          hertz = LOW_HZ * ((HIGH_HZ / LOW_HZ)**(x.to_f / WIDTH))
+          decibels = gain(hertz / cutoff, quality, mode_volume).clamp(-36.0, 12.0)
+          points[x] = Painter.point(CURVE_LEFT + x, top + 8 + (((12.0 - decibels) * (HEIGHT - 12)) / 48.0).round)
+          x += 1
+        end
+        paint.polyline(points, BRIGHT)
+        marker = (WIDTH * Math.log(cutoff / LOW_HZ) / Math.log(HIGH_HZ / LOW_HZ)).round
+        paint.box(CURVE_LEFT + marker, top, 1, HEIGHT, DIM) if marker.between?(0, WIDTH)
+      end
+
+      # The gain in decibels of a two-pole state-variable filter at `ratio`
+      # of its cutoff, summing the low-, band- and high-pass outputs chosen.
+      def gain(ratio, quality, mode_volume)
+        real = 1.0 - (ratio * ratio)
+        imaginary = ratio / quality
+        denominator = (real * real) + (imaginary * imaginary)
+        out_real = 0.0
+        out_imaginary = 0.0
+        if mode_volume.anybits?(0x10)
+          out_real += real / denominator
+          out_imaginary -= imaginary / denominator
+        end
+        if mode_volume.anybits?(0x20)
+          out_real += ratio * imaginary / denominator
+          out_imaginary += ratio * real / denominator
+        end
+        if mode_volume.anybits?(0x40)
+          out_real -= ratio * ratio * real / denominator
+          out_imaginary += ratio * ratio * imaginary / denominator
+        end
+        magnitude = Math.sqrt((out_real * out_real) + (out_imaginary * out_imaginary))
+        20.0 * Math.log([magnitude, 1.0e-6].max) / Math.log(10)
+      end
+    end
+  end
+end