badline 0.5.1 → 0.6.1

data/lib/badline/frontend/boot.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Badline
+  # The window both builds play the machine in, badline-ruby on CRuby and
+  # the native badline compiled with Spinel, so it stays inside the subset
+  # of Ruby Spinel compiles. On CRuby, require badline/ffi before it.
+  module Frontend
+    # Builds the machine the options ask for and plays it in the window
+    # until it closes, and returns the exit status: 1 when the media won't
+    # attach, an --at key names nothing or an event fails, which it warns
+    # about.
+    def self.run(options)
+      error = Timeline.error(options.timeline)
+      unless error.empty?
+        warn "#{options.program}: #{error}"
+        return 1
+      end
+
+      begin
+        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
+        warn "#{options.program}: #{options.media_path}: #{e.message}"
+        return 1
+      end
+      timeline = Timeline.new(options)
+      App.new(computer, options, timeline).run
+      timeline.failed? ? 1 : 0
+    end
+
+    # The machine a .vsf snapshot holds, built as the saved one was, or a
+    # new one built from the options with the media attached.
+    def self.boot(options)
+      media = options.media_path
+      if options.snapshot?
+        computer = Snapshot.load(media) { |line| puts line }
+        puts "Restored #{media}"
+        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)
+      Media::TrueDrive.plug(computer) if options.true_drive?
+      unless media.nil?
+        puts Media.attach(computer, media, autostart: options.autostart?, song: options.song,
+                                           disk: { read_only: options.read_only? })
+      end
+      computer
+    end
+  end
+end

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/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/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

data/lib/badline/frontend/pacer.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # Decides how many cycles each frame clocks and how long it waits.
+    #
+    # With vsync, a frame lasts one display refresh (see FrameRate), and
+    # presenting it waits for the display, so #wait has nothing left to do.
+    # While the sound plays, each frame's cycles are trimmed to keep the
+    # audio queue at Sound::AHEAD. If presenting doesn't wait, as when the
+    # display's driver has vsync off, #check falls back to the timer, and
+    # until then the sound holds any frame that would take its queue past
+    # SAFETY, so no samples are dropped. #measure fits the frames to the
+    # rate the display presents at, measured over the whole run.
+    #
+    # Without vsync, a frame is one of the machine's frames, 20 ms on PAL.
+    # With the sound playing, #wait lasts until the audio queue is down to
+    # Sound::AHEAD; otherwise it waits out the rest of the frame.
+    class Pacer
+      # The frame after which the app first checks that vsync holds.
+      EARLY_CHECK = 10
+      SAFETY = Sound::AHEAD * 2
+
+      attr_reader :rate
+
+      def initialize(paced:, vsync:, verbose:, region: Region::PAL)
+        @paced = paced
+        @verbose = verbose
+        @vsync = paced && vsync
+        @region = region
+        @rate = FrameRate.machine(region)
+        @deadline = 0.0
+        @measured_frames = 0
+        @measured_seconds = 0.0
+      end
+
+      def vsync? = @vsync
+
+      # Fits the frames to the display's refresh rate, once the window has
+      # been opened with vsync.
+      def fit(refresh)
+        @rate = FrameRate.display(refresh, @region.clock_hz)
+        puts "Display #{@rate.refresh} Hz, vsync: #{@rate.base_cycles} cycles a frame" if @verbose
+      end
+
+      def start(at)
+        @deadline = at
+      end
+
+      def cycles(sound)
+        return @rate.base_cycles unless @vsync && sound.playing?
+
+        @rate.cycles(sound.level, Sound::AHEAD)
+      end
+
+      def wait(sound)
+        return unless @paced
+
+        if sound.playing?
+          sound.wait(@vsync ? SAFETY : Sound::AHEAD)
+        elsif !@vsync
+          wait_for_timer
+        end
+      end
+
+      # Adds `frames` presented over `elapsed` seconds to the measure of the
+      # display's rate, and fits the frames to the rate measured so far.
+      def measure(frames, elapsed)
+        return unless @vsync
+
+        @measured_frames += frames
+        @measured_seconds += elapsed
+        @rate.refit(@measured_frames, @measured_seconds)
+      end
+
+      # Falls back to the timer if the last `frames`, presented over
+      # `elapsed` seconds up to `at`, didn't wait for the display.
+      def check(frames, elapsed, at)
+        return if !@vsync || @rate.vsync_holds?(frames, elapsed)
+
+        puts "Vsync doesn't hold the display's #{@rate.refresh} Hz, so a timer paces the frames instead." if @verbose
+        @vsync = false
+        @deadline = at
+      end
+
+      private
+
+      def wait_for_timer
+        @deadline += @rate.seconds
+        started = now
+        @deadline = started if @deadline < started - @rate.seconds
+        left = @deadline - started
+        SDL.SDL_Delay((left * 1000).to_i) if left > 0.001
+        nil while now < @deadline
+      end
+
+      def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/badline/frontend/pad_port.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # One game controller's state wired onto a joystick: the D-pad and the
+    # left stick both steer, and every face and shoulder button fires. It
+    # only releases directions it pressed itself, so the keyboard's joystick
+    # keys keep working with a controller connected.
+    class PadPort
+      DEADZONE = 8_000
+
+      # SDL_GameControllerButton values.
+      BUTTON_COUNT = 15
+      BUTTONS = {
+        up: [11], down: [12], left: [13], right: [14],
+        fire: [0, 1, 2, 3, 9, 10] # A, B, X, Y and the shoulders
+      }.freeze
+
+      # SDL_GameControllerAxis values, and the sign that steers each way.
+      LEFT_X = 0
+      LEFT_Y = 1
+      AXES = { up: [LEFT_Y, -1], down: [LEFT_Y, 1], left: [LEFT_X, -1], right: [LEFT_X, 1] }.freeze
+
+      DIRECTIONS = %i[up down left right fire].freeze
+
+      attr_reader :pressed
+
+      def initialize(joystick)
+        @joystick = joystick
+        @pressed = []
+      end
+
+      # The directions a controller holds, from its `buttons` (0 or 1 for
+      # each SDL button) and its left stick.
+      def self.active(buttons, left_x, left_y)
+        DIRECTIONS.select do |direction|
+          BUTTONS[direction].any? { |button| buttons[button] != 0 } ||
+            tilted?(direction, left_x, left_y)
+        end
+      end
+
+      def self.tilted?(direction, left_x, left_y)
+        return false if direction == :fire
+
+        axis, sign = AXES[direction]
+        (axis == LEFT_X ? left_x : left_y) * sign > DEADZONE
+      end
+
+      # Presses what the controller holds and releases what it let go of.
+      def update(active)
+        @pressed.each { |direction| @joystick.release(direction) unless active.include?(direction) }
+        active.each { |direction| @joystick.press(direction) }
+        @pressed = active
+      end
+
+      def release
+        update([])
+      end
+    end
+  end
+end