badline 0.6.0 → 0.7.0

data/.claude/hooks/session-start.sh

@@ -1,57 +0,0 @@
-#!/bin/bash
-# Prepares a Claude Code on the web container to run `bundle exec rubocop`
-# and `bundle exec rspec`. The regression suites need vendor/ and aren't set
-# up here.
-set -euo pipefail
-
-if [ "${CLAUDE_CODE_REMOTE:-}" != "true" ]; then
-  exit 0
-fi
-
-cd "${CLAUDE_PROJECT_DIR:-$(dirname "$0")/../..}"
-
-# The SDL specs open libSDL2 through Fiddle, so only the runtime library is
-# needed, as in CI.
-if ! ldconfig -p | grep 'libSDL2-2\.0\.so\.0' >/dev/null; then
-  export DEBIAN_FRONTEND=noninteractive
-  apt-get update -qq
-  apt-get install -y -qq libsdl2-2.0-0 >/dev/null
-fi
-
-# The image ships Ruby 3.3 and an rbenv. Install the newest Ruby 4.0.x, as
-# CI's ruby-version "4.0" picks, from the prebuilt binaries setup-ruby uses,
-# unless a 4.0 is installed already.
-export RBENV_ROOT=/opt/rbenv
-export PATH="$RBENV_ROOT/bin:$RBENV_ROOT/shims:$PATH"
-ruby_version=$(rbenv versions --bare | grep -E '^4\.0\.[0-9]+$' | sort -V | tail -1 || true)
-if [ -z "$ruby_version" ]; then
-  ruby_version=$(curl -fsSL https://raw.githubusercontent.com/ruby/setup-ruby/master/ruby-builder-versions.json |
-    ruby -rjson -e 'puts JSON.parse($stdin.read)["ruby"].grep(/\A4\.0\.\d+\z/).max_by { Gem::Version.new(_1) }')
-  # The binaries only run from the prefix they were built with, so unpack
-  # there and link it into rbenv.
-  . /etc/os-release
-  prefix="/opt/hostedtoolcache/Ruby/$ruby_version/x64"
-  mkdir -p "$prefix"
-  if curl -fsSL "https://github.com/ruby/ruby-builder/releases/download/ruby-$ruby_version/ruby-$ruby_version-ubuntu-$VERSION_ID-x64.tar.gz" |
-      tar -xz -C "$prefix" --strip-components=1; then
-    ln -sfn "$prefix" "$RBENV_ROOT/versions/$ruby_version"
-  else
-    # No binary for this Ubuntu release: build from source, which takes minutes.
-    rm -rf "$prefix"
-    git -C "$RBENV_ROOT/plugins/ruby-build" pull --ff-only -q || true
-    MAKE_OPTS="-j$(nproc)" rbenv install --skip-existing "$ruby_version"
-  fi
-fi
-rbenv global "$ruby_version"
-rbenv rehash
-
-# Put rbenv's shims ahead of /usr/local/bin/ruby for the session.
-if [ -n "${CLAUDE_ENV_FILE:-}" ]; then
-  {
-    echo "export RBENV_ROOT=$RBENV_ROOT"
-    echo "export PATH=\"$RBENV_ROOT/bin:$RBENV_ROOT/shims:\$PATH\""
-  } >> "$CLAUDE_ENV_FILE"
-fi
-
-# Bundler switches to the version Gemfile.lock was bundled with.
-bundle install --jobs "$(nproc)"

data/.claude/settings.json

@@ -1,14 +0,0 @@
-{
-  "hooks": {
-    "SessionStart": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/session-start.sh"
-          }
-        ]
-      }
-    ]
-  }
-}

data/lib/badline/audio/sdl_sink.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Audio
-    # The host's audio device, fed through SDL's queue: mono signed 16-bit
-    # samples go in at the device's rate and SDL plays them out behind us.
-    class SDLSink
-      class Error < Playback::DeviceError; end
-
-      # int freq; Uint16 format; Uint8 channels, silence; Uint16 samples,
-      # padding; Uint32 size; then the callback and userdata pointers.
-      SPEC_LAYOUT = "lSCCSSLQQ"
-
-      attr_reader :rate
-
-      # With `exact_rate` false SDL may pick the device's own rate instead,
-      # which #rate then reports.
-      def initialize(rate:, exact_rate: false, buffer: 1024)
-        load_sdl
-        check(SDL::InitSubSystem.call(SDL::INIT_AUDIO))
-        @device = open_device(rate, exact_rate ? 0 : SDL::AUDIO_ALLOW_FREQUENCY_CHANGE, buffer)
-      end
-
-      def queue(samples)
-        data = samples.pack("s*")
-        check(SDL::QueueAudio.call(@device, data, data.bytesize))
-      end
-
-      def queued_seconds = SDL::GetQueuedAudioSize.call(@device).fdiv(2 * rate)
-
-      def start = SDL::PauseAudioDevice.call(@device, 0)
-
-      def pause = SDL::PauseAudioDevice.call(@device, 1)
-
-      def clear = SDL::ClearQueuedAudio.call(@device)
-
-      def close
-        return unless @device
-
-        SDL::CloseAudioDevice.call(@device)
-        SDL::QuitSubSystem.call(SDL::INIT_AUDIO)
-        @device = nil
-      end
-
-      private
-
-      def open_device(rate, allowed_changes, buffer)
-        wanted = [rate, SDL::AUDIO_S16SYS, 1, 0, buffer, 0, 0, 0, 0].pack(SPEC_LAYOUT)
-        obtained = "\0".b * 32
-        device = SDL::OpenAudioDevice.call(nil, 0, wanted, obtained, allowed_changes)
-        raise Error, SDL.error if device.zero?
-
-        @rate = obtained.unpack1("l")
-        device
-      end
-
-      def load_sdl
-        require "badline/sdl"
-      rescue SDL::Error => e
-        raise Error, e.message
-      end
-
-      def check(result)
-        raise Error, SDL.error if result.negative?
-
-        result
-      end
-    end
-  end
-end

data/lib/badline/audio/stream.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Audio
-    # Plays a running machine's SID through a sink, for the window: #feed
-    # queues whatever the SID recorded since the last call, once a frame,
-    # and #pace holds the machine to the device's clock.
-    #
-    # The device starts once the queue holds `ahead` seconds. Below real time
-    # the queue runs dry, and the device then stops until it holds `ahead`
-    # again, so the sound stutters with silent gaps rather than slowing
-    # down; `on_underrun` hears about the first time. A frame that would
-    # take the queue past `limit` seconds, as an unpaced machine above real
-    # time makes, is dropped whole.
-    class Stream
-      AHEAD = 0.08
-      LIMIT = 0.25
-
-      attr_reader :underruns, :dropped
-
-      # What #pace reads the time from and sleeps on: #now and #sleep.
-      attr_writer :clock
-
-      def initialize(sink, sid, ahead: AHEAD, limit: LIMIT, on_underrun: nil)
-        @sink = sink
-        @sid = sid
-        @ahead = ahead
-        @limit = limit
-        @on_underrun = on_underrun
-        @clock = Clock.new
-        @next_frame = nil
-        @started = false
-        @muted = false
-        @underruns = 0
-        @dropped = 0
-        sid.record(rate: sink.rate)
-      end
-
-      def rate = @sink.rate
-
-      # Plays another machine's SID from here on.
-      def sid=(sid)
-        @sid = sid
-        sid.record(rate: rate)
-      end
-
-      def muted? = @muted
-
-      def playing? = @started
-
-      # Muting drops the queue; unmuting fills it to `ahead` again before
-      # the device restarts.
-      def toggle_mute
-        @muted = !@muted
-        return unless @muted
-
-        halt
-        @sink.clear
-      end
-
-      def feed
-        samples = @sid.drain_samples
-        return if @muted || samples.empty?
-
-        queued = @sink.queued_seconds
-        return @dropped += samples.size if queued + samples.size.fdiv(rate) > @limit
-
-        underrun! if @started && queued.zero?
-        @sink.queue(samples)
-        start if @sink.queued_seconds >= @ahead
-      end
-
-      # Waits out the frame just run. While the device plays, that is until
-      # it has played the queue down to `ahead`, so the machine runs at the
-      # device's rate and the queue neither drifts dry nor grows. Muted or
-      # filling up, the clock paces frames `seconds` apart instead.
-      def pace(seconds)
-        return wait_for_device if playing?
-
-        now = @clock.now
-        @next_frame = now if @next_frame.nil? || @next_frame < now
-        @clock.sleep(@next_frame - now)
-        @next_frame += seconds
-      end
-
-      def close = @sink.close
-
-      private
-
-      def start
-        return if @started
-
-        @started = true
-        @sink.start
-      end
-
-      def wait_for_device
-        @next_frame = nil
-        while (excess = @sink.queued_seconds - @ahead).positive?
-          @clock.sleep([excess, 0.001].max)
-        end
-      end
-
-      def halt
-        @started = false
-        @sink.pause
-      end
-
-      def underrun!
-        @underruns += 1
-        @on_underrun&.call if @underruns == 1
-        halt
-      end
-
-      # The host's monotonic clock.
-      class Clock
-        def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
-        def sleep(seconds) = Kernel.sleep(seconds)
-      end
-    end
-  end
-end

data/lib/badline/gui/application.rb

@@ -1,243 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module GUI
-    class Application
-      TITLE = "Badline"
-      TOGGLE_SYM = SDL::KEY_TAB
-      MUTE_SYM = SDL::KEY_F10
-      SAVE_SYM = SDL::KEY_F11
-      RESTORE_SYM = SDL::KEY_F12
-      HOST_SYMS = [TOGGLE_SYM, MUTE_SYM, SAVE_SYM, RESTORE_SYM].freeze
-      REVERSE_MOD = SDL::KMOD_SHIFT
-
-      SHARED_KEYS = %i[cursor_up cursor_left cursor_h cursor_v space w a s d lshift].freeze
-
-      # Tab steps through the input modes and shift-Tab back; the title bar
-      # names the live one. The pot devices appear once per control port, since
-      # games disagree on which one they read.
-      MODES = {
-        keyboard: nil, joystick: "JOY",
-        mouse1: "MOUSE 1", mouse2: "MOUSE 2",
-        paddles1: "PADDLE 1", paddles2: "PADDLE 2"
-      }.freeze
-
-      # Both pot devices take their input from the host mouse. Motion turns the
-      # paddle knobs or steps the 1351's counters, and the host buttons go to
-      # whichever lines the device puts them on.
-      POT_DEVICES = {
-        mouse1: [Input::Mouse1351, 1], mouse2: [Input::Mouse1351, 2],
-        paddles1: [Input::Paddles, 1], paddles2: [Input::Paddles, 2]
-      }.freeze
-      MOUSE_BUTTONS = { 1 => :left, 3 => :right }.freeze
-
-      # The machine options (sid_model:, reu:, true_drive:, ntsc:) build
-      # the machine: reu plugs in an REU of that many K, true_drive puts a
-      # true 1541 on device 8, and ntsc makes it an NTSC C64. The media
-      # options (autostart:, song:, disk:) go to Media.attach.
-      def initialize(media_path: nil, machine: {}, sound: false, verbose: false, **media)
-        @verbose = verbose
-        @snapshots = Snapshots.new
-        @computer = @snapshots.boot(media_path, machine, media)
-
-        @mode = :keyboard
-        @pot_device = nil
-        @panes = panes
-        @stream = open_stream if sound
-        @paced = ENV["NOVSYNC"].nil?
-        @window = Window.new(
-          title: TITLE,
-          width: canvas_width, height: canvas_height,
-          vsync: @paced && !@stream
-        )
-        @gamepads = Gamepads.new(@computer)
-        @gamepads.names.each { |name| report "Gamepad: #{name}" }
-        fit_frame
-      end
-
-      def run
-        @running = true
-        while @running
-          handle_events
-          @gamepads.poll
-          @cycles_per_frame.times { @computer.cycle! }
-          @stream&.feed
-          @window.draw(@panes)
-          @stream.pace(@frame_seconds) if @stream && @paced
-        end
-      ensure
-        @computer.drive1541&.flush
-        @stream&.close
-        @gamepads.close
-        @window.close
-        report @computer.cpu.inspect
-      end
-
-      private
-
-      def handle_events
-        while (event = SDL.poll_event)
-          case event
-          when SDL::Quit
-            @running = false
-          when SDL::KeyDown
-            handle_key_down(event)
-          when SDL::KeyUp
-            handle_key_up(event)
-          when SDL::MouseMotion
-            @pot_device&.move(event.xrel, event.yrel)
-          when SDL::MouseButton
-            handle_mouse_button(event)
-          when SDL::ControllerDevice
-            @gamepads.rescan
-          end
-        end
-      end
-
-      def handle_key_down(event)
-        return host_key(event) if HOST_SYMS.include?(event.sym)
-
-        port, dir = JoyMap.parse(event) if @mode == :joystick
-        if port
-          joystick(port).press(dir)
-        else
-          press_key(KeyMap.parse(event), event.repeat)
-        end
-      end
-
-      # Tab, F10, F11 and F12 drive the front end, not the machine.
-      def host_key(event)
-        case event.sym
-        when TOGGLE_SYM then cycle_mode(event.mod.anybits?(REVERSE_MOD) ? -1 : 1)
-        when MUTE_SYM then toggle_mute
-        when SAVE_SYM then @snapshots.save(@computer) unless event.repeat
-        else restore_snapshot unless event.repeat
-        end
-      end
-
-      # RESTORE isn't in the key matrix, so it goes to the machine instead,
-      # once per press as the real key's one-shot fires.
-      def press_key(key, repeat)
-        return @computer.press_restore if key == :restore && !repeat
-        return if key == :restore
-
-        @computer.keyboard.press(key)
-      end
-
-      def handle_key_up(event)
-        return if HOST_SYMS.include?(event.sym)
-
-        port, dir = JoyMap.parse(event) if @mode == :joystick
-        if port
-          joystick(port).release(dir)
-        else
-          @computer.keyboard.release(KeyMap.parse(event))
-        end
-      end
-
-      def handle_mouse_button(event)
-        button = MOUSE_BUTTONS[event.button]
-        return unless button && @pot_device
-
-        if event.pressed
-          @pot_device.press(button)
-        else
-          @pot_device.release(button)
-        end
-      end
-
-      def joystick(port)
-        port == 1 ? @computer.joystick1 : @computer.joystick2
-      end
-
-      def cycle_mode(step)
-        modes = MODES.keys
-        @mode = modes[(modes.index(@mode) + step) % modes.size]
-        release_inputs
-        attach_pot_device
-        update_title
-      end
-
-      def toggle_mute
-        return unless @stream
-
-        @stream.toggle_mute
-        update_title
-      end
-
-      # Runs the restored machine in place of the one before: the screen,
-      # the drive LED, the gamepads and the sound go over to it. The input
-      # mode stays the host's, so a mouse or paddles go back in their port.
-      def restore_snapshot
-        computer = @snapshots.restore
-        return unless computer
-
-        release_inputs
-        @computer = computer
-        @panes = panes
-        @gamepads.computer = computer
-        @stream&.sid = computer.sid
-        attach_pot_device if POT_DEVICES.key?(@mode)
-      end
-
-      # The screen, and the drive LED in its border when a true drive is
-      # plugged in.
-      def panes
-        screen = ScreenPane.new(@computer)
-        drive = @computer.drive1541
-        drive ? [screen, DriveLedPane.new(drive, screen)] : [screen]
-      end
-
-      def update_title
-        tags = [MODES[@mode], @stream&.muted? && "MUTED"].select(&:itself)
-        @window.title = [TITLE, *tags.map { |tag| "[#{tag}]" }].join(" ")
-      end
-
-      def open_stream
-        sink = Audio::SDLSink.new(rate: Audio::Renderer::DEFAULT_RATE)
-        report "Sound at #{sink.rate} Hz, F10 mutes"
-        Audio::Stream.new(sink, @computer.sid,
-                          on_underrun: -> { puts "Running below real time, so the sound will stutter." })
-      rescue Audio::SDLSink::Error => e
-        warn "badline: no sound, can't open the audio device: #{e.message}"
-      end
-
-      def fit_frame
-        rate = @window.refresh_rate
-        clock_hz = @computer.region.clock_hz
-        @cycles_per_frame = clock_hz / rate
-        @frame_seconds = @cycles_per_frame.fdiv(clock_hz)
-        report "Display #{rate} Hz -> #{@cycles_per_frame} cycles/frame"
-      end
-
-      def report(line)
-        puts line if @verbose
-      end
-
-      def attach_pot_device
-        device_class, port = POT_DEVICES[@mode]
-        @pot_device = device_class&.new
-        ports = @computer.control_ports
-        ports.device1 = port == 1 ? @pot_device : nil
-        ports.device2 = port == 2 ? @pot_device : nil
-        SDL::SetRelativeMouseMode.call(@pot_device ? 1 : 0)
-      end
-
-      def release_inputs
-        SHARED_KEYS.each { |key| @computer.keyboard.release(key) }
-        Joystick::DIRECTIONS.each_key do |dir|
-          @computer.joystick1.release(dir)
-          @computer.joystick2.release(dir)
-        end
-      end
-
-      def canvas_width
-        @panes.map { |pane| pane.left + pane.width }.max
-      end
-
-      def canvas_height
-        @panes.map { |pane| pane.top + pane.height }.max
-      end
-    end
-  end
-end

data/lib/badline/gui/drive_led_pane.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module GUI
-    # The true drive's red LED, in the bottom right corner of the screen
-    # pane's border: bright while the DOS lights it, as it does while a file
-    # is open or after an error, and dim otherwise.
-    class DriveLedPane < Pane
-      WIDTH = 12
-      HEIGHT = 4
-
-      LIT = [0xff, 0x20, 0x20].freeze
-      DARK = [0x40, 0x00, 0x00].freeze
-
-      def initialize(drive, screen)
-        super(width: WIDTH, height: HEIGHT,
-              left: screen.left + screen.width - WIDTH - 8, top: screen.top + screen.height - HEIGHT - 6)
-        @drive = drive
-      end
-
-      def color = @drive.led_on? ? LIT : DARK
-
-      def render(renderer)
-        SDL::SetRenderDrawColor.call(renderer, *color, 0xff)
-        SDL::RenderFillRect.call(renderer, @rect)
-      end
-    end
-  end
-end

data/lib/badline/gui/gamepads.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module GUI
-    # Host game controllers wired onto the control ports.
-    #
-    # The first controller found drives joystick 2, the port most games read;
-    # a second one drives joystick 1. D-pad and left stick both steer, every
-    # face and shoulder button fires.
-    #
-    # SDL announces arrivals by device index but reports button presses by
-    # instance id, so rather than line the two up, this class polls the
-    # controllers every frame. It only releases directions it
-    # pressed itself, so the keyboard mapping keeps working with a pad
-    # connected.
-    class Gamepads
-      DEADZONE = 8_000
-      PORTS = [2, 1].freeze
-
-      BUTTONS = {
-        up: [SDL::CONTROLLER_BUTTON_DPAD_UP],
-        down: [SDL::CONTROLLER_BUTTON_DPAD_DOWN],
-        left: [SDL::CONTROLLER_BUTTON_DPAD_LEFT],
-        right: [SDL::CONTROLLER_BUTTON_DPAD_RIGHT],
-        fire: [SDL::CONTROLLER_BUTTON_A, SDL::CONTROLLER_BUTTON_B,
-               SDL::CONTROLLER_BUTTON_X, SDL::CONTROLLER_BUTTON_Y,
-               SDL::CONTROLLER_BUTTON_LEFTSHOULDER, SDL::CONTROLLER_BUTTON_RIGHTSHOULDER]
-      }.freeze
-
-      AXES = {
-        up: [SDL::CONTROLLER_AXIS_LEFTY, -1],
-        down: [SDL::CONTROLLER_AXIS_LEFTY, 1],
-        left: [SDL::CONTROLLER_AXIS_LEFTX, -1],
-        right: [SDL::CONTROLLER_AXIS_LEFTX, 1]
-      }.freeze
-
-      def initialize(computer)
-        SDL.check(SDL::InitSubSystem.call(SDL::INIT_GAMECONTROLLER))
-        @computer = computer
-        @controllers = []
-        @pressed = Array.new(PORTS.size) { [] }
-        rescan
-      end
-
-      def names = @controllers.map { |controller| SDL::GameControllerName.call(controller) }
-
-      def rescan
-        close
-        @controllers = (0...SDL::NumJoysticks.call)
-                       .select { |index| SDL::IsGameController.call(index) == 1 }
-                       .first(PORTS.size)
-                       .map { |index| SDL::GameControllerOpen.call(index) }
-                       .reject(&:null?)
-      end
-
-      # Wires the controllers to another machine's joysticks, which take
-      # what they hold on the next poll.
-      def computer=(computer)
-        @computer = computer
-        @pressed.map! { [] }
-      end
-
-      def poll
-        @controllers.each_with_index { |controller, index| apply(controller, index) }
-      end
-
-      def close
-        @controllers.each { |controller| SDL::GameControllerClose.call(controller) }
-        @controllers = []
-        @pressed.size.times { |index| release(index) }
-      end
-
-      private
-
-      def apply(controller, index)
-        active = Joystick::DIRECTIONS.keys.select { |dir| active?(controller, dir) }
-        (@pressed[index] - active).each { |dir| joystick(index).release(dir) }
-        active.each { |dir| joystick(index).press(dir) }
-        @pressed[index] = active
-      end
-
-      def release(index)
-        @pressed[index].each { |dir| joystick(index).release(dir) }
-        @pressed[index] = []
-      end
-
-      def active?(controller, direction)
-        BUTTONS.fetch(direction).any? { |button| SDL::GameControllerGetButton.call(controller, button) == 1 } ||
-          tilted?(controller, direction)
-      end
-
-      def tilted?(controller, direction)
-        axis, sign = AXES[direction]
-        return false unless axis
-
-        SDL::GameControllerGetAxis.call(controller, axis) * sign > DEADZONE
-      end
-
-      def joystick(index)
-        PORTS[index] == 1 ? @computer.joystick1 : @computer.joystick2
-      end
-    end
-  end
-end

data/lib/badline/gui/joy_map.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module GUI
-    # Maps host keys onto the two control ports while joystick mode is on.
-    #
-    # The arrow cluster plus space drives joystick 2, WASD plus left shift
-    # joystick 1, so both ports can be played at once.
-    class JoyMap
-      PORTS = {
-        2 => { "Up" => :up, "Down" => :down, "Left" => :left, "Right" => :right, "Space" => :fire }.freeze,
-        1 => { "W" => :up, "S" => :down, "A" => :left, "D" => :right, "Left Shift" => :fire }.freeze
-      }.freeze
-
-      def self.parse(event)
-        name = SDL.key_name(event.sym)
-
-        PORTS.each do |port, map|
-          direction = map[name]
-          return [port, direction] if direction
-        end
-
-        nil
-      end
-    end
-  end
-end