road_to_rubykaigi 0.2.1 → 2026.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e1c9d75458d0964d5a7016dffb3cd8b80a7528e6dd6988400e54b37d307a2ae
-  data.tar.gz: 645ba606e44b14f7065136dc22b8dfd7f33fd8af5f0c7d0c2fcf94f928b54997
+  metadata.gz: 527a733e37bdf8463d938cbfebb32b9760f1635bcf710730952fe6432522e760
+  data.tar.gz: f87265b023dde2645e842882550705322045916a9c850ae1dba08e6ff58480e0
 SHA512:
-  metadata.gz: cc76ee396cf3a522c4aca51b02a4fc3009e7f7dea49c4ca59bcaa4161c70e8bc9a1276549e8777385a9baa4b1960f682ee0415b3534a06f22bc2f5d6bd71780a
-  data.tar.gz: a6f482e2a301be08a089b978950a1d890417653243e63b985b24e2f2c94a7c1bb64a61fde9b47d0eb885d531b778f10f94c0c280e45a81a2184dd69b6e3aa33d
+  metadata.gz: 26b4d55a9e985cdf15edde864070eb4294727571ea8bfe6fe3c2be96a15283c1a896dffb22834963ab278ab487f5e335094b5e33000b2c0ecca1a334f9c36f00
+  data.tar.gz: 78161e32af91184d672f0279b662b0e7a22c323651299f5a0925987d460d22dd5687a34be698d0d23a24a2a2f4e74ab0099ee294c67c78791bb34738af2f66e5

data/.road_to_rubykaigi.sample

@@ -0,0 +1,26 @@
+# Configuration file for Road to RubyKaigi
+# Copy this file to .road_to_rubykaigi and uncomment the settings you want to enable.
+#
+# Input source for the accelerometer signal: `ble` or `serial`.
+# Leave unset to play with keyboard only.
+# INPUT_SOURCE=ble
+# Enable debug logging to tmp/game_server.log
+# DEBUG=1
+# Mute BGM (sound effects play)
+# BGM_OFF=1
+# Skip auto-opening the controller browser on game start
+# DEMO=1
+# Start threshold for run start detection (set by calibration)
+# START_THRESHOLD=0.025
+# Continuation threshold for step detection (set by calibration)
+# CONTINUATION_THRESHOLD=0.05
+# Walking step cadence in Hz (set by calibration)
+# WALK_CADENCE=2.6
+# Walking motion intensity median (set by calibration)
+# WALK_INTENSITY=0.6
+# Gravity vector (x,y,z, set by calibration, used to project vertical axis)
+# GRAVITY=0.0,0.0,1.0
+# Max vertical acceleration at a committed jump (set by calibration)
+# JUMP_V_MAX=2.0
+# Serial port device path (default: /dev/tty.usbmodem0001)
+# SERIAL_PORT=/dev/tty.usbmodem0001

data/Rakefile

@@ -6,6 +6,4 @@ import "util/audio.rake"
 
 RSpec::Core::RakeTask.new(:spec)
 
-require "standard/rake"
-
-task default: %i[spec standard]
+task default: %i[spec]

data/examples/accelerometer.rb

@@ -0,0 +1,131 @@
+# Sample PicoRuby script for reading acceleration data from KXR94-2050 module
+# and sending it via BLE UART and hardware UART (serial).
+#
+# Data is always sent to both channels simultaneously:
+#   - BLE UART: received by browser controller -> GameServer
+#   - Hardware UART (GP0): received by USB-TTL cable -> SerialReader on the host
+# Switch SERIAL=1 in .road_to_rubykaigi on the host side to choose which to use.
+#
+# Wiring (USB-TTL cable -> Pico W):
+#   Cable RX  -> GP0 (UART0 TX)
+#   Cable GND -> GND
+#
+# KXR94-2050 datasheet: https://akizukidenshi.com/goodsaffix/KXR94_2025_06_25.pdf
+#   Sensitivity: Vdd / 5 (V/g)
+#   Zero-g offset: Vdd / 2 (V)
+#
+# Flash this script to a Raspberry Pi Pico (2) W with PicoRuby.
+
+require 'adc'
+require 'uart'
+require 'ble'
+require 'ble-uart'
+
+# Switch this to match the target board before flashing.
+BOARD = :ble  # :ble or :serial
+
+ZERO = 3.3 / 2.0
+SENSITIVITY = 3.3 / 5.0
+# Sensor axes in chip-native frame (both boards mount the chip the same way
+# relative to the body):
+#   chip X = vertical (up/down along gravity)
+#   chip Y = horizontal (lateral)
+#   chip Z = body front-back
+# Emitted stream uses a rotated frame where Z = up, so at rest both boards
+# emit (x=0, y=0, z=+1). Chip X reads -1g at rest, so Z_SIGN=-1 flips it.
+if BOARD == :ble
+  # Chip X/Y physically swapped on this board: pin 26 reads chip Y, pin 27
+  # reads chip X.
+  X_PIN, Y_PIN, Z_PIN = 26, 28, 27
+else # :serial
+  # Straight pin-to-chip mapping: pin 26=chip X, 27=chip Y, 28=chip Z.
+  X_PIN, Y_PIN, Z_PIN = 27, 28, 26
+end
+X_SIGN, Y_SIGN, Z_SIGN = 1, 1, -1
+
+class Accelerometer
+  def initialize
+    GPIO.new(19, GPIO::OUT).write(1)
+    sleep 0.5
+
+    @ax = ADC.new(X_PIN)
+    @ay = ADC.new(Y_PIN)
+    @az = ADC.new(Z_PIN)
+  end
+
+  def read
+    x = to_g(@ax.read_voltage) * X_SIGN
+    y = to_g(@ay.read_voltage) * Y_SIGN
+    z = to_g(@az.read_voltage) * Z_SIGN
+    bootsel = Machine.bootsel_pressed? ? 1 : 0
+    "x=#{x.round(5)},y=#{y.round(5)},z=#{z.round(5)},b=#{bootsel}"
+  end
+
+  # private
+
+  def to_g(voltage)
+    (voltage - ZERO) / SENSITIVITY
+  end
+end
+
+class Blinker
+  LED_PIN = CYW43::GPIO::LED_PIN
+  FAST_INTERVAL_MS = 200
+  SLOW_INTERVAL_MS = 500
+  TICK_INTERVAL_MS = BLE::POLLING_UNIT_MS / BLE::UART::USER_BLOCK_CALL_COUNT_PER_POLL
+  INTERVALS = {
+    fast: FAST_INTERVAL_MS / TICK_INTERVAL_MS,
+    slow: SLOW_INTERVAL_MS / TICK_INTERVAL_MS,
+  }
+
+  attr_writer :mode
+
+  def initialize
+    @led = CYW43::GPIO.new(LED_PIN)
+    @on = false
+    @tick = 0
+    @mode = :fast
+  end
+
+  def tick
+    @tick += 1
+    return if @tick < INTERVALS[@mode]
+
+    @tick = 0
+    @on = !@on
+    @led.write(@on ? 1 : 0)
+  end
+end
+
+accelerometer = Accelerometer.new
+serial = UART.new(unit: :RP2040_UART0, txd_pin: 0, baudrate: 115200)
+ble_uart = BLE::UART.new(name: 'RtR')
+ble_uart.debug = true
+blinker = Blinker.new
+
+# The BLE connection interval (negotiated by the central) caps the notification rate,
+# the sensor produces faster than a single-sample-per-notify stream can be delivered.
+# Batching keeps the effective sample rate while staying under the notification throughput ceiling.
+BLE_BATCH_SIZE = 2
+SAMPLE_SEPARATOR = '|'
+
+ble_batch = []
+
+# BLE::UART#start calls this block USER_BLOCK_CALL_COUNT_PER_POLL times per BLE
+# polling cycle (every POLLING_UNIT_MS / USER_BLOCK_CALL_COUNT_PER_POLL ≈ 20ms).
+# Send one sample per call — no inner loop, no sleep_ms here.
+ble_uart.start do
+  data = accelerometer.read
+  if ble_uart.connected?
+    ble_batch << data
+    if ble_batch.size >= BLE_BATCH_SIZE
+      ble_uart.puts(ble_batch.join(SAMPLE_SEPARATOR))
+      ble_batch.clear
+    end
+  else
+    serial.puts(data)
+  end
+
+  blinker.mode = ble_uart.connected? ? :slow : :fast
+  blinker.tick
+end

data/lib/road_to_rubykaigi/ansi.rb

@@ -5,6 +5,7 @@ module RoadToRubykaigi
     CURSOR_ON = "\e[?25h"
     HOME = "\e[H"
     RESET = "\e[0m"
+    BOLD = "\e[1m"
     RED = "\e[31m"
     BLUE = "\e[38;5;39m"
     YELLOW = "\e[33m"
@@ -12,6 +13,13 @@ module RoadToRubykaigi
     DEFAULT_TEXT_COLOR = "\e[38;5;238m"
     RESULT_DATA = ["\e[4;18H", "\e[5;18H", "\e[6;18H"]
     NULL = "\0"
+    UP = "\e[A"
+    DOWN = "\e[B"
+    ENTER = "\r"
+    LF = "\n"
+    SPACE = " "
+    ESC = "\e"
+    ETX = "\x03"
 
     self.constants(false).each do |constant|
       ANSI.define_singleton_method(constant.to_s.downcase) {

data/lib/road_to_rubykaigi/calibration_bar.rb

@@ -0,0 +1,84 @@
+module RoadToRubykaigi
+  class CalibrationBar
+    BAR_WIDTH = 100
+    BAR_MAX = 2.5
+    EMOJI_WIDTH = 2
+    BOUNCE_HZ = 4
+
+    BASE_X = 5
+    EMOJI_BOUNCE_Y = 6
+    EMOJI_BASE_Y = EMOJI_BOUNCE_Y + 1
+
+    MESSAGES = {
+      remaining: [5, 5, "#{ANSI::BOLD}%-20s#{ANSI::RESET}  %5.1fs"],
+      intensity: [5, 8, '[%s] %.4f'],
+    }.freeze
+
+    LABELS = {
+      static: { text: 'Hold still', emoji: '🧍' },
+      walk:   { text: 'Walk',       emoji: '🚶‍➡️', emoji_bounce: '🏃‍➡️' },
+      jump:   { text: 'Jump',       emoji: '🧍',    emoji_bounce: '🤸' },
+    }.freeze
+
+    def self.states = LABELS.keys.dup
+
+    def self.clear_emoji
+      blank = ' ' * (BAR_WIDTH + EMOJI_WIDTH)
+      [
+        [BASE_X + 1, EMOJI_BOUNCE_Y, blank],
+        [BASE_X + 1, EMOJI_BASE_Y, blank],
+      ]
+    end
+
+    def render
+      result = [
+        format_line(MESSAGES[:remaining], "▶ #{@label[:text]}", @sampler.remaining),
+        format_line(MESSAGES[:intensity], bar, @sampler.intensity),
+      ]
+
+      if bouncing_state?
+        emoji_x = BASE_X + 1 + (@sampler.progress * BAR_WIDTH).to_i.clamp(0, BAR_WIDTH)
+        # Clear previous emoji
+        unless @prev_emoji_x == emoji_x
+          result << [@prev_emoji_x, EMOJI_BOUNCE_Y, ' ' * EMOJI_WIDTH]
+          result << [@prev_emoji_x, EMOJI_BASE_Y, ' ' * EMOJI_WIDTH]
+          @prev_emoji_x = emoji_x
+        end
+
+        if bouncing?
+          result << [emoji_x, EMOJI_BOUNCE_Y, @label[:emoji_bounce]]
+          result << [emoji_x, EMOJI_BASE_Y, ' ' * EMOJI_WIDTH]
+        else
+          result << [emoji_x, EMOJI_BOUNCE_Y, ' ' * EMOJI_WIDTH]
+          result << [emoji_x, EMOJI_BASE_Y, @label[:emoji]]
+        end
+      else
+        result << [BASE_X + 1, EMOJI_BASE_Y, @label[:emoji]]
+      end
+
+      result
+    end
+
+    private
+
+    def initialize(sampler, state:)
+      @sampler = sampler
+      @state = state
+      @label = LABELS.fetch(state)
+      @prev_emoji_x = BASE_X + 1
+    end
+
+    def bar
+      filled = (@sampler.intensity / BAR_MAX * BAR_WIDTH).to_i.clamp(0, BAR_WIDTH)
+      '█' * filled + '░' * (BAR_WIDTH - filled)
+    end
+
+    def bouncing_state? = @label.key?(:emoji_bounce)
+    def bouncing? = (Time.now.to_f * BOUNCE_HZ).to_i.odd?
+
+    def format_line(line, *args)
+      x, y, template = line
+      [x, y, format(template, *args)]
+    end
+  end
+end

data/lib/road_to_rubykaigi/calibration_result.rb

@@ -0,0 +1,70 @@
+module RoadToRubykaigi
+  CalibrationResult = Data.define(
+    :start_threshold,
+    :continuation_threshold,
+    :walk_cadence,
+    :walk_cadence_sample_count,
+    :walk_intensity,
+    :gravity_vector,
+    :jump_v_max,
+    :static_sample_count,
+    :jump_sample_count,
+  ) do
+    # Derives calibrated values from per-phase collected samples.
+    def self.from_samples(static:, walk:, jump:)
+      # Use p95 rather than max so a single stray spike during "still" doesn't
+      # inflate every downstream threshold.
+      sorted_static = static[:intensities].sort
+      noise_ceiling = sorted_static[(sorted_static.size * 0.95).floor] || 0.0
+      # Noise ceiling * 2.5 as the threshold separating noise from walking.
+      # Stays above noise even in short-window valleys between steps.
+      #   2.5 is an empirical factor derived from real calibration data.
+      start_threshold = noise_ceiling * 2.5
+      # Continuation uses a short window (fast stop detection) which is noise-sensitive,
+      # so use a higher threshold for noise tolerance.
+      continuation_threshold = noise_ceiling * 5.0
+      gravity_vector = mean_vector(static[:raw_samples])
+      new(
+        start_threshold:,
+        continuation_threshold:,
+        walk_cadence:     median(walk[:cadences]), # Median walking step cadence in Hz, representing individual step frequency.
+        walk_intensity:   median(walk[:intensities]), # Used by the intensity-boost path that lifts in-place running (elevated intensity, walk-level cadence).
+        gravity_vector:,
+        jump_v_max:       max_vertical_acceleration(jump[:raw_samples], gravity_vector),
+
+        static_sample_count: static[:intensities].size,
+        walk_cadence_sample_count: walk[:cadences].size,
+        jump_sample_count: jump[:raw_samples].size,
+      )
+    end
+
+    def self.median(values)
+      sorted = values.sort
+      sorted[sorted.size / 2] || 0.0
+    end
+
+    # Averaged [x, y, z] of the resting accelerometer, used as the gravity reference.
+    def self.mean_vector(samples)
+      samples.transpose.map { |values| values.sum / values.size }
+    end
+
+    # Max upward acceleration (in g, gravity subtracted) observed across jump samples.
+    def self.max_vertical_acceleration(samples, gravity)
+      gravity_magnitude = Math.sqrt(gravity[0] ** 2 + gravity[1] ** 2 + gravity[2] ** 2)
+      samples.map { |sample|
+        (sample[0] * gravity[0] + sample[1] * gravity[1] + sample[2] * gravity[2]) / gravity_magnitude - gravity_magnitude
+      }.max || 0.0
+    end
+
+    def save
+      Config.save_calibration(
+        start_threshold: start_threshold.round(6),
+        continuation_threshold: continuation_threshold.round(6),
+        walk_cadence: walk_cadence.round(6),
+        walk_intensity: walk_intensity.round(6),
+        gravity_vector: gravity_vector.map { |value| value.round(6) },
+        jump_v_max: jump_v_max.round(6),
+      )
+    end
+  end
+end

data/lib/road_to_rubykaigi/calibration_sampler.rb

@@ -0,0 +1,52 @@
+module RoadToRubykaigi
+  class CalibrationSampler
+    PHASE_SECONDS = 5
+
+    attr_reader :intensities, :cadences, :raw_samples, :intensity
+
+    def tick
+      Config.signal_source.drain do |data|
+        sample = parse_sample(data)
+        next unless sample
+        @window.buffer_sample(sample)
+        @raw_samples << sample
+      end
+      return unless @window.full?
+      @intensity = @window.motion_intensity
+      @intensities << @intensity
+      @cadences << @window.cadence_hz if @window.cadence_ready?
+    end
+
+    def finished?
+      elapsed >= PHASE_SECONDS
+    end
+
+    def remaining
+      PHASE_SECONDS - elapsed
+    end
+
+    def progress
+      (elapsed / PHASE_SECONDS.to_f).clamp(0.0, 1.0)
+    end
+
+    private
+
+    def initialize
+      @window = SignalWindow.new
+      @intensities = []
+      @cadences = []
+      @raw_samples = []
+      @intensity = 0.0
+      @started_at = Time.now
+    end
+
+    def elapsed
+      Time.now - @started_at
+    end
+
+    def parse_sample(data)
+      return nil unless %w[x y z].all? { |key| data.key?(key) }
+      [data['x'].to_f, data['y'].to_f, data['z'].to_f]
+    end
+  end
+end

data/lib/road_to_rubykaigi/calibration_screen.rb

@@ -0,0 +1,171 @@
+module RoadToRubykaigi
+  class CalibrationScreen
+    COUNTDOWN_FROM = 5
+
+    MESSAGES = {
+      title: [5, 3, '=== Sensor Calibration ==='],
+      intro: [
+        [5, 10, '[Enter/Space] start'],
+        [5, 11, '[ESC]         return'],
+      ],
+      cancel: [5, 11, '[ESC] cancel'],
+      instructions: [
+        [5, 13, '🧍 Hold -> 🚶‍➡️ Walk -> 🤸 Jump!'],
+        [5, 14, "#{CalibrationSampler::PHASE_SECONDS}s each"],
+      ],
+      clear_instructions: [
+        [5, 13, ' ' * 30],
+        [5, 14, ' ' * 30],
+      ],
+      countdown:    [5, 8, 'Starting in %d...'],
+      countdown_clear: [5, 8, ' ' * 20],
+      done_static:  [5, 6, 'Static: %.6f (%d samples)'],
+      done_walk:    [5, 7, 'Walk:   %.3f Hz (%d samples)'],
+      done_jump:    [5, 8, 'Jump:   %.3f g (%d samples)'],
+      done_return:  [5, 10, '[Enter/ESC] return'],
+      not_connected: [
+        [5, 6, 'Sensor not connected.'],
+        [5, 7, 'Connect the sensor and try again.'],
+        [5, 10, '[Enter/ESC] return'],
+      ],
+    }.freeze
+
+    def display
+      if Config.serial? && !File.exist?(Config.serial_port)
+        enter_not_connected
+      else
+        Config.signal_source.start
+        enter_intro
+      end
+      $stdin.raw do
+        loop do
+          case tick
+          when :done then return
+          end
+          sleep Manager::GameManager::FRAME_RATE
+        end
+      end
+    end
+
+    private
+
+    def tick
+      action = read_action
+      if action == :cancel
+        if @state == :intro || @state == :done
+          return :done
+        else
+          enter_intro && return
+        end
+      end
+
+      case @state
+      when :intro     then action == :proceed && enter_countdown
+      when :countdown then tick_countdown
+      when :collect   then tick_collect
+      when :done      then action == :proceed && enter_intro
+      end
+    end
+
+    def enter_intro
+      @state = :intro
+      @results = {}
+      @remaining_keys = CalibrationBar.states
+      ANSI.clear
+      draw MESSAGES[:title], *MESSAGES[:intro], *MESSAGES[:instructions]
+    end
+
+    def enter_countdown
+      @state = :countdown
+      @countdown_remaining = COUNTDOWN_FROM
+      @countdown_last_tick = nil
+      ANSI.clear
+      draw MESSAGES[:title], MESSAGES[:cancel], *MESSAGES[:instructions]
+    end
+
+    def tick_countdown
+      now = Time.now
+      @countdown_last_tick ||= now
+
+      if now - @countdown_last_tick >= 1.0
+        @countdown_remaining -= 1
+        @countdown_last_tick = now
+      end
+
+      if @countdown_remaining <= 0
+        draw MESSAGES[:countdown_clear]
+        enter_collect
+      else
+        draw format_line(MESSAGES[:countdown], @countdown_remaining)
+      end
+    end
+
+    def enter_not_connected
+      @state = :done
+      ANSI.clear
+      draw MESSAGES[:title], *MESSAGES[:not_connected]
+    end
+
+    def enter_collect
+      if @results.empty? && Config.signal_source.queue.empty?
+        enter_not_connected && return
+      end
+
+      @state = :collect
+      @current_key = @remaining_keys.first
+      @sampler = CalibrationSampler.new
+      @bar = CalibrationBar.new(@sampler, state: @current_key)
+      draw *MESSAGES[:clear_instructions], *CalibrationBar.clear_emoji
+    end
+
+    def tick_collect
+      @sampler.tick
+      draw *@bar.render
+
+      return unless @sampler.finished?
+
+      @results[@current_key] = {
+        intensities: @sampler.intensities,
+        cadences: @sampler.cadences,
+        raw_samples: @sampler.raw_samples,
+      }
+      @remaining_keys.shift
+
+      if @remaining_keys.empty?
+        enter_done
+      else
+        enter_collect
+      end
+    end
+
+    def enter_done
+      @state = :done
+      result = CalibrationResult.from_samples(**@results)
+      result.save
+      ANSI.clear
+      draw MESSAGES[:title],
+           format_line(MESSAGES[:done_static], result.continuation_threshold, result.static_sample_count),
+           format_line(MESSAGES[:done_walk], result.walk_cadence, result.walk_cadence_sample_count),
+           format_line(MESSAGES[:done_jump], result.jump_v_max, result.jump_sample_count),
+           MESSAGES[:done_return]
+    end
+
+    def format_line(line, *args)
+      x, y, template = line
+      [x, y, format(template, *args)]
+    end
+
+    def read_action
+      case $stdin.read_nonblock(3, exception: false)
+      when ANSI::ETX then raise Interrupt
+      when ANSI::ENTER, ANSI::LF, ANSI::SPACE then :proceed
+      when ANSI::ESC then :cancel
+      end
+    end
+
+    def draw(*lines)
+      lines.each { |x, y, text| print "\e[#{y};#{x}H#{text}" }
+      $stdout.flush
+    end
+  end
+end