road_to_rubykaigi 0.1.0

data/lib/road_to_rubykaigi/manager/collision_manager.rb

@@ -0,0 +1,133 @@
+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)
+          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
+
+      # @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
+      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
+          end
+        end
+      end
+
+      def find_collision_item(entity, others)
+        others.find do |other|
+          collided?(entity.bounding_box, other.bounding_box)
+        end
+      end
+
+      def collided?(box1, box2)
+        !(
+          box1[:x] + box1[:width] <= box2[:x] ||
+          box1[:x] >= box2[:x] + box2[:width] ||
+          box1[:y] + box1[:height] <= box2[:y] ||
+          box1[:y] >= box2[:y] + box2[:height]
+        )
+      end
+    end
+  end
+end

data/lib/road_to_rubykaigi/manager/drawing_manager.rb

@@ -0,0 +1,48 @@
+module RoadToRubykaigi
+  module Manager
+    class DrawingManager
+      MAP_X_START = 1
+      MAP_Y_START = 2
+
+      def draw(offset_x:)
+        buffer = Array.new(@viewport_height) { Array.new(@viewport_width) { "" } }
+        @layers.each do |layer|
+          merge_buffer(buffer, layer, offset_x: offset_x)
+        end
+
+        ANSI.home
+        ANSI.background_color
+        ANSI.default_text_color
+        print @score_board.render
+        @viewport_height.times do |row|
+          @viewport_width.times do |col|
+            unless buffer[row][col] == @preview_buffer[row][col]
+              print "\e[#{row+MAP_Y_START};#{col+MAP_X_START}H" + ANSI::BACKGROUND_COLOR + ANSI::DEFAULT_TEXT_COLOR + buffer[row][col]
+            end
+          end
+        end
+        @preview_buffer = buffer.map(&:dup)
+      end
+
+      private
+
+      def initialize(score_board, background, foreground, fireworks)
+        @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]
+      end
+
+      def merge_buffer(buffer, layer, offset_x:)
+        layer.build_buffer(offset_x: offset_x).each_with_index do |row, i|
+          row.each_with_index do |tile, j|
+            buffer[i][j] = tile unless tile == ""
+          end
+        end
+      end
+    end
+  end
+end

data/lib/road_to_rubykaigi/manager/game_manager.rb

@@ -0,0 +1,55 @@
+module RoadToRubykaigi
+  module Manager
+    class GameManager
+      GOAL_X = 650
+      STATE = {
+        playing: 0,
+        pause: 1,
+        game_over: 2,
+        ending: 3,
+        finished: 4,
+      }
+      attr_reader :fireworks
+
+      def update
+        @deadline.activate(player_x: @player.x)
+        @enemies.activate if player_moved?
+        if @player.x >= GOAL_X && playing?
+          game_clear
+        end
+      end
+
+      def finish
+        @state = STATE[:finished]
+      end
+
+      def finished?
+        @state == STATE[:finished]
+      end
+
+      private
+
+      def initialize(player, deadline, enemies)
+        @player = player
+        @deadline = deadline
+        @enemies = enemies
+        @fireworks = RoadToRubykaigi::Fireworks.new(self)
+        @state = STATE[:playing]
+      end
+
+      def player_moved?
+        @player_initial_x ||= @player.x
+        @player_initial_x != @player.x
+      end
+
+      def playing?
+        @state == STATE[:playing]
+      end
+
+      def game_clear
+        @state = STATE[:ending]
+        @fireworks.shoot
+      end
+    end
+  end
+end

data/lib/road_to_rubykaigi/manager/update_manager.rb

@@ -0,0 +1,27 @@
+module RoadToRubykaigi
+  module Manager
+    class UpdateManager
+      def update(offset_x:)
+        enemies = @entities[3]
+        enemies.each do |enemy|
+          enemy.activate_with_offset(offset_x)
+        end
+        @entities.each(&:update)
+        enforce_boundary(offset_x: offset_x)
+      end
+
+      private
+
+      def initialize(map, foreground, 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
+      end
+    end
+  end
+end

data/lib/road_to_rubykaigi/map.rb

@@ -0,0 +1,120 @@
+module RoadToRubykaigi
+  class Map
+    VIEWPORT_WIDTH = 100
+    VIEWPORT_HEIGHT = 30
+    attr_reader :width, :height
+
+    def build_buffer(offset_x:)
+      (0...VIEWPORT_HEIGHT).map do |row|
+        @tiles[row][offset_x, VIEWPORT_WIDTH].map(&:character)
+      end
+    end
+
+    def clamp_position(x:, y:, width:, height:, dx:, dy:)
+      clamped_x = x.clamp(2, @width - width)
+      clamped_y = y.clamp(2, @height - height)
+      return [clamped_x, clamped_y] if box_passable?(clamped_x, clamped_y, width, height)
+
+      attempt_count = 10
+      delta_x = nil
+      delta_y = nil
+      unless dx == 0
+        (1..attempt_count).each do |i|
+          attempt_x = clamped_x + i * dx
+          if box_passable?(attempt_x, clamped_y, width, height)
+            break delta_x = attempt_x - clamped_x
+          end
+        end
+      end
+      unless dy == 0
+        (1..attempt_count).each do |i|
+          attempt_y = [clamped_y + i * dy, RoadToRubykaigi::Sprite::Player::BASE_Y].min
+          if box_passable?(clamped_x, attempt_y, width, height)
+            break delta_y = attempt_y - clamped_y
+          end
+        end
+      end
+
+      case
+      when delta_x && delta_y
+        if delta_x.abs <= delta_y.abs
+          [clamped_x + delta_x, clamped_y]
+        else
+          [clamped_x, clamped_y + delta_y]
+        end
+      when delta_x && !delta_y
+        [clamped_x + delta_x, clamped_y]
+      when !delta_x && delta_y
+        [clamped_x, clamped_y + delta_y]
+      else
+        coordinates = (1..attempt_count).select do |i|
+          attempt_x = clamped_x + i * dx
+          attempt_y = [clamped_y + i * dy, RoadToRubykaigi::Sprite::Player::BASE_Y].min
+          if box_passable?(attempt_x, attempt_y, width, height)
+            break [attempt_x, attempt_y]
+          end
+        end
+        coordinates.empty? ? [clamped_x + dx, clamped_y + dy] : coordinates
+      end
+    end
+
+    def passable_at?(col, row)
+      @tiles[row-1][col-1].passable?
+    end
+
+    private
+
+    def initialize
+      map_data = RoadToRubykaigi::Graphics::Map.data
+      mask_data = RoadToRubykaigi::Graphics::Mask.data
+      @tiles = map_data.each_with_index.map do |line, row|
+        line.chars.each_with_index.map do |ch, col|
+          Tile.new(ch, mask: mask_data[row][col])
+        end
+      end
+      @height = @tiles.size
+      @width = @tiles.first.size
+    end
+
+    def box_passable?(x, y, width, height)
+      (y...(y + height)).all? do |row|
+        (x...(x + width)).all? do |col|
+          passable_at?(col, row)
+        end
+      end
+    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 = "#"
+
+    def character
+      @symbol
+    end
+
+    def passable?
+      @mask != MASK_CHAR
+    end
+
+    private
+
+    def initialize(symbol, mask:)
+      @symbol = symbol
+      @mask = mask
+    end
+  end
+end

data/lib/road_to_rubykaigi/opening_screen.rb

@@ -0,0 +1,56 @@
+module RoadToRubykaigi
+  class OpeningScreen
+    WIDTH = 10
+    OFFSET = 30
+    DELAY = 0.75
+    LOGO =<<~LOGO
+      ╔═══════╗
+      ║       ║
+      ║       ║                                ║
+      ║       ║                                ║
+      ╠═════╦═╝  ╔═══════╗  ╔═══════║   ╔══════╣
+      ║     ╚═╗  ║       ║  ║       ║  ╔╝      ║    ══╬══  ╔═══╗
+      ║       ║  ║       ║  ║       ║  ║       ║      ║    ║   ║
+      ║       ║  ╚═══════╝  ╚═══════║  ╚═══════╝      ║    ╚═══╝
+
+      ╔═══════╗                                   ║       ║
+      ║       ║                                   ║       ║
+      ║       ║             ║          ║       ║  ║       ║                ╔═══════║
+      ║       ║             ║          ║       ║  ║       ║             ║  ║       ║  ║
+      ╠═════╦═╝  ║       ║  ╠══════╗   ║       ║  ╠═════╦═╝  ╔═══════║     ║       ║
+      ║     ╚═╗  ║       ║  ║      ╚╗  ╚═══════╣  ║     ╚═╗  ║       ║  ║  ╚═══════╣  ║
+      ║       ║  ║       ║  ║       ║          ║  ║       ║  ║       ║  ║          ║  ║
+      ║       ║  ╚═══════║  ╚═══════╝  ════════╝  ║       ║  ╚═══════║  ║  ════════╝  ║
+    LOGO
+    PLAYER =<<~PLAYER
+      ╭──────╮
+      │｡・◡・│_◢◤
+      ╰ᜊ───ᜊ─╯
+    PLAYER
+
+    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
+        end
+
+        x += direction
+        if x >= WIDTH || x <= 0
+          direction = -direction
+        end
+        sleep DELAY
+      end
+    end
+  end
+end

data/lib/road_to_rubykaigi/score_board.rb

@@ -0,0 +1,17 @@
+module RoadToRubykaigi
+  class ScoreBoard
+    def increment
+      @score += 1
+    end
+
+    def render
+      "Score: #{@score}".ljust(10).rjust(Map::VIEWPORT_WIDTH)
+    end
+
+    private
+
+    def initialize
+      @score = 0
+    end
+  end
+end

data/lib/road_to_rubykaigi/sprite/attack.rb

@@ -0,0 +1,72 @@
+require "forwardable"
+
+module RoadToRubykaigi
+  module Sprite
+    class Attacks
+      extend Forwardable
+      def_delegators :@attacks, :each, :delete, :select
+
+      def add(x, y)
+        @attacks << Attack.new(x, y)
+      end
+
+      def update
+        @attacks.each(&:move)
+      end
+
+      def enforce_boundary(map, offset_x:)
+        @attacks.reject! do |attack|
+          attack.reach_border?(map, offset_x: offset_x)
+        end
+      end
+
+      def build_buffer(offset_x:)
+        buffer = Array.new(Map::VIEWPORT_HEIGHT) { Array.new(Map::VIEWPORT_WIDTH) { "" } }
+        @attacks.each do |attack|
+          bounding_box = attack.bounding_box
+          relative_x = bounding_box[:x] - offset_x - 1
+          relative_y = bounding_box[:y] - 1
+          next if relative_x < 1
+          attack.characters.each_with_index do |chara, j|
+            buffer[relative_y][relative_x+j] = chara
+          end
+        end
+        buffer
+      end
+
+      private
+
+      def initialize
+        @attacks = []
+      end
+    end
+
+    class Attack < Sprite
+      SYMBOL = ".˖"
+
+      def move
+        @x += 1
+      end
+
+      def characters
+        super { SYMBOL.chars }
+      end
+
+      def reach_border?(map, offset_x:)
+        (@x - offset_x + SYMBOL.size - 1) > Map::VIEWPORT_WIDTH ||
+          (@x + SYMBOL.size) > map.width
+      end
+
+      def bounding_box
+        { x: @x, y: @y, width: SYMBOL.size, height: 1 }
+      end
+
+      private
+
+      def initialize(x, y)
+        @x = x
+        @y = y
+      end
+    end
+  end
+end

data/lib/road_to_rubykaigi/sprite/bonus.rb

@@ -0,0 +1,127 @@
+require "forwardable"
+
+module RoadToRubykaigi
+  module Sprite
+    class Bonuses
+      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 },
+        ]
+      }
+
+      def build_buffer(offset_x:)
+        buffer = Array.new(Map::VIEWPORT_HEIGHT) { Array.new(Map::VIEWPORT_WIDTH) { "" } }
+        @bonuses.each do |bonus|
+          bounding_box = bonus.bounding_box
+          relative_x = bounding_box[:x] - offset_x - 1
+          relative_y = bounding_box[:y] - 1
+          next if relative_x < 1
+          bonus.characters.each_with_index do |character, j|
+            next if relative_x + j >= Map::VIEWPORT_WIDTH - 1
+            buffer[relative_y][relative_x+j] = character
+          end
+        end
+        buffer
+      end
+
+      def update
+      end
+
+      private
+
+      def initialize
+        @bonuses = BONUSES_DATA.map do |key, bonuses|
+          bonuses.map do |bonus|
+            Bonus.new(
+              bonus[:x],
+              bonus[:y],
+              bonus[:character],
+            )
+          end
+        end.flatten
+      end
+    end
+
+    class Bonus < Sprite
+      CHARACTER = {
+        ruby: "💎",
+        money: "💰",
+        coffee: "☕️",
+        book: "📚",
+        sushi: "🍣",
+        meat: "🍖",
+        fish: "🐟",
+        beer: "🍺",
+        sake: "🍶",
+        laptop: "💻",
+      }
+
+      def bounding_box
+        { x: @x, y: @y, width: width, height: height }
+      end
+
+      def characters
+        super { [CHARACTER[@character]] }
+      end
+
+      def width
+        2
+      end
+
+      def height
+        1
+      end
+
+      private
+
+      def initialize(x, y, character)
+        @x = x
+        @y = y
+        @character = character
+      end
+    end
+  end
+end