road_to_rubykaigi 0.2.1 → 2026.0.1

data/lib/road_to_rubykaigi/signal_interpreter.rb

@@ -0,0 +1,199 @@
+require 'singleton'
+
+module RoadToRubykaigi
+  class SignalInterpreter
+    include Singleton
+
+    CONTINUATION_WINDOW_SECONDS = 0.2 # short window used for continuation detection to avoid tail smoothing
+    CONTINUATION_TIMEOUT_SECONDS = 0.8 # time without a continuation event before declaring a stop
+    SPEED_RATIO_MIN = 0.7
+    SPEED_RATIO_MAX = 2.3
+    # Assumed motions:
+    #   - in-place running (high intensity, walk-level cadence)
+    #   - forward running (moderate intensity, high cadence)
+    # Forward running raises cadence; in-place running raises intensity.
+    # Speed = cadence_amp + intensity_boost.
+    # cadence_amp is dominant; lifts forward-run.
+    # intensity_boost is supplementary; lifts in-place-run, whose cadence
+    # stays near walk and so cannot be picked up by cadence_amp alone.
+    CADENCE_PIVOT = 1.0     # walking reference; below passes through, above gets gain
+    CADENCE_GAIN = 4.5      # cadence ratios are narrow (~1.0-1.3), so amplify aggressively
+    INTENSITY_PIVOT = 1.1   # intensity must clearly exceed walking before contributing
+    INTENSITY_WEIGHT = 1.6  # additive boost weight for in-place run
+    SPEED_SMOOTHING_ALPHA = 0.4 # EMA weight on the newest sample; lower = smoother, laggier
+
+    # Walk states
+    STOPPED = :stopped # no walk in progress; next start flips direction
+    WALKING = :walking # continuation events arriving
+    PAUSED = :paused   # continuation briefly absent; next event -> WALKING (same direction), timeout -> STOPPED
+
+    Walk = Data.define(:direction, :speed_ratio) do
+      def right? = direction == :right
+    end
+
+    class << self
+      extend Forwardable
+      def_delegators :instance, :process, :log_cue
+    end
+
+    # Drain every queued sample per tick so the pipeline rate matches the
+    # sensor rate instead of being capped at frame rate. NOTE: :input events
+    # may fire multiple times per tick — action handlers must be safe under
+    # repeated same-tick calls (idempotent or self-gated).
+    def process
+      Config.signal_source.drain do |data|
+        if (action = interpret(data))
+          EventDispatcher.publish(:input, action)
+        end
+      end
+      if walk_expired?
+        stop
+        EventDispatcher.publish(:input, :stop)
+      end
+    end
+
+    def log_cue(phase, text)
+      return unless ENV['SIG_LOG'] == '1'
+
+      @sig_log_io ||= open_sig_log_io
+      @sig_log_io.puts "[cue] t=#{Time.now.to_f} phase=#{phase} #{text}"
+    end
+
+    private
+
+    def initialize
+      @window = SignalWindow.new
+      @direction = :right
+      @state = STOPPED
+      @has_started = false
+      @last_continuation_time = nil
+      @smoothed_speed_ratio = nil
+      @start_threshold = Config.start_threshold
+      @continuation_threshold = Config.continuation_threshold
+      @walk_cadence = Config.walk_cadence
+      @walk_intensity = Config.walk_intensity
+      @jump_detector = JumpDetector.new(gravity: Config.gravity_vector)
+    end
+
+    def interpret(data)
+      return unless %w[x y z].all? { |key| data.key?(key) }
+
+      buffer_sample(data)
+      return unless window_full?
+
+      was_walking = walking?
+      track_continuation
+      update_speed_ratio
+      update_walking_state
+      @direction = data['b'] == '1' ? :left : :right
+      log_signal
+
+      if jump_detected?
+        EventDispatcher.publish(:input, :jump)
+      end
+      if was_walking && !walking?
+        :stop
+      elsif walking?
+        Walk.new(direction: @direction, speed_ratio: @smoothed_speed_ratio)
+      end
+    end
+
+    def buffer_sample(data)
+      @window.buffer_sample([data['x'].to_f, data['y'].to_f, data['z'].to_f])
+    end
+
+    def track_continuation
+      @last_continuation_time = Time.now if continuing?
+    end
+
+    # EMA-smoothed mapping of motion strength to output speed. Without
+    # smoothing, small frame-to-frame bumps make the speed flicker.
+    def update_speed_ratio
+      instant = instantaneous_speed_ratio
+      @smoothed_speed_ratio ||= instant
+      @smoothed_speed_ratio = @smoothed_speed_ratio * (1 - SPEED_SMOOTHING_ALPHA) + instant * SPEED_SMOOTHING_ALPHA
+    end
+
+    def instantaneous_speed_ratio
+      return 1.0 unless @walk_intensity && @walk_intensity > 0
+
+      (@window.motion_intensity / @walk_intensity).clamp(SPEED_RATIO_MIN, SPEED_RATIO_MAX)
+    end
+
+    def jump_detected?
+      @jump_detector.detect(sample: @window.last_sample)
+    end
+
+    def update_walking_state
+      case
+      when stopped? && walk_started?           then start
+      when walking? && !continuing?            then pause
+      when paused?  && continuing?             then unpause
+      when paused?  && continuation_timed_out? then stop
+      end
+    end
+
+    def start
+      # @direction = (@direction == :right ? :left : :right) if @has_started
+      @has_started = true
+      @state = WALKING
+    end
+
+    def window_full? = @window.full?
+    def stopped? = @state == STOPPED
+    def walking? = @state == WALKING
+    def unpause = @state = WALKING
+    def paused? = @state == PAUSED
+    def pause = @state = PAUSED
+    def stop = @state = STOPPED
+    def continuation_timed_out?
+      return false if @last_continuation_time.nil?
+      (Time.now - @last_continuation_time) > CONTINUATION_TIMEOUT_SECONDS
+    end
+
+    # True when a walk is in progress but the continuation timeout has elapsed.
+    # The normal PAUSED -> STOPPED transition lives inside interpret(), so it
+    # only fires while samples are flowing. When the stream dries up mid-walk
+    # (device off, BLE buffer drained, stale-drop skipping every sample), this
+    # predicate lets the caller emit :stop on a pure tick basis instead.
+    def walk_expired? = !stopped? && continuation_timed_out?
+
+    # Start detection uses the full window so that a single noisy sample
+    # cannot trigger a fake walk start.
+    def walk_started? = @window.full.motion_intensity > @start_threshold
+
+    # Short-window intensity used for continuation detection. Shorter than the
+    # main window so that the signal drops quickly after motion stops, making
+    # stop detection responsive.
+    def continuing? = @window.tail(seconds: CONTINUATION_WINDOW_SECONDS).motion_intensity > @continuation_threshold
+
+    def log_signal
+      return unless ENV['SIG_LOG'] == '1'
+
+      @sig_log_io ||= open_sig_log_io
+      full = @window.motion_intensity
+      tail = @window.tail(seconds: CONTINUATION_WINDOW_SECONDS).motion_intensity
+      axes = @window.axis_intensities
+      sum = axes.sum
+      ratio = sum.zero? ? 0.0 : axes.max / sum
+      vx, vy, vz = axes.map { |value| value.round(6) }
+      cadence = @window.cadence_hz.round(4)
+      instant = instantaneous_speed_ratio.round(4)
+      speed = @smoothed_speed_ratio.round(4)
+      mag = @window.last_magnitude.round(6)
+      jerk = @window.mag_jerk.round(6)
+      vertical_acceleration = @window.last_vertical_acceleration(Config.gravity_vector).round(6)
+      x, y, z = @window.last_sample.map { |value| value.round(6) }
+      @sig_log_io.puts "#{Time.now.to_f},#{full.round(6)},#{tail.round(6)},#{ratio.round(4)},#{vx},#{vy},#{vz},#{cadence},#{instant},#{speed},#{@state},#{mag},#{jerk},#{vertical_acceleration},#{x},#{y},#{z}"
+    end
+
+    def open_sig_log_io
+      path = File.join(File.expand_path('../../tmp', __dir__), "sig_#{Time.now.strftime('%Y%m%d_%H%M')}.log")
+      file = File.open(path, 'w')
+      file.sync = true
+      file.puts "t,full,tail,ratio,var_x,var_y,var_z,cadence,instant,speed,state,mag,jerk,vertical_acceleration,x,y,z"
+      $stderr.puts "[SIG_LOG] writing to #{path}"
+      file
+    end
+  end
+end

data/lib/road_to_rubykaigi/signal_window.rb

@@ -0,0 +1,139 @@
+module RoadToRubykaigi
+  class SignalWindow
+    BUFFER_SECONDS = 0.5
+    READY_FILL_RATIO = 0.8 # window must be 80% filled (by time) before considered ready
+
+    StepCadence = Data.define(:recent_magnitudes) do
+      WINDOW_SECONDS = 2.0
+      MIN_STEP_INTERVAL_SECONDS = 0.15 # min gap between steps (caps cadence at ~6.7Hz)
+      MIN_SAMPLES_FOR_LOCAL_MAXIMUM = 3 # need prev/current/next to detect a local maximum
+
+      def record(sample)
+        magnitude = Math.sqrt(sample[0] ** 2 + sample[1] ** 2 + sample[2] ** 2)
+        now = Time.now
+        recent_magnitudes << { time: now, magnitude: magnitude }
+        window_start = now - WINDOW_SECONDS
+        recent_magnitudes.shift while recent_magnitudes.first[:time] < window_start
+      end
+
+      # Step cadence in Hz: count of local maxima in the recent magnitudes divided
+      # by the window duration. Walking produce one peak per footstrike, so cadence tracks step frequency.
+      def hz
+        return 0.0 if recent_magnitudes.size < MIN_SAMPLES_FOR_LOCAL_MAXIMUM
+
+        magnitudes = recent_magnitudes.map { |entry| entry[:magnitude] }
+        mean = magnitudes.sum / magnitudes.size
+        step_count = 0
+        last_step_time = nil
+        (1...(recent_magnitudes.size - 1)).each do |i|
+          time = recent_magnitudes[i][:time]
+          magnitude = recent_magnitudes[i][:magnitude]
+          prev_magnitude = recent_magnitudes[i - 1][:magnitude]
+          next_magnitude = recent_magnitudes[i + 1][:magnitude]
+          is_local_maximum = magnitude > prev_magnitude && magnitude > next_magnitude
+          above_mean = magnitude > mean # only count bumps stronger than the average
+          enough_gap_from_last_step = last_step_time.nil? || (time - last_step_time) >= MIN_STEP_INTERVAL_SECONDS
+          if is_local_maximum && above_mean && enough_gap_from_last_step
+            step_count += 1
+            last_step_time = time
+          end
+        end
+
+        duration = recent_magnitudes.last[:time] - recent_magnitudes.first[:time]
+        return 0.0 if duration <= 0 # guard against division by zero (just in case)
+
+        step_count / duration
+      end
+
+      def ready?
+        return false if recent_magnitudes.size < MIN_SAMPLES_FOR_LOCAL_MAXIMUM
+        (recent_magnitudes.last[:time] - recent_magnitudes.first[:time]) >= WINDOW_SECONDS * READY_FILL_RATIO
+      end
+    end
+
+    def buffer_sample(sample)
+      now = Time.now
+      @samples << { time: now, sample: sample }
+      window_start = now - BUFFER_SECONDS
+      @samples.shift while @samples.first[:time] < window_start
+      @step_cadence.record(sample)
+    end
+
+    def cadence_hz = @step_cadence.hz
+    def cadence_ready? = @step_cadence.ready?
+
+    def full?
+      return false if @samples.size < 2
+      (@samples.last[:time] - @samples.first[:time]) >= BUFFER_SECONDS * READY_FILL_RATIO
+    end
+
+    # Returns how far samples in the window spread from their mean position
+    # (RMS distance across all 3 axes).
+    def motion_intensity
+      Math.sqrt(axis_variance(0) + axis_variance(1) + axis_variance(2))
+    end
+
+    # Per-axis RMS spread. Same unit as motion_intensity but kept separate so
+    # callers can compare how energy is distributed across axes.
+    def axis_intensities
+      [0, 1, 2].map { |index| Math.sqrt(axis_variance(index)) }
+    end
+
+    # Raw acceleration magnitude of the latest sample: sqrt(x² + y² + z²).
+    def last_magnitude
+      sample = @samples.last[:sample]
+      Math.sqrt(sample[0] ** 2 + sample[1] ** 2 + sample[2] ** 2)
+    end
+
+    # Raw [x, y, z] of the latest sample (before variance/intensity).
+    def last_sample
+      @samples.last[:sample]
+    end
+
+    # Signed vertical acceleration of the latest sample after removing
+    # gravity. Positive = accelerating upward, negative = downward.
+    def last_vertical_acceleration(gravity)
+      sample = @samples.last[:sample]
+      # Magnitude of the gravity reference vector (used to normalize the
+      # projection below and as the resting 1g offset).
+      gravity_magnitude = Math.sqrt(gravity[0] ** 2 + gravity[1] ** 2 + gravity[2] ** 2)
+      # Sample projected onto the vertical axis, normalized to g units.
+      projection = (sample[0] * gravity[0] + sample[1] * gravity[1] + sample[2] * gravity[2]) / gravity_magnitude
+      # Subtract the resting offset.
+      projection - gravity_magnitude
+    end
+
+    # Average absolute change in magnitude between consecutive samples.
+    # Walking/running produce sharp footstrike impacts (high jerk),
+    # while jumping produces smoother acceleration curves (low jerk).
+    def mag_jerk
+      mags = @samples.map { |entry| s = entry[:sample]; Math.sqrt(s[0] ** 2 + s[1] ** 2 + s[2] ** 2) }
+      deltas = mags.each_cons(2).map { |a, b| (b - a).abs }
+      deltas.sum / deltas.size
+    end
+
+    def full
+      self
+    end
+
+    # Sub-window containing samples from the last `seconds`, for continuation detection.
+    def tail(seconds:)
+      return SignalWindow.new([]) if @samples.empty?
+      cutoff = @samples.last[:time] - seconds
+      SignalWindow.new(@samples.select { |entry| entry[:time] >= cutoff })
+    end
+
+    private
+
+    def initialize(samples = [])
+      @samples = samples
+      @step_cadence = StepCadence.new(recent_magnitudes: [])
+    end
+
+    def axis_variance(index)
+      values = @samples.map { |entry| entry[:sample][index] }
+      mean = values.sum / values.size
+      values.sum { |value| (value - mean) ** 2 } / values.size
+    end
+  end
+end

data/lib/road_to_rubykaigi/sprite/bonus.rb

@@ -6,50 +6,87 @@ module RoadToRubykaigi
       extend Forwardable
       def_delegators :@bonuses, :to_a, :find, :delete
       BONUSES_DATA = {
-        Basic: [
-          { x: 39, y: 22, character: :ruby },
-          { x: 46, y: 22, character: :ruby },
-          { x: 53, y: 22, character: :ruby },
-          { x: 107, y: 23, character: :coffee },
-          { x: 110, y: 23, character: :book },
-          { x: 142, y: 16, character: :ruby },
-          { x: 146, y: 16, character: :ruby },
-          { x: 205, y: 19, character: :money },
-          { x: 212, y: 19, character: :money },
-          { x: 205, y: 19, character: :money },
-          { x: 212, y: 19, character: :money },
-          { x: 223, y: 17, character: :money },
-          { x: 231, y: 17, character: :money },
-          { x: 243, y: 13, character: :money },
-          { x: 250, y: 13, character: :money },
-          { x: 260, y: 10, character: :sushi },
-          { x: 265, y: 10, character: :meat },
-          { x: 270, y: 10, character: :fish },
-          { x: 260, y: 10, character: :sushi },
-          { x: 265, y: 10, character: :meat },
-          { x: 270, y: 10, character: :fish },
-          { x: 275, y: 10, character: :sushi },
-          { x: 280, y: 10, character: :meat },
-          { x: 285, y: 10, character: :fish },
-          { x: 290, y: 10, character: :sushi },
-          { x: 295, y: 10, character: :meat },
-          { x: 300, y: 10, character: :fish },
-          { x: 358, y: 15, character: :money },
-          { x: 363, y: 13, character: :money },
-          { x: 368, y: 15, character: :money },
-          { x: 373, y: 13, character: :money },
-          { x: 378, y: 15, character: :money },
-          { x: 383, y: 13, character: :money },
-          { x: 388, y: 15, character: :money },
-        ],
-        Alcohol: [
-          { x: 217, y: 28, character: :beer },
-          { x: 220, y: 28, character: :beer },
-          { x: 223, y: 28, character: :beer },
-        ],
-        Laptop: [
-          { x: 298, y: 23, character: :laptop },
-        ]
+        2025 => {
+          Basic: [
+            { x: 39, y: 22, character: :ruby },
+            { x: 46, y: 22, character: :ruby },
+            { x: 53, y: 22, character: :ruby },
+            { x: 107, y: 23, character: :coffee },
+            { x: 110, y: 23, character: :book },
+            { x: 142, y: 16, character: :ruby },
+            { x: 146, y: 16, character: :ruby },
+            { x: 205, y: 19, character: :money },
+            { x: 212, y: 19, character: :money },
+            { x: 205, y: 19, character: :money },
+            { x: 212, y: 19, character: :money },
+            { x: 223, y: 17, character: :money },
+            { x: 231, y: 17, character: :money },
+            { x: 243, y: 13, character: :money },
+            { x: 250, y: 13, character: :money },
+            { x: 260, y: 10, character: :sushi },
+            { x: 265, y: 10, character: :meat },
+            { x: 270, y: 10, character: :fish },
+            { x: 260, y: 10, character: :sushi },
+            { x: 265, y: 10, character: :meat },
+            { x: 270, y: 10, character: :fish },
+            { x: 275, y: 10, character: :sushi },
+            { x: 280, y: 10, character: :meat },
+            { x: 285, y: 10, character: :fish },
+            { x: 290, y: 10, character: :sushi },
+            { x: 295, y: 10, character: :meat },
+            { x: 300, y: 10, character: :fish },
+            { x: 358, y: 15, character: :money },
+            { x: 363, y: 13, character: :money },
+            { x: 368, y: 15, character: :money },
+            { x: 373, y: 13, character: :money },
+            { x: 378, y: 15, character: :money },
+            { x: 383, y: 13, character: :money },
+            { x: 388, y: 15, character: :money },
+          ],
+          Alcohol: [
+            { x: 217, y: 28, character: :beer },
+            { x: 220, y: 28, character: :beer },
+            { x: 223, y: 28, character: :beer },
+          ],
+          Laptop: [
+            { x: 298, y: 23, character: :laptop },
+          ],
+        },
+        2026 => {
+          Basic: [
+            { x: 60, y: 25, character: :ruby },
+            { x: 67, y: 25, character: :ruby },
+            { x: 74, y: 25, character: :ruby },
+            { x: 107, y: 23, character: :coffee },
+            { x: 110, y: 23, character: :book },
+            { x: 140, y: 13, character: :ruby },
+            { x: 167, y: 13, character: :ruby },
+            { x: 182, y: 13, character: :ruby },
+
+            { x: 240, y: 20, character: :money },
+            { x: 260, y: 18, character: :money },
+            { x: 279, y: 16, character: :money },
+
+            { x: 315, y: 18, character: :sushi },
+            { x: 320, y: 18, character: :meat },
+            { x: 325, y: 18, character: :fish },
+            { x: 330, y: 18, character: :sushi },
+            { x: 335, y: 18, character: :meat },
+
+            { x: 390, y: 13, character: :money },
+            { x: 399, y: 14, character: :money },
+            { x: 406, y: 14, character: :money },
+            { x: 415, y: 14, character: :money },
+
+            { x: 600, y: 15, character: :sakura },
+            { x: 613, y: 13, character: :sakura },
+            { x: 626, y: 11, character: :sakura },
+            { x: 713, y: 11, character: :sakura },
+
+          ],
+          Alcohol: [],
+          Laptop: [],
+        },
       }
 
       def build_buffer(offset_x:)
@@ -73,7 +110,7 @@ module RoadToRubykaigi
       private
 
       def initialize
-        @bonuses = BONUSES_DATA.map do |key, bonuses|
+        @bonuses = BONUSES_DATA[RoadToRubykaigi.version].map do |key, bonuses|
           bonuses.map do |bonus|
             Bonus.new(
               bonus[:x],
@@ -94,6 +131,7 @@ module RoadToRubykaigi
         sushi: "🍣",
         meat: "🍖",
         fish: "🐟",
+        sakura: "🌸",
         beer: "🍺",
         sake: "🍶",
         laptop: "💻",

data/lib/road_to_rubykaigi/sprite/deadline.rb

@@ -2,7 +2,7 @@ module RoadToRubykaigi
   module Sprite
     class Deadline < Sprite
       DEADLINE_SPEED = 0.3
-      DEADLINE_START_X = 18
+      DEADLINE_START_X = { 2025 => 18, 2026 => 48 }
 
       attr_reader :x, :y, :width, :height
 
@@ -35,7 +35,7 @@ module RoadToRubykaigi
       end
 
       def activate(player_x:)
-        @waiting = false if player_x > DEADLINE_START_X
+        @waiting = false if player_x > DEADLINE_START_X[RoadToRubykaigi.version]
       end
 
       private

data/lib/road_to_rubykaigi/sprite/enemy.rb

@@ -6,26 +6,33 @@ module RoadToRubykaigi
       extend Forwardable
       def_delegators :@enemies, :to_a, :find, :delete, :each
       ENEMIES_DATA = {
-        FixedPatrol: [
-          { x: 55, y: 6, left_bound: 0, right_bound: 0, speed: 0, character: :ladybug },
-          { x: 125, y: 8, left_bound: 0, right_bound: 0, speed: 0, character: :ladybug },
-          { x: 293, y: 23, left_bound: 0, right_bound: 0, speed: 0, character: :spider },
-        ],
-        HorizontalPatrol: [
-          { x: 123, y: 26, left_bound: 114, right_bound: 123, speed: 1.5, character: :bee },
-          { x: 171, y: 26, left_bound: 162, right_bound: 171, speed: 1.5, character: :bee },
-          { x: 278, y: 15, left_bound: 270, right_bound: 278, speed: 1.5, character: :bug },
-          { x: 291, y: 15, left_bound: 283, right_bound: 291, speed: 1.5, character: :bug },
-          { x: 302, y: 15, left_bound: 297, right_bound: 302, speed: 1.5, character: :bug },
-        ],
-        ScreenEntryPatrol: [
-          { x: 63, y: 27, left_bound: 0, right_bound: 63, speed: 4.0, character: :bug },
-          { x: 76, y: 27, left_bound: 0, right_bound: 76, speed: 4.0, character: :bug },
-          { x: 87, y: 27, left_bound: 0, right_bound: 76, speed: 4.0, character: :bug },
-          { x: 221, y: 23, left_bound: 0, right_bound: 151, speed: 6.0, character: :bee },
-          { x: 240, y: 19, left_bound: 0, right_bound: 170, speed: 6.0, character: :bee },
-          { x: 256, y: 16, left_bound: 0, right_bound: 186, speed: 6.0, character: :bee },
-        ],
+        2025 => {
+          FixedPatrol: [
+            { x: 55, y: 6, left_bound: 0, right_bound: 0, speed: 0, character: :ladybug },
+            { x: 125, y: 8, left_bound: 0, right_bound: 0, speed: 0, character: :ladybug },
+            { x: 293, y: 23, left_bound: 0, right_bound: 0, speed: 0, character: :spider },
+          ],
+          HorizontalPatrol: [
+            { x: 123, y: 26, left_bound: 114, right_bound: 123, speed: 1.5, character: :bee },
+            { x: 171, y: 26, left_bound: 162, right_bound: 171, speed: 1.5, character: :bee },
+            { x: 278, y: 15, left_bound: 270, right_bound: 278, speed: 1.5, character: :bug },
+            { x: 291, y: 15, left_bound: 283, right_bound: 291, speed: 1.5, character: :bug },
+            { x: 302, y: 15, left_bound: 297, right_bound: 302, speed: 1.5, character: :bug },
+          ],
+          ScreenEntryPatrol: [
+            { x: 63, y: 27, left_bound: 0, right_bound: 63, speed: 4.0, character: :bug },
+            { x: 76, y: 27, left_bound: 0, right_bound: 76, speed: 4.0, character: :bug },
+            { x: 87, y: 27, left_bound: 0, right_bound: 76, speed: 4.0, character: :bug },
+            { x: 221, y: 23, left_bound: 0, right_bound: 151, speed: 6.0, character: :bee },
+            { x: 240, y: 19, left_bound: 0, right_bound: 170, speed: 6.0, character: :bee },
+            { x: 256, y: 16, left_bound: 0, right_bound: 186, speed: 6.0, character: :bee },
+          ],
+        },
+        2026 => {
+          FixedPatrol: [],
+          HorizontalPatrol: [],
+          ScreenEntryPatrol: [],
+        },
       }
 
       def build_buffer(offset_x:)
@@ -62,7 +69,7 @@ module RoadToRubykaigi
       private
 
       def initialize
-        @enemies = ENEMIES_DATA.map do |key, enemies|
+        @enemies = ENEMIES_DATA[RoadToRubykaigi.version].map do |key, enemies|
           strategy = RoadToRubykaigi::Sprite.const_get("#{key}Strategy")
           enemies.map do |enemy|
             Enemy.new(

data/lib/road_to_rubykaigi/sprite/player.rb

@@ -7,9 +7,14 @@ module RoadToRubykaigi
       WALK_ACCEL = 15.0
       WALK_MAX_SPEED = 20.0
       WALK_FRICTION = 1.0
+      RUNNING_SPEED_THRESHOLD = 1.3
+      RUNNING_SUSTAIN_SECOND = 0.3
 
-      INITIAL_X = 10
+      INITIAL_X = { 2025 => 10, 2026 => 40 }
+      WARMUP_END_X = { 2025 => 18, 2026 => 48 }
+      WARMUP_SPEED_RATIO_CAP = 1.0
       BASE_Y = 26
+      INITIAL_Y = { 2025 => BASE_Y, 2026 => 15 }
       BASE_HEIGHT = 3
       JUMP_INITIAL_VELOCITY = -40.0
       JUMP_GRAVITY = 80.0
@@ -23,12 +28,23 @@ module RoadToRubykaigi
       RIGHT = 1
       LEFT = -1
 
-      def right
-        move(RIGHT)
+      def right(speed_ratio = 1.0)
+        move(RIGHT, speed_ratio)
       end
 
-      def left
-        move(LEFT)
+      def left(speed_ratio = 1.0)
+        move(in_warmup? ? RIGHT : LEFT, speed_ratio)
+      end
+
+      # @param [SignalInterpreter::Walk] action
+      def walk(action)
+        action.right? ? right(action.speed_ratio) : left(action.speed_ratio)
+      end
+
+      def stop
+        @vx = 0
+        @last_speed_ratio = 1.0
+        @fast_speed_since = nil
       end
 
       def jump
@@ -182,8 +198,8 @@ module RoadToRubykaigi
       private
 
       def initialize
-        @x = INITIAL_X
-        @y = BASE_Y
+        @x = INITIAL_X[RoadToRubykaigi.version]
+        @y = INITIAL_Y[RoadToRubykaigi.version]
         @vx = 0.0
         @vy = 0.0
         @width ||= {}
@@ -198,15 +214,25 @@ module RoadToRubykaigi
         @stunned_until = Time.now
         @attack_mode = false
         @last_attack_time = Time.now
+        @last_speed_ratio = 1.0
+        @fast_speed_since = nil
       end
 
-      def move(dx)
+      def move(dx, speed_ratio = 1.0)
+        speed_ratio = [speed_ratio, WARMUP_SPEED_RATIO_CAP].min if in_warmup?
         unless current_direction == dx
           @vx = 0
         end
         @vx += WALK_ACCEL * dx
-        @vx = @vx.clamp(-WALK_MAX_SPEED, WALK_MAX_SPEED)
-        Manager::AudioManager.instance.walk
+        max_speed = WALK_MAX_SPEED * speed_ratio
+        @vx = @vx.clamp(-max_speed, max_speed)
+        @last_speed_ratio = speed_ratio
+        if speed_ratio >= RUNNING_SPEED_THRESHOLD
+          @fast_speed_since ||= Time.now
+        else
+          @fast_speed_since = nil
+        end
+        Manager::AudioManager.instance.walk(running: running?)
       end
 
       def fall
@@ -237,12 +263,25 @@ module RoadToRubykaigi
 
       def current_character
         posture = crouching? ? :crouching : :standup
-        status = stunned? ? :stunned : :normal
+        status = stunned? ? :stunned : running? ? :running : :normal
         Graphics::Player.character(
-          posture: posture, status: status, direction: current_direction, attack_mode: @attack_mode
+          posture:, status:, direction: current_direction, attack_mode: @attack_mode
         )
       end
 
+      def running? = !crouching? && @fast_speed_since && (Time.now - @fast_speed_since) >= RUNNING_SUSTAIN_SECOND
+
+      def in_warmup?
+        if @warmed_up || !Config.external_input?
+          false
+        elsif @x > WARMUP_END_X[RoadToRubykaigi.version]
+          @warmed_up = true
+          false
+        else
+          true
+        end
+      end
+
       def jumping?
         @jumping
       end