road_to_rubykaigi 0.1.0 → 0.2.1

data/lib/road_to_rubykaigi/manager/audio_manager.rb

@@ -0,0 +1,82 @@
+require 'singleton'
+
+module RoadToRubykaigi
+  module Manager
+    class AudioManager
+      include Singleton
+      SOUND_FILES = {
+        attack: %w[
+          lib/road_to_rubykaigi/audio/wav/attack_03.wav
+          lib/road_to_rubykaigi/audio/wav/attack_04.wav
+          lib/road_to_rubykaigi/audio/wav/attack_05.wav
+        ],
+        bonus: %w[lib/road_to_rubykaigi/audio/wav/bonus.wav],
+        crouch: %w[lib/road_to_rubykaigi/audio/wav/crouch.wav],
+        defeat: %w[lib/road_to_rubykaigi/audio/wav/defeat.wav],
+        game_over: %w[lib/road_to_rubykaigi/audio/wav/game_over.wav],
+        jump: %w[lib/road_to_rubykaigi/audio/wav/jump.wav],
+        laptop: %w[lib/road_to_rubykaigi/audio/wav/laptop.wav],
+        stun: %w[lib/road_to_rubykaigi/audio/wav/stun.wav],
+        walk: %w[
+          lib/road_to_rubykaigi/audio/wav/walk_01.wav
+          lib/road_to_rubykaigi/audio/wav/walk_02.wav
+        ],
+      }
+      WALK_SOUND_INTERVAL = 0.25
+
+      SOUND_FILES.keys.each do |action|
+        define_method(action) {
+          @audio_engine.add_source(@sources[action].sample)
+        }
+      end
+
+      def fanfare
+        @audio_engine.mute
+        @audio_engine.remove_source(@bass_sequencer)
+        @audio_engine.remove_source(@melody_sequencer)
+        @audio_engine.unmute
+        @audio_engine.add_source(@fanfare_sequencer)
+      end
+
+      def fanfare_finished?
+        @fanfare_sequencer.finished?
+      end
+
+      def game_over
+        @sources[:game_over].first.tap do |source|
+          @audio_engine.remove_source(@bass_sequencer)
+          @audio_engine.remove_source(@melody_sequencer)
+          @audio_engine.add_source(source)
+          until source.finished?
+            sleep 0.1
+          end
+        end
+      end
+
+      def walk
+        now = Time.now
+        if (now - @last_walk_time) >= WALK_SOUND_INTERVAL
+          @audio_engine.add_source(@sources[:walk][@walk_index])
+          @last_walk_time = now
+          @walk_index = (@walk_index + 1) % @sources[:walk].size
+        end
+      end
+
+      private
+
+      def initialize
+        @bass_sequencer = Audio::BassSequencer.new
+        @melody_sequencer = Audio::MelodySequencer.new
+        @fanfare_sequencer = Audio::FanfareSequencer.new
+        @audio_engine = Audio::AudioEngine.new(@bass_sequencer, @melody_sequencer)
+        @sources = SOUND_FILES
+        dir = __dir__.sub("lib/road_to_rubykaigi/manager", "")
+        @sources.each do |action, file_paths|
+          @sources[action] = file_paths.map { |file_path| Audio::WavSource.new(dir + file_path) }
+        end
+        @walk_index = 0
+        @last_walk_time = Time.now - 1
+      end
+    end
+  end
+end

data/lib/road_to_rubykaigi/manager/collision_manager.rb

@@ -2,122 +2,37 @@ module RoadToRubykaigi
   module Manager
     class CollisionManager
       def process
-        event = [player_meet_enemy] # player must hit enemy before land
-        player_fall
-        player_land
-
-        event += [
-          player_meet_deadline,
-          player_meet_bonus,
-          attack_hit_bonus,
-          attack_hit_enemy,
-        ]
-        if event.include?(:game_over)
-          :game_over
-        elsif event.include?(:bonus)
-          :bonus
-        end
-      end
-
-      private
-
-      def initialize(background, foreground)
-        @map = background
-        @player, @deadline, @bonuses, @enemies, @attacks, @effects = foreground.layers
-      end
-
-      def player_fall
-        bounding_box = @player.bounding_box
-        foot_y = bounding_box[:y] + bounding_box[:height]
-        center_x = bounding_box[:x] + bounding_box[:width] / 2.0
-        if @map.passable_at?(center_x, foot_y + 1)
-          @player.fall
-        end
-      end
-
-      def player_land
-        bounding_box = @player.bounding_box
-        foot_y = bounding_box[:y] + bounding_box[:height]
-        foot_y = foot_y.clamp(bounding_box[:height], RoadToRubykaigi::Sprite::Player::BASE_Y)
-        (bounding_box[:x]...(bounding_box[:x] + bounding_box[:width])).each do |col|
-          unless @map.passable_at?(col, foot_y)
-            break @player.land(foot_y)
+        {
+          attack_bonus: [@attacks, @bonuses],
+          attack_enemy: [@attacks, @enemies],
+          player_bonus: [[@player], @bonuses],
+          player_deadline: [[@player], [@deadline]],
+          player_enemy: [[@player], @enemies],
+        }.each do |type, pair|
+          collided_pair = find_collided_pair(*pair)
+          unless collided_pair.empty?
+            EventDispatcher.publish(:collision, { type: type, pair: collided_pair })
           end
         end
       end
 
-      # @returns [:game_over, Nil]
-      def player_meet_deadline
-        find_collision_item(@player, @deadline) && :game_over
-      end
-
-      def player_meet_bonus
-        if (collided_item = find_collision_item(@player, @bonuses))
-          @effects.heart(
-            @player.x + @player.width - 1,
-            @player.y,
-          )
-          @bonuses.delete(collided_item)
-          :bonus
-        end
-      end
-
-      # @returns [:bonus, false]
-      def attack_hit_bonus
-        collided = !@attacks.dup.select do |attack|
-          if (collided_item = find_collision_item(attack, @bonuses))
-            @effects.heart(
-              @player.x + @player.width - 1,
-              @player.y,
-            )
-            @bonuses.delete(collided_item)
-            @attacks.delete(attack)
-          end
-        end.empty?
-        collided && :bonus
-      end
+      private
 
-      # @returns [:bonus, Nil]
-      def attack_hit_enemy
-        collided = !@attacks.dup.select do |attack|
-          if (collided_item = find_collision_item(attack, @enemies))
-            @effects.note(
-              @player.x + @player.width - 1,
-              @player.y,
-            )
-            @enemies.delete(collided_item)
-            @attacks.delete(attack)
-          end
-        end.empty?
-        collided && :bonus
+      def initialize(attacks:, bonuses:, deadline:, enemies:, player:)
+        @attacks = attacks
+        @bonuses = bonuses
+        @deadline = deadline
+        @enemies = enemies
+        @player = player
       end
 
-      # @returns [:bonus, Nil]
-      def player_meet_enemy
-        if (collided_item = find_collision_item(@player, @enemies))
-          if @player.stompable?
-            @effects.note(
-              @player.x + @player.width - 1,
-              @player.y,
-            )
-            @enemies.delete(collided_item)
-            @player.vy = @player.class::JUMP_INITIAL_VELOCITY
-            :bonus
-          else
-            @effects.lightning(
-              @player.x + @player.width - 1,
-              @player.y,
-            )
-            @enemies.delete(collided_item)
-            @player.stun
+      def find_collided_pair(entities, others)
+        entities.map do |entity|
+          found = others.find do |other|
+            collided?(entity.bounding_box, other.bounding_box)
           end
-        end
-      end
-
-      def find_collision_item(entity, others)
-        others.find do |other|
-          collided?(entity.bounding_box, other.bounding_box)
-        end
+          break [entity, found] if found
+        end.compact
       end
 
       def collided?(box1, box2)

data/lib/road_to_rubykaigi/manager/drawing_manager.rb

@@ -13,7 +13,7 @@ module RoadToRubykaigi
         ANSI.home
         ANSI.background_color
         ANSI.default_text_color
-        print @score_board.render
+        print @game_manager.render_score_board
         @viewport_height.times do |row|
           @viewport_width.times do |col|
             unless buffer[row][col] == @preview_buffer[row][col]
@@ -26,14 +26,15 @@ module RoadToRubykaigi
 
       private
 
-      def initialize(score_board, background, foreground, fireworks)
+      def initialize(map:, attacks:, bonuses:, deadline:, effects:, enemies:, player:, game_manager:)
         @viewport_width = Map::VIEWPORT_WIDTH
         @viewport_height = Map::VIEWPORT_HEIGHT
         @preview_buffer = Array.new(@viewport_height) { Array.new(@viewport_width) { "" } }
-        @score_board = score_board
-        @background = background
-        @foreground = foreground
-        @layers = [background, *foreground.layers, fireworks]
+        @game_manager = game_manager
+        @layers = [
+          # From bottom to top
+          map, player, deadline, bonuses, enemies, attacks, effects, game_manager.fireworks,
+        ]
       end
 
       def merge_buffer(buffer, layer, offset_x:)

data/lib/road_to_rubykaigi/manager/game_manager.rb

@@ -1,7 +1,10 @@
 module RoadToRubykaigi
   module Manager
     class GameManager
+      UPDATE_RATE = 1.0 / 10
+      FRAME_RATE = 1.0 / 60
       GOAL_X = 650
+      DEMO_GOAL_X = 540
       STATE = {
         playing: 0,
         pause: 1,
@@ -11,29 +14,68 @@ module RoadToRubykaigi
       }
       attr_reader :fireworks
 
+      def self.goal_x
+        @goal_x ||= RoadToRubykaigi.demo? ? DEMO_GOAL_X : GOAL_X
+      end
+
+      def offset_x
+        (@player.x - Map::VIEWPORT_WIDTH / 2).clamp(0, @map.width - Map::VIEWPORT_WIDTH).to_i
+      end
+
       def update
         @deadline.activate(player_x: @player.x)
         @enemies.activate if player_moved?
-        if @player.x >= GOAL_X && playing?
-          game_clear
+        if @player.x >= GameManager.goal_x && playing?
+          EventDispatcher.publish(:ending)
         end
       end
 
-      def finish
-        @state = STATE[:finished]
+      def increment_score
+        @score_board.increment
+      end
+
+      def render_score_board
+        @score_board.render_score_board
+      end
+
+      def render_result
+        if game_over?
+          @score_board.render_game_over_result
+        else
+          @score_board.render_clear_result
+        end
       end
 
-      def finished?
-        @state == STATE[:finished]
+      def result?
+        @state == STATE[:game_over] || @state == STATE[:finished]
+      end
+
+      def game_over
+        @state = STATE[:game_over]
+      end
+
+      def game_over?
+        @state == STATE[:game_over]
+      end
+
+      def ending
+        @state = STATE[:ending]
+        @fireworks.shoot
+      end
+
+      def finish
+        @state = STATE[:finished]
       end
 
       private
 
-      def initialize(player, deadline, enemies)
+      def initialize(map:, deadline:, enemies:, player:)
+        @map = map
         @player = player
         @deadline = deadline
         @enemies = enemies
-        @fireworks = RoadToRubykaigi::Fireworks.new(self)
+        @score_board = ScoreBoard.new
+        @fireworks = RoadToRubykaigi::Fireworks.new
         @state = STATE[:playing]
       end
 
@@ -45,11 +87,6 @@ module RoadToRubykaigi
       def playing?
         @state == STATE[:playing]
       end
-
-      def game_clear
-        @state = STATE[:ending]
-        @fireworks.shoot
-      end
     end
   end
 end

data/lib/road_to_rubykaigi/manager/physics_engine.rb

@@ -0,0 +1,21 @@
+module RoadToRubykaigi
+  module Manager
+    class PhysicsEngine
+      def simulate
+        @attacks.simulate_physics
+        @deadline.simulate_physics
+        @enemies.simulate_physics
+        @player.simulate_physics
+      end
+
+      private
+
+      def initialize(attacks:, deadline:, enemies:, player:)
+        @attacks = attacks
+        @deadline = deadline
+        @enemies = enemies
+        @player = player
+      end
+    end
+  end
+end

data/lib/road_to_rubykaigi/manager/update_manager.rb

@@ -2,25 +2,28 @@ module RoadToRubykaigi
   module Manager
     class UpdateManager
       def update(offset_x:)
-        enemies = @entities[3]
-        enemies.each do |enemy|
+        @enemies.each do |enemy|
           enemy.activate_with_offset(offset_x)
         end
-        @entities.each(&:update)
-        enforce_boundary(offset_x: offset_x)
+        @effects.update
+        @enemies.update
+        @player.update
+        @fireworks.update
+        @player.enforce_boundary(@map, offset_x: offset_x)
+        @attacks.enforce_boundary(@map, offset_x: offset_x)
+        @player.fall_if_ground_is_passable(@map)
+        @player.land_unless_ground_is_passable(@map)
       end
 
       private
 
-      def initialize(map, foreground, fireworks)
+      def initialize(map:, attacks:, effects:, enemies:, player:, fireworks:)
         @map = map
-        @entities = foreground.layers + [fireworks]
-      end
-
-      def enforce_boundary(offset_x:)
-        @entities.each do |entity|
-          entity.respond_to?(:enforce_boundary) && entity.enforce_boundary(@map, offset_x:)
-        end
+        @attacks = attacks
+        @effects = effects
+        @enemies = enemies
+        @player = player
+        @fireworks = fireworks
       end
     end
   end

data/lib/road_to_rubykaigi/map.rb

@@ -12,7 +12,7 @@ module RoadToRubykaigi
 
     def clamp_position(x:, y:, width:, height:, dx:, dy:)
       clamped_x = x.clamp(2, @width - width)
-      clamped_y = y.clamp(2, @height - height)
+      clamped_y = y.clamp(2, @height - (Sprite::Player::BASE_HEIGHT - height))
       return [clamped_x, clamped_y] if box_passable?(clamped_x, clamped_y, width, height)
 
       attempt_count = 10
@@ -85,20 +85,6 @@ module RoadToRubykaigi
     end
   end
 
-  class Layer
-    attr_reader :layers
-
-    def build_buffer(offset_x:)
-      @layers.map { |layer| layer.build_buffer(offset_x: offset_x) }
-    end
-
-    private
-
-    def initialize(player:, deadline:, bonuses:, enemies:, attacks:, effects:)
-      @layers = [player, deadline, bonuses, enemies, attacks, effects]
-    end
-  end
-
   class Tile
     MASK_CHAR = "#"
 

data/lib/road_to_rubykaigi/score_board.rb

@@ -4,14 +4,31 @@ module RoadToRubykaigi
       @score += 1
     end
 
-    def render
+    def render_score_board
       "Score: #{@score}".ljust(10).rjust(Map::VIEWPORT_WIDTH)
     end
 
+    def render_clear_result
+      [ANSI::BLUE + "CLEAR!" + ANSI::DEFAULT_TEXT_COLOR, "Score: #{@score}", "Time: #{result_time} seconds"].map.with_index do |message, i|
+        ANSI::RESULT_DATA[i] + "  #{message}  "
+      end.join
+    end
+
+    def render_game_over_result
+      [ANSI::RED + "Game Over" + ANSI::DEFAULT_TEXT_COLOR, "Score: #{@score}", "Time: #{result_time} seconds"].map.with_index do |message, i|
+        ANSI::RESULT_DATA[i] + "  #{message}  "
+      end.join
+    end
+
     private
 
     def initialize
       @score = 0
+      @start_time = Time.now
+    end
+
+    def result_time
+      (Time.now - @start_time).round(2)
     end
   end
 end

data/lib/road_to_rubykaigi/sprite/attack.rb

@@ -4,13 +4,18 @@ module RoadToRubykaigi
   module Sprite
     class Attacks
       extend Forwardable
-      def_delegators :@attacks, :each, :delete, :select
+      def_delegators :@attacks, :each, :map, :delete, :select
+      ATTACK_COUNT = 13
 
-      def add(x, y)
-        @attacks << Attack.new(x, y)
+      def remain_attack?
+        @attacks.size < ATTACK_COUNT
       end
 
-      def update
+      def add(player)
+        @attacks << Attack.new(*player.attack_position, player.current_direction)
+      end
+
+      def simulate_physics
         @attacks.each(&:move)
       end
 
@@ -43,9 +48,10 @@ module RoadToRubykaigi
 
     class Attack < Sprite
       SYMBOL = ".˖"
+      SPEED = 3
 
       def move
-        @x += 1
+        @x += @direction * SPEED
       end
 
       def characters
@@ -63,9 +69,10 @@ module RoadToRubykaigi
 
       private
 
-      def initialize(x, y)
+      def initialize(x, y, direction)
         @x = x
         @y = y
+        @direction = direction
       end
     end
   end

data/lib/road_to_rubykaigi/sprite/bonus.rb

@@ -98,6 +98,22 @@ module RoadToRubykaigi
         sake: "🍶",
         laptop: "💻",
       }
+      TYPE = {
+        ruby: :basic,
+        money: :basic,
+        coffee: :basic,
+        book: :basic,
+        sushi: :basic,
+        meat: :basic,
+        fish: :basic,
+        beer: :alcohol,
+        sake: :alcohol,
+        laptop: :laptop,
+      }
+
+      def type
+        TYPE[@character]
+      end
 
       def bounding_box
         { x: @x, y: @y, width: width, height: height }

data/lib/road_to_rubykaigi/sprite/deadline.rb

@@ -10,7 +10,7 @@ module RoadToRubykaigi
         yield self || nil
       end
 
-      def update
+      def simulate_physics
         return unless active?
         now = Time.now
         if (now - @last_update) > DEADLINE_SPEED
@@ -40,11 +40,11 @@ module RoadToRubykaigi
 
       private
 
-      def initialize(map_height)
+      def initialize
         @x = 2
         @y = 1
         @width = 1
-        @height = map_height
+        @height = Map::VIEWPORT_HEIGHT
         @last_update = Time.now
         @waiting = true
       end

data/lib/road_to_rubykaigi/sprite/enemy.rb

@@ -43,10 +43,14 @@ module RoadToRubykaigi
         buffer
       end
 
-      def update
+      def simulate_physics
         if activated?
-          @enemies.each(&:update)
-        else
+          @enemies.each(&:move)
+        end
+      end
+
+      def update
+        unless activated?
           @enemies.each(&:reset_last_update_time)
         end
       end
@@ -101,10 +105,10 @@ module RoadToRubykaigi
         super { [CHARACTER[@character]] }
       end
 
-      def update
+      def move
         elapsed_time = Time.now - @last_update_time
         @last_update_time = Time.now
-        @strategy.update(self, elapsed_time)
+        @strategy.move(self, elapsed_time)
       end
 
       def reset_last_update_time
@@ -153,7 +157,7 @@ module RoadToRubykaigi
         @speed = speed
       end
 
-      def update(enemy, elapsed_time)
+      def move(enemy, elapsed_time)
       end
     end
 
@@ -161,7 +165,7 @@ module RoadToRubykaigi
     end
 
     class HorizontalPatrolStrategy < PatrolStrategy
-      def update(enemy, elapsed_time)
+      def move(enemy, elapsed_time)
         enemy.x += @speed * elapsed_time * enemy.direction
         enemy.x = enemy.x.clamp(@left_bound, @right_bound)
         enemy.reverse_direction if enemy.x == @left_bound || enemy.x == @right_bound
@@ -169,7 +173,7 @@ module RoadToRubykaigi
     end
 
     class ScreenEntryPatrolStrategy < PatrolStrategy
-      def update(enemy, elapsed_time)
+      def move(enemy, elapsed_time)
         return unless enemy.active?
         enemy.x += @speed * elapsed_time * enemy.direction
       end