badline 0.6.0 → 0.7.0

data/lib/badline/frontend/controls.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+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:
+    #
+    # - 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.
+    class Controls
+      MODES = %i[keyboard joystick mouse1 mouse2 paddles1 paddles2].freeze
+      TAGS = ["", "JOY", "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
+
+      def initialize(computer)
+        @computer = computer
+        @mode = :keyboard
+        @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.
+      def computer=(computer)
+        release_all
+        @computer = computer
+        attach_pot_device
+      end
+
+      def joystick_mode? = @mode == :joystick
+
+      # Whether the host mouse drives a pot device, and so should be held
+      # in relative mode.
+      def pot_device? = MODES.index(@mode) >= 2
+
+      # The title bar's tag for the mode, empty for the keyboard.
+      def tag
+        return "JOY #{@arrows_port}" if joystick_mode?
+
+        TAGS[MODES.index(@mode)]
+      end
+
+      def key(scancode, down)
+        if joystick_mode? && Keys.joystick?(scancode)
+          joystick_key(scancode, down)
+        else
+          c64_key(Keys.c64_key(scancode), down)
+        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
+      end
+
+      def mouse_motion(delta_x, delta_y)
+        return unless pot_device?
+
+        paddles? ? @paddles.move(delta_x, delta_y) : @mouse.move(delta_x, delta_y)
+      end
+
+      def mouse_button(button, down)
+        name = MOUSE_BUTTONS[button]
+        return unless name && pot_device?
+
+        if paddles?
+          down ? @paddles.press(name) : @paddles.release(name)
+        else
+          down ? @mouse.press(name) : @mouse.release(name)
+        end
+      end
+
+      private
+
+      # RESTORE isn't in the key matrix, so it goes to the machine instead.
+      def c64_key(key, down)
+        if key == :restore
+          @computer.press_restore if down
+        else
+          down ? @computer.keyboard.press(key) : @computer.keyboard.release(key)
+        end
+      end
+
+      def paddles? = MODES.index(@mode) >= 4
+
+      # A fresh device on the mode's port, and none on the other.
+      def attach_pot_device
+        ports = @computer.control_ports
+        ports.device1 = nil
+        ports.device2 = nil
+        return unless pot_device?
+
+        if paddles?
+          @paddles = Input::Paddles.new
+          attach_paddles(ports)
+        else
+          @mouse = Input::Mouse1351.new
+          attach_mouse(ports)
+        end
+      end
+
+      def attach_paddles(ports)
+        if port_one?
+          ports.device1 = @paddles
+        else
+          ports.device2 = @paddles
+        end
+      end
+
+      def attach_mouse(ports)
+        if port_one?
+          ports.device1 = @mouse
+        else
+          ports.device2 = @mouse
+        end
+      end
+
+      def port_one? = %i[mouse1 paddles1].include?(@mode)
+
+      def joystick_key(scancode, down)
+        direction = Keys.arrows(scancode)
+        if direction == :none
+          move(joystick(3 - @arrows_port), Keys.wasd(scancode), down)
+        else
+          move(joystick(@arrows_port), direction, down)
+        end
+      end
+
+      def joystick(port) = port == 1 ? @computer.joystick1 : @computer.joystick2
+
+      def move(joystick, direction, down)
+        down ? joystick.press(direction) : joystick.release(direction)
+      end
+
+      def release_all
+        Keys::ARROWS.each_key { |scancode| @computer.keyboard.release(Keys.c64_key(scancode)) }
+        Keys::WASD.each_key { |scancode| @computer.keyboard.release(Keys.c64_key(scancode)) }
+        Keys::ARROWS.each_value do |direction|
+          @computer.joystick1.release(direction)
+          @computer.joystick2.release(direction)
+        end
+      end
+    end
+  end
+end

data/lib/badline/frontend/drive_led.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The true drive's red LED, drawn over the bottom right corner of the
+    # border: bright while the DOS lights it, as it does while a file is
+    # open or after an error, and dim otherwise.
+    class DriveLed
+      WIDTH = 12
+      HEIGHT = 4
+      LEFT = Screen::WIDTH - WIDTH - 8
+      TOP = Screen::HEIGHT - HEIGHT - 6
+
+      LIT = [0xff, 0x20, 0x20].freeze
+      DARK = [0x40, 0x00, 0x00].freeze
+
+      # The LED of the machine's true drive, or nil without one.
+      def self.for(computer)
+        drive = computer.drive1541
+        drive ? new(drive) : nil
+      end
+
+      # Sets SDL.led_rect to where the LED goes.
+      def self.place
+        rect = SDL.led_rect
+        SDL.rect_x(rect, LEFT)
+        SDL.rect_y(rect, TOP)
+        SDL.rect_w(rect, WIDTH)
+        SDL.rect_h(rect, HEIGHT)
+      end
+
+      def initialize(drive)
+        @drive = drive
+      end
+
+      def lit? = @drive.led_on?
+
+      def color = lit? ? LIT : DARK
+
+      # Fills the LED's rectangle in its colour, then puts back the black
+      # that RenderClear clears with.
+      def draw(renderer)
+        DriveLed.place
+        rgb = color
+        SDL.SDL_SetRenderDrawColor(renderer, rgb[0], rgb[1], rgb[2], 255)
+        SDL.SDL_RenderFillRect(renderer, SDL.led_rect)
+        SDL.SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255)
+      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

data/lib/badline/frontend/frame_rate.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # How many cycles a frame clocks and how long it lasts. Without vsync a
+    # frame is one of the machine's frames: on PAL 312 lines of 63 cycles
+    # over 19.95 ms. With vsync a frame lasts one display refresh and clocks as
+    # many cycles as the machine runs in that time, so a 60 Hz display
+    # shows 60 PAL frames of 16,420 cycles a second.
+    #
+    # A display's reported refresh rate is a whole number, and can be some
+    # way off the rate it presents at. #refit sizes the frames to the rate
+    # measured instead, as long as that is within REFIT of the reported one.
+    #
+    # While the sound plays under vsync, the display paces the frames but
+    # the audio device consumes the samples, and the two clocks still drift
+    # apart. #cycles steers the audio queue towards its target: it trims
+    # each frame by up to PROPORTIONAL of the queue's error, and by a trim
+    # that builds up by INTEGRAL a frame while the error lasts, up to
+    # MAX_TRIM, so the queue settles at the target instead of beside it.
+    class FrameRate
+      # A display that reports no refresh rate is taken to run at this.
+      DEFAULT_REFRESH = 60
+      PROPORTIONAL = 0.02
+      INTEGRAL = 0.0001
+      MAX_TRIM = 0.05
+      # Presenting faster than this many times the refresh rate means vsync
+      # isn't waiting for the display.
+      VSYNC_SLACK = 1.5
+      REFIT = 0.1
+
+      attr_reader :base_cycles, :seconds, :refresh, :trim
+
+      # One frame of the region's raster.
+      def self.machine(region)
+        cycles = region.cycles_per_line * region.lines_per_frame
+        new(cycles, cycles.to_f / region.clock_hz, 0, region.clock_hz)
+      end
+
+      def self.display(refresh, clock_hz)
+        refresh = DEFAULT_REFRESH unless refresh.positive?
+        cycles = clock_hz / refresh
+        new(cycles, cycles.to_f / clock_hz, refresh, clock_hz)
+      end
+
+      def initialize(base_cycles, seconds, refresh, clock_hz)
+        @base_cycles = base_cycles
+        @seconds = seconds
+        @refresh = refresh
+        @clock_hz = clock_hz
+        @trim = 0.0
+      end
+
+      # The cycles for the next frame, steering the audio queue's `level`
+      # towards `target` (both in seconds).
+      def cycles(level, target)
+        error = (target - level) / target
+        error = 1.0 if error > 1.0
+        error = -1.0 if error < -1.0
+        @trim += INTEGRAL * error
+        @trim = MAX_TRIM if @trim > MAX_TRIM
+        @trim = -MAX_TRIM if @trim < -MAX_TRIM
+        (@base_cycles * (1.0 + @trim + (PROPORTIONAL * error))).round
+      end
+
+      # Sizes the frames to `frames` that lasted `elapsed` seconds.
+      def refit(frames, elapsed)
+        return unless frames.positive? && elapsed.positive?
+        return if ((frames / elapsed) - @refresh).abs > @refresh * REFIT
+
+        @base_cycles = (@clock_hz * elapsed / frames).round
+        @seconds = @base_cycles.to_f / @clock_hz
+      end
+
+      # Whether `frames` presented in `elapsed` seconds kept to the display.
+      def vsync_holds?(frames, elapsed)
+        return true unless elapsed.positive?
+
+        frames / elapsed <= @refresh * VSYNC_SLACK
+      end
+    end
+  end
+end

data/lib/badline/frontend/gamepads.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # Host game controllers wired onto the control ports: the first
+    # controller found drives joystick 2, the port most games read, and a
+    # second one joystick 1. PadPort holds the mapping.
+    #
+    # The controllers are polled every frame, and rescanned whenever SDL
+    # reports one added or removed.
+    class Gamepads
+      PORTS = [2, 1].freeze
+
+      def initialize(computer, verbose)
+        @verbose = verbose
+        @controllers = []
+        @ports = [PadPort.new(computer.joystick2), PadPort.new(computer.joystick1)]
+        @buttons = Array.new(PadPort::BUTTON_COUNT, 0)
+        @available = SDL.SDL_InitSubSystem(SDL::INIT_GAMECONTROLLER).zero?
+        puts "No game controllers: #{SDL.SDL_GetError}" if @verbose && !@available
+      end
+
+      # Wires the controllers to another machine's joysticks, which take
+      # what they hold on the next poll.
+      def computer=(computer)
+        @ports.each(&:release)
+        @ports = [PadPort.new(computer.joystick2), PadPort.new(computer.joystick1)]
+      end
+
+      def rescan
+        return unless @available
+
+        close
+        index = 0
+        count = SDL.SDL_NumJoysticks
+        while index < count && @controllers.size < PORTS.size
+          open_controller(index) if SDL.SDL_IsGameController(index) != 0
+          index += 1
+        end
+      end
+
+      def poll
+        @controllers.each_with_index { |controller, index| @ports[index].update(active(controller)) }
+      end
+
+      def close
+        @controllers.each { |controller| SDL.SDL_GameControllerClose(controller) }
+        @controllers = []
+        @ports.each(&:release)
+      end
+
+      private
+
+      def open_controller(index)
+        controller = SDL.SDL_GameControllerOpen(index)
+        # SDL returns NULL when the controller won't open, which Spinel's FFI
+        # reads as nil.
+        return if controller.nil?
+
+        puts "Gamepad on joystick #{PORTS[@controllers.size]}: #{SDL.SDL_GameControllerName(controller)}" if @verbose
+        @controllers << controller
+      end
+
+      def active(controller)
+        buttons = @buttons
+        button = 0
+        while button < PadPort::BUTTON_COUNT
+          buttons[button] = SDL.SDL_GameControllerGetButton(controller, button)
+          button += 1
+        end
+        PadPort.active(buttons, SDL.SDL_GameControllerGetAxis(controller, PadPort::LEFT_X),
+                       SDL.SDL_GameControllerGetAxis(controller, PadPort::LEFT_Y))
+      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/keys.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # SDL scancodes follow key positions on a US layout. They map onto the C64
+    # keys and, in joystick mode, the joystick directions.
+    module Keys
+      TAB = 43
+
+      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
+
+      OTHERS = {
+        40 => :return, 41 => :run_stop, 42 => :delete, 44 => :space,
+        45 => :-, 46 => :"=", 49 => :"@", 51 => :";", 52 => :":",
+        48 => :up, 53 => :left, 54 => :",", 55 => :".", 56 => :/,
+        58 => :f1, 60 => :f3, 62 => :f5, 64 => :f7,
+        74 => :clr_home, 75 => :restore, 77 => :£, 79 => :cursor_h, 80 => :cursor_left,
+        81 => :cursor_v, 82 => :cursor_up, 85 => :*, 87 => :+,
+        224 => :control, 225 => :lshift, 226 => :cbm, 229 => :rshift
+      }.freeze
+
+      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
+
+      def self.c64_key(scancode)
+        if scancode.between?(4, 29)
+          LETTERS[scancode - 4]
+        elsif scancode.between?(30, 39)
+          DIGITS[scancode - 30]
+        else
+          OTHERS[scancode] || :none
+        end
+      end
+
+      def self.arrows(scancode) = ARROWS[scancode] || :none
+
+      def self.wasd(scancode) = WASD[scancode] || :none
+
+      def self.joystick?(scancode) = ARROWS.key?(scancode) || WASD.key?(scancode)
+    end
+  end
+end