badline 0.6.1 → 0.8.0

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The SID player's INFO view: the tune's STIL entry, and the playing
+    # subtune's, laid out as STIL.txt lays them out but reflowed to the
+    # window's width. A line of STIL's that runs to its width goes on into
+    # the next, and a shorter one ends a paragraph. Text longer than the view
+    # scrolls, by the wheel, the up and down keys, or a click or drag along
+    # the scroll bar beside it.
+    class InfoView
+      HEIGHT = VisualizerView::HEIGHT
+      LINE = 10
+      ROWS = HEIGHT / LINE
+      LEFT = SIDView::LEFT
+      BAR = 6
+      BAR_LEFT = PlayerHeader::WIDTH - 16 - BAR
+      COLUMNS = (BAR_LEFT - LEFT - 8) / Painter::GLYPH
+      LABEL = 9
+
+      # How long a line of STIL's is when it runs on into the next.
+      FULL = 60
+
+      attr_reader :offset
+
+      def initialize(painter, buttons, top)
+        @painter = painter
+        @buttons = buttons
+        @top = top
+        @lines = []
+        @offset = 0
+      end
+
+      # Shows the tune's fields, then the subtune's under its number, from
+      # the top.
+      def show(fields, subtune, subtune_fields)
+        lines = InfoView.layout(fields)
+        lines += ["", "(##{subtune})"] + InfoView.layout(subtune_fields) unless subtune_fields.empty?
+        @lines = lines.empty? ? ["No STIL entry for this tune."] : lines
+        @offset = 0
+      end
+
+      def scroll(rows)
+        @offset = (@offset + rows).clamp(0, last_offset)
+      end
+
+      # Scrolls to the place `top` points at along the scroll bar.
+      def scroll_along(top)
+        @offset = ((top - @top).to_f / HEIGHT * @lines.size).round.clamp(0, last_offset)
+      end
+
+      def draw
+        index = 0
+        while index < ROWS && @offset + index < @lines.size
+          @painter.text(LEFT, @top + (index * LINE), @lines[@offset + index], SIDView::TEXT)
+          index += 1
+        end
+        draw_bar if @lines.size > ROWS
+      end
+
+      # Each field's label, right-aligned as in STIL.txt, before its text
+      # reflowed into the columns beside it.
+      def self.layout(fields)
+        lines = []
+        fields.each do |field|
+          label = "#{field.name}:".rjust(LABEL - 1)
+          paragraphs(field.text).each do |paragraph|
+            wrap(paragraph, COLUMNS - LABEL).each do |line|
+              lines << "#{label} #{line}"
+              label = " " * (LABEL - 1)
+            end
+          end
+        end
+        lines
+      end
+
+      # The text's lines joined where one ran to STIL's width.
+      def self.paragraphs(text)
+        paragraphs = []
+        full = false
+        text.split("\n").each do |line|
+          if full
+            paragraphs[-1] = "#{paragraphs[-1]} #{line.strip}"
+          else
+            paragraphs << line.strip
+          end
+          full = line.length >= FULL
+        end
+        paragraphs
+      end
+
+      # The text broken at spaces into lines of at most `columns`, and a word
+      # longer than that broken where it has to be.
+      def self.wrap(text, columns)
+        lines = []
+        rest = text
+        while rest.length > columns
+          cut = rest.rindex(" ", columns)
+          cut = columns if cut.nil? || cut.zero?
+          lines << rest[0, cut].rstrip
+          rest = rest[cut, rest.length - cut].lstrip
+        end
+        lines << rest
+        lines
+      end
+
+      private
+
+      def last_offset = [@lines.size - ROWS, 0].max
+
+      def draw_bar
+        @buttons.area([BAR_LEFT, @top, BAR, HEIGHT], :scroll)
+        @painter.box(BAR_LEFT, @top, BAR, HEIGHT, SIDView::BOX)
+        thumb = [HEIGHT * ROWS / @lines.size, 8].max
+        place = (HEIGHT - thumb) * @offset / [last_offset, 1].max
+        @painter.box(BAR_LEFT, @top + place, BAR, thumb, SIDView::TEXT)
+      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

data/lib/badline/frontend/menu_media.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # What the pause menu puts in the machine and takes out: disks, tapes
+    # and cartridges, whether disks are writable, which carries over from
+    # one disk to the next, and the disk's set, which PREVIOUS and NEXT step
+    # through. It keeps what last went wrong for the page to show.
+    class MenuMedia
+      attr_reader :disk_path, :problem
+      attr_writer :computer
+
+      def initialize(disk_path, writable)
+        @disk_path = disk_path
+        @writable = writable
+        @set_path = ""
+        @set = []
+        @problem = ""
+        @computer = nil
+      end
+
+      def writable? = @writable
+
+      def inserted?
+        drive = @computer.drive1541
+        drive.nil? ? @computer.mounted? : !drive.disk.nil?
+      end
+
+      # Puts a disk in device 8 or a tape in the datasette, `kind` :disk or
+      # :tape.
+      def insert(kind, path)
+        @problem = ""
+        if kind == :disk
+          Media.insert_disk(@computer, path, read_only: !@writable)
+          @disk_path = path
+        else
+          @computer.datasette.insert(Storage::TAP.new(path))
+        end
+      rescue ArgumentError, SystemCallError, Storage::TAP::FormatError, Storage::T64::FormatError,
+             Storage::G64Image::FormatError => e
+        @problem = e.message
+      end
+
+      # Does what the Drive page's :eject_disk, :previous_disk, :next_disk,
+      # :protect or :unprotect asks.
+      def drive(action)
+        case action
+        when :eject_disk then eject_disk
+        when :previous_disk then step_disk(-1)
+        when :next_disk then step_disk(1)
+        else writable(action == :unprotect)
+        end
+      end
+
+      def eject_disk
+        drive = @computer.drive1541
+        drive.nil? ? @computer.unmount : drive.insert(nil)
+        @disk_path = ""
+      end
+
+      # Sets whether disks are writable, for the disk in the drive too,
+      # which goes in again as the notch now says.
+      def writable(writable)
+        @writable = writable
+        insert(:disk, @disk_path) if inserted? && !@disk_path.empty?
+      end
+
+      # The disks of the set the disk in the drive belongs to.
+      def disk_set
+        return [] if @disk_path.empty?
+
+        unless @set_path == @disk_path
+          @set = Media::DiskSet.around(@disk_path)
+          @set_path = @disk_path
+        end
+        @set
+      end
+
+      # Puts the disk `step` before or after this one in its set in the
+      # drive, if there is one.
+      def step_disk(step)
+        set = disk_set
+        index = set.index(@disk_path)
+        return if index.nil? || !(index + step).between?(0, set.size - 1)
+
+        insert(:disk, set[index + step])
+      end
+
+      # 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
+      end
+
+      # The name the cartridge in the expansion port gives itself, or an
+      # empty one.
+      def cartridge_name
+        cartridge = @computer.address_bus.cartridge
+        cartridge.nil? ? "" : cartridge.name
+      end
+
+      # Takes the cartridge out with the power off.
+      def remove_cartridge
+        @computer.address_bus.detach_cartridge
+        @computer.power_cycle!
+      end
+
+      # 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)
+        @disk_path = PauseMenu.disk_path(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
+      end
+    end
+  end
+end

data/lib/badline/frontend/menu_pages.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The pause menu's sections, each showing a part of the machine's
+    # hardware as it stands, in one column: what's there, and under it a
+    # row for each thing to do, a setting showing its value on the right,
+    # which a press steps on.
+    class MenuPages
+      TEXT = PauseMenu::TEXT
+      DIM = PauseMenu::DIM
+      LINE = 12
+      COLUMNS = 25
+      ROW_WIDTH = 200
+
+      WARNING = 0xff7a6b
+
+      PORT_DEVICES = %i[joystick mouse paddles].freeze
+      PORT_NAMES = %w[JOY MOUSE PADDLES].freeze
+      PORT_ACTIONS = [%i[port1_joystick port1_mouse port1_paddles], %i[port2_joystick port2_mouse port2_paddles]].freeze
+      POTS = [%i[none mouse1 paddles1], %i[none mouse2 paddles2]].freeze
+
+      # The disks, tapes and cartridges the pages put in and take out.
+      attr_reader :media
+
+      def initialize(painter, buttons, disk_path, options)
+        @painter = painter
+        @buttons = buttons
+        @media = MenuMedia.new(disk_path, options.writable?)
+        @reu_kb = options.reu
+        @computer = nil
+        @controls = nil
+        @sound = nil
+        @left = 0
+        @top = 0
+      end
+
+      # The machine the pages show and change.
+      def machine(computer, controls, sound)
+        @computer = computer
+        @media.computer = computer
+        @controls = controls
+        @sound = sound
+      end
+
+      def draw(page, left, top)
+        problem = @media.problem
+        @painter.text(left, top + 186, problem[0, COLUMNS], WARNING) unless problem.empty?
+        @left = left
+        @top = top
+        case page
+        when :drive then draw_drive
+        when :datasette then draw_datasette
+        when :expansion then draw_expansion
+        when :ports then draw_ports
+        when :sound then draw_sound
+        else draw_power
+        end
+      end
+
+      def perform(action)
+        case action
+        when :eject_disk, :previous_disk, :next_disk, :protect, :unprotect then @media.drive(action)
+        when :tape_stop then @computer.datasette.stop!
+        when :tape_down then @computer.datasette.play!
+        when :tape_rewind then @computer.datasette.rewind
+        when :tape_eject then @computer.datasette.eject
+        when :keys_c64, :keys_joystick then keys(action == :keys_c64 ? :keyboard : :joystick)
+        when :swap then @controls.swap_ports
+        when :sound_on, :mute then @sound.toggle_mute unless @sound.muted? == (action == :mute)
+        when :sid6581, :sid8580 then @computer.sid.model = action == :sid8580 ? :mos8580 : :mos6581
+        when :reset then @computer.reset!
+        when :power_cycle then @computer.power_cycle!
+        else pick_port(action)
+        end
+      end
+
+      private
+
+      def draw_drive
+        media = @media
+        inserted = media.inserted?
+        set = inserted ? media.disk_set : []
+        place = set.size < 2 ? "" : " #{set.index(media.disk_path).to_i + 1} OF #{set.size}"
+        info("DISK#{place}", inserted ? File.basename(media.disk_path) : "")
+        row("INSERT...", :insert_disk)
+        row("EJECT", :eject_disk)
+        unless set.size < 2
+          row("PREVIOUS DISK", :previous_disk)
+          row("NEXT DISK", :next_disk)
+        end
+        toggle("WRITABLE", :writable, [%w[OFF ON], %i[protect unprotect], media.writable? ? 1 : 0])
+        skip
+        info("DEVICE", @computer.drive1541.nil? ? "FAST LOADING" : "1541, TRUE DRIVE")
+      end
+
+      def draw_datasette
+        datasette = @computer.datasette
+        tape = datasette.tape
+        info("TAPE", tape.nil? ? "" : File.basename(tape.path))
+        row("INSERT...", :insert_tape)
+        row("EJECT", :tape_eject)
+        toggle("PLAY", :tape_play, [%w[UP DOWN], %i[tape_stop tape_down], datasette.playing? ? 1 : 0])
+        row("REWIND", :tape_rewind)
+        skip
+        info("MOTOR", datasette.motor? ? "ON" : "OFF")
+      end
+
+      def draw_expansion
+        cartridge = @computer.address_bus.cartridge
+        info("CARTRIDGE", cartridge.nil? ? "" : cartridge.name)
+        row("INSERT...", :insert_cartridge)
+        row("REMOVE", :remove_cartridge)
+        row("FREEZE", :freeze) if !cartridge.nil? && cartridge.freezer?
+        return if @reu_kb.nil?
+
+        skip
+        info("RAM EXPANSION", "REU, #{@reu_kb} KB")
+      end
+
+      def draw_ports
+        toggle("PORT 1", :port1, [PORT_NAMES, PORT_ACTIONS[0], PORT_DEVICES.index(port_device(1))])
+        toggle("PORT 2", :port2, [PORT_NAMES, PORT_ACTIONS[1], PORT_DEVICES.index(port_device(2))])
+        joystick = @controls.joystick_mode?
+        toggle("KEYS", :keys, [%w[C64 JOYSTICK], %i[keys_c64 keys_joystick], joystick ? 1 : 0])
+        return unless joystick
+
+        row("SWAP JOYSTICKS", :swap)
+        skip
+        arrows = @controls.arrows_port
+        info("ARROWS, SPACE", "PORT #{arrows}")
+        info("WASD, LEFT SHIFT", "PORT #{3 - arrows}")
+      end
+
+      def draw_sound
+        if @sound.on?
+          toggle("OUTPUT", :output, [%w[ON MUTED], %i[sound_on mute], @sound.muted? ? 1 : 0])
+        else
+          info("OUTPUT", "OFF")
+        end
+        toggle("SID", :sid, [%w[6581 8580], %i[sid6581 sid8580], @computer.sid.model == :mos8580 ? 1 : 0])
+      end
+
+      def draw_power
+        row("RESET", :reset)
+        row("POWER CYCLE", :power_cycle)
+        skip
+        row("QUIT", :quit)
+      end
+
+      # A label, and its value under it, or NONE in the dim colour when the
+      # value is empty.
+      def info(label, value)
+        @painter.text(@left, @top, label, DIM)
+        if value.empty?
+          @painter.text(@left, @top + LINE, "NONE", DIM)
+        else
+          @painter.text(@left, @top + LINE, Painter.fit(value, COLUMNS), TEXT)
+        end
+        @top += (LINE * 2) + 6
+      end
+
+      def row(label, action, value = "")
+        @buttons.row([@left, @top, ROW_WIDTH], label, action, value)
+        @top += Buttons::HEIGHT + 2
+      end
+
+      def toggle(label, action, choices)
+        @buttons.toggle([@left, @top, ROW_WIDTH], label, action, choices)
+        @top += Buttons::HEIGHT + 2
+      end
+
+      def skip
+        @top += LINE
+      end
+
+      def keys(mode) = @controls.joystick_mode = mode == :joystick
+
+      def port_device(port)
+        index = POTS[port - 1].index(@controls.pot)
+        index.nil? ? :joystick : PORT_DEVICES[index]
+      end
+
+      # Plugs the device a choice such as :port1_mouse names into its port.
+      def pick_port(action)
+        index = PORT_ACTIONS[0].include?(action) ? 0 : 1
+        choice = PORT_ACTIONS[index].index(action)
+        plug_device(index + 1, choice) unless choice.nil? || choice == PORT_DEVICES.index(port_device(index + 1))
+      end
+
+      # Plugs PORT_DEVICES[choice] into the port. A joystick there takes out
+      # the pot device.
+      def plug_device(port, choice)
+        @controls.plug(POTS[port - 1][choice])
+      end
+    end
+  end
+end