road_to_rubykaigi 0.2.1 → 2026.0.1

data/lib/road_to_rubykaigi/graphics/player.rb

@@ -5,62 +5,92 @@ module RoadToRubykaigi
       LEFT = RoadToRubykaigi::Sprite::Player::LEFT
       FILE_PATH = "player.txt"
 
+      STATUSES_BY_POSTURE = {
+        standup: %i[normal stunned running],
+        crouching: %i[normal stunned],
+      }.freeze
+      FRAMES = [1, 2].freeze
+
+      Direction = Data.define(:value) do
+        def right? = value == RIGHT
+        def name = right? ? 'RIGHT' : 'LEFT'
+      end
+      DIRECTIONS = [Direction.new(RIGHT), Direction.new(LEFT)].freeze
+
+      Variant = Data.define(:posture, :status, :direction, :default_frames, :attack_frames) do
+        class << self
+          def build(posture:, status:, direction:, parts:)
+            new(
+              posture: posture,
+              status: status,
+              direction: direction,
+              default_frames: FRAMES.map { |frame| default_frame(posture, status, direction, frame, parts) },
+              attack_frames:  FRAMES.map { |frame| attack_frame(posture, status, direction, frame, parts) },
+            )
+          end
+
+          private
+
+          def face_key(posture, status, direction) = :"face_#{posture}_#{status}_#{direction.name}"
+          def foot_key(status, frame) = :"foot_#{status == :running ? :normal : status}_#{frame}"
+          def crouching?(posture) = posture == :crouching
+
+          def default_frame(posture, status, direction, frame, parts)
+            [
+              parts[:head],
+              parts[face_key(posture, status, direction)],
+              crouching?(posture) ? nil : parts[foot_key(status, frame)],
+            ].compact
+          end
+
+          def attack_frame(posture, status, direction, frame, parts)
+            head = parts[:head]
+            face = parts[face_key(posture, status, direction)]
+            foot = crouching?(posture) ? nil : parts[foot_key(status, frame)]
+
+            if direction.right?
+              [head + "   ".chars, face + "_◢◤".chars, foot && foot + "   ".chars].compact
+            else
+              ["   ".chars + head, "◥◣_".chars + face, foot && "   ".chars + foot].compact
+            end
+          end
+        end
+      end
+
       class << self
         def character(posture:, status:, direction:, attack_mode:)
-          load_data
-          characters = attack_mode ? @attack_characters : @default_characters
-          characters[posture][status][direction]
+          load_data unless @variants
+
+          variant = @variants[[posture, status, direction]]
+          attack_mode ? variant.attack_frames : variant.default_frames
         end
 
         private
 
         def load_data
-          return if @default_characters
-          index = { "RIGHT" => Sprite::Player::RIGHT, "LEFT" => Sprite::Player::LEFT }
-          hash = Hash.new { |h, k| h[k] = [] }
-          @default_characters = {
-            standup: { normal: hash.dup, stunned: hash.dup },
-            crouching: { normal: hash.dup, stunned: hash.dup },
-          }
-          @attack_characters = {
-            standup: { normal: hash.dup, stunned: hash.dup },
-            crouching: { normal: hash.dup, stunned: hash.dup },
-          }
-          set = {}
-          File.read("#{__dir__}/#{FILE_PATH}").scan(/# (\w+)\n(.*)\n/) do |type, line|
-            set[type.to_sym] = line.chars.map do |char|
-              fullwidth?(char) ? [char, ANSI::NULL] : char
-            end.flatten
-          end
-
-          %i[standup crouching].each do |posture|
-            %i[normal stunned].each do |status|
-              index.each do |(direction, direction_value)|
-                (1..2).each do |i|
-                  @default_characters[posture][status][direction_value] << (
-                    [
-                      set[:head],
-                      set[:"face_#{posture}_#{status}_#{direction}"],
-                      posture == :crouching ? nil : set[:"foot_#{status}_#{i}"],
-                    ].compact
-                  )
-                  @attack_characters[posture][status][direction_value] << (
-                    direction == "RIGHT" ?
-                      [
-                        set[:head] + "   ".chars,
-                        set[:"face_#{posture}_#{status}_#{direction}"] + "_◢◤".chars,
-                        posture == :crouching ? nil : set[:"foot_#{status}_#{i}"] + "   ".chars,
-                      ].compact :
-                      [
-                        "   ".chars + set[:head],
-                        "◥◣_".chars + set[:"face_#{posture}_#{status}_#{direction}"],
-                        posture == :crouching ? nil : "   ".chars + set[:"foot_#{status}_#{i}"],
-                      ].compact
-                  )
-                end
-              end
+          parts = load_parts
+          @variants = STATUSES_BY_POSTURE.flat_map do |posture, statuses|
+            statuses.product(DIRECTIONS).map do |status, direction|
+              [
+                [posture, status, direction.value],
+                Variant.build(posture:, status:, direction:, parts:),
+              ]
             end
-          end
+          end.to_h
+        end
+
+        # @return [Hash{Symbol => Array<String>}]
+        #   {head: ["╭", "─", "─", "─", "─", "─", "─", "╮"],
+        #    foot_normal_1: ["╰", "─", "∪", "─", "─", "─", "∪", "╯"],
+        #    face_standup_normal_RIGHT: ["│", "｡", "・", "\u0000", "◡", "・", "\u0000", "│"], ...
+        def load_parts
+          File.read("#{__dir__}/#{FILE_PATH}")
+              .scan(/^# (\w+)\n(.*)$/)
+              .to_h { |name, line| [name.to_sym, expand_cells(line)] }
+        end
+
+        def expand_cells(line)
+          line.chars.flat_map { |char| fullwidth?(char) ? [char, ANSI::NULL] : [char] }
         end
 
         def fullwidth?(char)

data/lib/road_to_rubykaigi/graphics/player.txt

@@ -12,6 +12,10 @@
 │｡・◡・│
 # face_standup_normal_LEFT
 │・◡・｡│
+# face_standup_running_RIGHT
+│｡> ◡ <│
+# face_standup_running_LEFT
+│> ◡ <｡│
 # face_standup_stunned_RIGHT
 │ ´×⌓× │
 # face_standup_stunned_LEFT

data/lib/road_to_rubykaigi/jump_detector.rb

@@ -0,0 +1,125 @@
+module RoadToRubykaigi
+  # Detects squat-jumps from the accelerometer stream.
+  #
+  # Axis-agnostic: consumes the gravity-compensated vertical acceleration
+  # instead of any single raw axis. vertical_acceleration = projection of the
+  # sample onto the gravity vector, minus |gravity|. So rest = 0, upward
+  # proper acceleration > 0, downward (or free fall) < 0.
+  #
+  # Rule: loaded hold + bottom turnover. Running strides briefly peak the
+  # vertical acceleration above the loaded threshold at each footstrike.
+  # A squat-jump holds it above the threshold noticeably longer. Fire at the
+  # bottom of that span (slope becomes clearly negative), whether the signal
+  # is still above the threshold or has just crossed back below.
+  #
+  # Firing at the bottom of the load (not at landing or at full takeoff)
+  # minimizes latency.
+  #
+  # The loaded span must start from an up-crossing (a prior sample at or
+  # below the threshold) inside the buffer. Otherwise a stationary sensor
+  # reading near 0 could drift above threshold and accumulate an unbounded
+  # "loaded hold" that passes the duration gate on its own.
+  class JumpDetector
+    LOADED_THRESHOLD = 0.20         # vertical_acceleration above this counts as "loaded" (body under extra g-load)
+    LOADED_MIN_SECONDS = 0.2       # loaded span qualifying as squat hold
+    TAKEOFF_SLOPE_MAX = -1.0        # g/s — fall slope indicating takeoff turnover
+    SLOPE_WINDOW_SECONDS = 0.08
+    LOADED_END_GRACE_SECONDS = 0.15 # allow fire shortly past the span's last above-threshold point
+
+    COOLDOWN_SECONDS = 0.8          # min gap between consecutive fires (covers takeoff→landing)
+    SAMPLE_BUFFER_SECONDS = 1.2     # retain samples long enough to cover an elongated squat hold
+    MIN_SAMPLES_FOR_ANALYSIS = 5    # slope + hold both need a few samples to be meaningful
+
+    def initialize(gravity:)
+      @gravity = gravity
+      @gravity_magnitude = Math.sqrt(gravity[0] ** 2 + gravity[1] ** 2 + gravity[2] ** 2)
+      @last_samples = [] # [{time:, vertical_acceleration:}] sliding window
+      @last_jump_time = nil
+    end
+
+    def detect(sample:)
+      now = Time.now
+      @last_samples << { time: now, vertical_acceleration: vertical_acceleration(sample) }
+      cutoff = now - SAMPLE_BUFFER_SECONDS
+      @last_samples.shift while !@last_samples.empty? && @last_samples.first[:time] < cutoff
+
+      if !buffer_ready? || !squat_takeoff? || cooling_down?(now)
+        false
+      else
+        @last_jump_time = now
+        debug_log('JUMP_FIRED')
+        true
+      end
+    end
+
+    private
+
+    def vertical_acceleration(sample)
+      projection = (-sample[0] * @gravity[0] + sample[1] * @gravity[1] + sample[2] * @gravity[2]) / @gravity_magnitude
+      projection - @gravity_magnitude
+    end
+
+    def buffer_ready? = @last_samples.size >= MIN_SAMPLES_FOR_ANALYSIS
+    def cooling_down?(now) = @last_jump_time && (now - @last_jump_time) < COOLDOWN_SECONDS
+
+    def squat_takeoff?
+      hold_seconds = last_loaded_hold_seconds
+      slope = last_slope
+      debug_log(format('vertical_acceleration=%+.2f hold=%.3f slope=%+.2f', @last_samples.last[:vertical_acceleration], hold_seconds, slope)) if hold_seconds > 0
+
+      if hold_seconds < LOADED_MIN_SECONDS
+        false
+      else
+        slope <= TAKEOFF_SLOPE_MAX
+      end
+    end
+
+    # Duration of the latest span where vertical_acceleration stayed
+    # continuously above LOADED_THRESHOLD. Returns 0 if the span reaches the
+    # buffer edge without a preceding below-threshold sample — that indicates
+    # stationary state (signal hovering near 0 continuously), not an
+    # oscillating stride.
+    # The span may still be in progress (latest sample above threshold) or
+    # just ended within the last sample — jumps launch fast enough that the
+    # signal can skip from +1g to below threshold between consecutive samples.
+    def last_loaded_hold_seconds
+      loaded_end_idx = @last_samples.rindex { |sample| sample[:vertical_acceleration] > LOADED_THRESHOLD }
+      return 0.0 unless loaded_end_idx
+      loaded_end_time = @last_samples[loaded_end_idx][:time]
+      # Too long past the span's end — no longer just after the turnover
+      return 0.0 if @last_samples.last[:time] - loaded_end_time > LOADED_END_GRACE_SECONDS
+
+      pre_load_idx = @last_samples[0...loaded_end_idx].rindex { |sample| sample[:vertical_acceleration] <= LOADED_THRESHOLD }
+      if pre_load_idx
+        loaded_begin_idx = pre_load_idx + 1
+        loaded_begin_time = @last_samples[loaded_begin_idx][:time]
+        loaded_end_time - loaded_begin_time
+      else
+        0.0
+      end
+    end
+
+    # Slope (g/s) of vertical_acceleration over the last SLOPE_WINDOW_SECONDS,
+    # measured as (latest - reference) / dt where reference is the newest
+    # sample at or before the window cutoff. A clearly negative value means
+    # the signal has peaked and started falling — the takeoff turnover.
+    def last_slope
+      window_end_sample = @last_samples.last
+      cutoff = window_end_sample[:time] - SLOPE_WINDOW_SECONDS
+      window_begin_sample = @last_samples.reverse_each.find { |sample| sample[:time] <= cutoff }
+      return 0.0 unless window_begin_sample
+
+      elapsed_seconds = window_end_sample[:time] - window_begin_sample[:time]
+      if elapsed_seconds <= 0
+        0.0
+      else
+        (window_end_sample[:vertical_acceleration] - window_begin_sample[:vertical_acceleration]) / elapsed_seconds
+      end
+    end
+
+    def debug_log(message)
+      return unless ENV['JUMP_LOG'] == '1'
+      $stderr.puts "[JumpDetector] #{Time.now.to_f} #{message}"
+    end
+  end
+end

data/lib/road_to_rubykaigi/manager/audio_manager.rb

@@ -23,6 +23,7 @@ module RoadToRubykaigi
         ],
       }
       WALK_SOUND_INTERVAL = 0.25
+      RUN_SOUND_INTERVAL = 0.11
 
       SOUND_FILES.keys.each do |action|
         define_method(action) {
@@ -53,9 +54,10 @@ module RoadToRubykaigi
         end
       end
 
-      def walk
+      def walk(running: false)
         now = Time.now
-        if (now - @last_walk_time) >= WALK_SOUND_INTERVAL
+        interval = running ? RUN_SOUND_INTERVAL : WALK_SOUND_INTERVAL
+        if (now - @last_walk_time) >= interval
           @audio_engine.add_source(@sources[:walk][@walk_index])
           @last_walk_time = now
           @walk_index = (@walk_index + 1) % @sources[:walk].size
@@ -69,6 +71,10 @@ module RoadToRubykaigi
         @melody_sequencer = Audio::MelodySequencer.new
         @fanfare_sequencer = Audio::FanfareSequencer.new
         @audio_engine = Audio::AudioEngine.new(@bass_sequencer, @melody_sequencer)
+        if Config.bgm_off?
+          @audio_engine.remove_source(@bass_sequencer)
+          @audio_engine.remove_source(@melody_sequencer)
+        end
         @sources = SOUND_FILES
         dir = __dir__.sub("lib/road_to_rubykaigi/manager", "")
         @sources.each do |action, file_paths|

data/lib/road_to_rubykaigi/manager/game_manager.rb

@@ -3,7 +3,7 @@ module RoadToRubykaigi
     class GameManager
       UPDATE_RATE = 1.0 / 10
       FRAME_RATE = 1.0 / 60
-      GOAL_X = 650
+      GOAL_X = { 2025 => 650, 2026 => 800 }
       DEMO_GOAL_X = 540
       STATE = {
         playing: 0,
@@ -15,7 +15,7 @@ module RoadToRubykaigi
       attr_reader :fireworks
 
       def self.goal_x
-        @goal_x ||= RoadToRubykaigi.demo? ? DEMO_GOAL_X : GOAL_X
+        @goal_x ||= RoadToRubykaigi.demo? ? DEMO_GOAL_X : GOAL_X[RoadToRubykaigi.version]
       end
 
       def offset_x
@@ -25,6 +25,7 @@ module RoadToRubykaigi
       def update
         @deadline.activate(player_x: @player.x)
         @enemies.activate if player_moved?
+        @score_board.start_timer if @player.x > Sprite::Player::WARMUP_END_X[RoadToRubykaigi.version]
         if @player.x >= GameManager.goal_x && playing?
           EventDispatcher.publish(:ending)
         end

data/lib/road_to_rubykaigi/opening_screen.rb

@@ -27,29 +27,100 @@ module RoadToRubykaigi
       │｡・◡・│_◢◤
       ╰ᜊ───ᜊ─╯
     PLAYER
+    VERSION_ROW = 25
 
     def display
-      x = 0
-      direction = 1
-
       loop do
         ANSI.clear
-        puts "\e[6;1H" + LOGO
-        puts [
-          PLAYER.lines.map.with_index do |line, i|
-            "\e[#{i+1};#{x+OFFSET}H" + line
-          end.join,
-          "\e[4;1H" + "Press Space to start...",
-        ]
-        if $stdin.raw { $stdin.read_nonblock(1, exception: false) == " " }
-          break true
+        render
+        $stdin.raw do
+          if handle_input == :SELECTED
+            item = menu_items[@menu_index]
+            case item
+            when :calibrate
+              CalibrationScreen.new.display
+            when :input_source
+              Config.cycle_input_source
+              @menu_items = nil
+              @menu_index = menu_items.index(:input_source) || 0
+            when :open_controller
+              GameServer.start
+              GameServer.open_controller
+            else
+              return item
+            end
+          end
+          move_player
+          sleep Manager::GameManager::FRAME_RATE
         end
+      end
+    end
+
+    private
+
+    def initialize
+      @player_x = 0
+      @direction = 1
+      @last_move_time = Time.now
+      @menu_index = 0
+    end
+
+    def menu_items
+      return @menu_items if @menu_items
+      @menu_items = RoadToRubykaigi::VERSIONS + [:input_source]
+      @menu_items = @menu_items + [:calibrate, :open_controller] if Config.external_input?
+      @menu_items
+    end
+
+    INPUT_SOURCE_LABELS = { ble: 'BLE', serial: 'Serial', nil => 'Keyboard' }.freeze
+
+    def render
+      puts [
+        "\e[6;1H",
+        LOGO,
+        PLAYER.lines.map.with_index do |line, i|
+          "\e[#{i+1};#{@player_x+OFFSET}H" + line
+        end.join,
+        "\e[4;1H",
+        " Press Space to start...",
+      ]
+      menu_items.each_with_index do |item, i|
+        cursor = i == @menu_index ? " -> " : "    "
+        row_offset = case item
+                     when :input_source, :calibrate, :open_controller then 1
+                     else 0
+                     end
+        label =
+          case item
+          when :calibrate then 'Calibrate sensor'
+          when :open_controller then 'Open Controller'
+          when :input_source then "Input: #{INPUT_SOURCE_LABELS[Config.input_source]}"
+          else "ver. #{RoadToRubykaigi::VERSIONS[i]}"
+          end
+        print "\e[#{VERSION_ROW + i + row_offset};1H#{cursor}#{label}"
+      end
+    end
+
+    def handle_input
+      case $stdin.read_nonblock(3, exception: false)
+      when ANSI::UP
+        @menu_index = (@menu_index - 1) % menu_items.size
+      when ANSI::DOWN
+        @menu_index = (@menu_index + 1) % menu_items.size
+      when " ", ANSI::ENTER, ANSI::LF
+        :SELECTED
+      when ANSI::ETX
+        raise Interrupt
+      end
+    end
 
-        x += direction
-        if x >= WIDTH || x <= 0
-          direction = -direction
+    def move_player
+      if Time.now - @last_move_time >= DELAY
+        @player_x += @direction
+        if @player_x >= WIDTH || @player_x <= 0
+          @direction = -@direction
         end
-        sleep DELAY
+        @last_move_time = Time.now
       end
     end
   end

data/lib/road_to_rubykaigi/score_board.rb

@@ -4,6 +4,10 @@ module RoadToRubykaigi
       @score += 1
     end
 
+    def start_timer
+      @start_time ||= Time.now
+    end
+
     def render_score_board
       "Score: #{@score}".ljust(10).rjust(Map::VIEWPORT_WIDTH)
     end
@@ -24,10 +28,11 @@ module RoadToRubykaigi
 
     def initialize
       @score = 0
-      @start_time = Time.now
+      @start_time = Config.external_input? ? nil : Time.now
     end
 
     def result_time
+      return 0.0 unless @start_time
       (Time.now - @start_time).round(2)
     end
   end

data/lib/road_to_rubykaigi/serial_reader.rb

@@ -0,0 +1,76 @@
+require 'singleton'
+require 'logger'
+require 'uart'
+
+module RoadToRubykaigi
+  class SerialReader
+    include Singleton
+
+    BAUD = 115200
+
+    class << self
+      extend Forwardable
+      def_delegators :instance, :start, :queue, :drain
+    end
+
+    attr_reader :queue
+
+    def drain
+      until @queue.empty?
+        yield @queue.pop(true)
+      end
+    rescue ThreadError
+      # pop(true) raises if the queue empties mid-drain
+    end
+
+    def start
+      @queue.clear
+      Config.detect_serial_port!
+      @port = Config.serial_port
+      return if @thread
+
+      @thread = Thread.new { read_loop }
+      at_exit { @thread&.kill }
+    end
+
+    private
+
+    def initialize
+      @queue = Thread::Queue.new
+      log_path = Config.debug? ? File.join(Config.project_root, 'tmp/serial_reader.log') : File::NULL
+      @logger = Logger.new(log_path)
+    end
+
+    def read_loop
+      serial = UART.open(@port, BAUD)
+      buf = +''
+      loop do
+        chunk = serial.sysread(256)
+        buf << chunk
+        while (idx = buf.index("\n"))
+          line = buf.slice!(0..idx).strip
+          next if line.empty?
+
+          data = parse_line(line)
+          unless data.empty?
+            @logger.info(data.inspect)
+            @queue.push(data)
+          end
+        end
+      rescue EOFError
+        sleep 0.05
+      end
+    rescue => e
+      $stderr.puts "[SerialReader] #{e.message}"
+    ensure
+      serial&.close
+    end
+
+    def parse_line(line)
+      line.split(',').each_with_object({}) do |pair, hash|
+        key, value = pair.split('=', 2)
+        hash[key] = value if key && value
+      end
+    end
+  end
+end