road_to_rubykaigi 0.1.0

data/lib/road_to_rubykaigi/sprite/deadline.rb

@@ -0,0 +1,57 @@
+module RoadToRubykaigi
+  module Sprite
+    class Deadline < Sprite
+      DEADLINE_SPEED = 0.3
+      DEADLINE_START_X = 18
+
+      attr_reader :x, :y, :width, :height
+
+      def find
+        yield self || nil
+      end
+
+      def update
+        return unless active?
+        now = Time.now
+        if (now - @last_update) > DEADLINE_SPEED
+          @x += 1
+          @last_update = now
+        end
+      end
+
+      def build_buffer(offset_x:)
+        buffer = Array.new(Map::VIEWPORT_HEIGHT) { Array.new(Map::VIEWPORT_WIDTH) { "" } }
+        relative_x = @x - offset_x - 1
+        relative_y = @y - 1
+        @height.times do |i|
+          next if relative_x < 1
+          buffer[relative_y+i][relative_x] = ANSI::RED + "#" + ANSI::DEFAULT_TEXT_COLOR
+        end
+        buffer
+      end
+
+      def bounding_box
+        { x: @x, y: @y, width: @width, height: @height }
+      end
+
+      def activate(player_x:)
+        @waiting = false if player_x > DEADLINE_START_X
+      end
+
+      private
+
+      def initialize(map_height)
+        @x = 2
+        @y = 1
+        @width = 1
+        @height = map_height
+        @last_update = Time.now
+        @waiting = true
+      end
+
+      def active?
+        !@waiting
+      end
+    end
+  end
+end

data/lib/road_to_rubykaigi/sprite/effect.rb

@@ -0,0 +1,88 @@
+module RoadToRubykaigi
+  module Sprite
+    class Effects
+      def update
+        @effects.reject!(&:expired?)
+      end
+
+      def heart(x, y)
+        @effects << HeartEffect.new(x, y)
+      end
+
+      def note(x, y)
+        @effects << NoteEffect.new(x, y)
+      end
+
+      def lightning(x, y)
+        @effects << LightningEffect.new(x, y)
+      end
+
+      def build_buffer(offset_x:)
+        buffer = Array.new(Map::VIEWPORT_HEIGHT) { Array.new(Map::VIEWPORT_WIDTH) { "" } }
+        @effects.each do |effect|
+          bounding_box = effect.bounding_box
+          relative_x = bounding_box[:x] - offset_x - 1
+          relative_y = bounding_box[:y] - 1
+          next if relative_x < 1
+          buffer[relative_y][relative_x] = effect.character
+        end
+        buffer
+      end
+
+      def to_a
+        @effects.to_a
+      end
+
+      private
+
+      def initialize
+        @effects = []
+      end
+    end
+
+    class Effect < Sprite
+      def update
+        elapsed = Time.now - @start_time
+        @y = (@y - elapsed).to_i
+      end
+
+      def character
+        self.class::SYMBOL
+      end
+
+      def expired?
+        (Time.now - @start_time) >= self.class::DURATION
+      end
+
+      def bounding_box
+        { x: @x, y: @y, width: 1, height: 1 }
+      end
+
+      private
+
+      def initialize(x, y)
+        @x = x
+        @y = y
+        @start_time = Time.now
+      end
+    end
+
+    class HeartEffect < Effect
+      DURATION = 1.0
+      SYMBOL = ANSI::RED + "♥" + ANSI::DEFAULT_TEXT_COLOR
+    end
+
+    class NoteEffect < Effect
+      DURATION = 1.0
+      SYMBOL = ANSI::BLUE + "♪" + ANSI::DEFAULT_TEXT_COLOR
+    end
+
+    class LightningEffect < Effect
+      DURATION = 0.3
+      SYMBOL = ANSI::YELLOW + "⚡︎" + ANSI::DEFAULT_TEXT_COLOR
+
+      def update
+      end
+    end
+  end
+end

data/lib/road_to_rubykaigi/sprite/enemy.rb

@@ -0,0 +1,178 @@
+require "forwardable"
+
+module RoadToRubykaigi
+  module Sprite
+    class Enemies
+      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 },
+        ],
+      }
+
+      def build_buffer(offset_x:)
+        buffer = Array.new(Map::VIEWPORT_HEIGHT) { Array.new(Map::VIEWPORT_WIDTH) { "" } }
+        @enemies.each do |enemy|
+          bounding_box = enemy.bounding_box
+          relative_x = bounding_box[:x] - offset_x - 1
+          relative_y = bounding_box[:y] - 1
+          next if relative_x < 1
+          enemy.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
+        if activated?
+          @enemies.each(&:update)
+        else
+          @enemies.each(&:reset_last_update_time)
+        end
+      end
+
+      def activate
+        @waiting = false
+      end
+
+      private
+
+      def initialize
+        @enemies = ENEMIES_DATA.map do |key, enemies|
+          strategy = RoadToRubykaigi::Sprite.const_get("#{key}Strategy")
+          enemies.map do |enemy|
+            Enemy.new(
+              enemy[:x],
+              enemy[:y],
+              enemy[:character],
+              strategy.new(
+                left_bound: enemy[:left_bound],
+                right_bound: enemy[:right_bound],
+                speed: enemy[:speed],
+              ),
+            )
+          end
+        end.flatten
+        @waiting = true
+      end
+
+      def activated?
+        !@waiting
+      end
+    end
+
+    class Enemy < Sprite
+      CHARACTER = {
+        bee: "🐝",
+        bug: "🐛",
+        ladybug: "🐞",
+        spider: "🕷️",
+      }
+      RIGHT = 1
+      LEFT = -1
+      attr_accessor :x
+      attr_reader :y, :direction
+
+      def bounding_box
+        { x: @x, y: @y, width: width, height: height }
+      end
+
+      def characters
+        super { [CHARACTER[@character]] }
+      end
+
+      def update
+        elapsed_time = Time.now - @last_update_time
+        @last_update_time = Time.now
+        @strategy.update(self, elapsed_time)
+      end
+
+      def reset_last_update_time
+        @last_update_time = Time.now
+      end
+
+      def width
+        2
+      end
+
+      def height
+        1
+      end
+
+      def reverse_direction
+        @direction *= -1
+      end
+
+      def activate_with_offset(offset_x)
+        if !@active && @x <= (offset_x + Map::VIEWPORT_WIDTH)
+          @active = true
+        end
+      end
+
+      def active?
+        @active
+      end
+
+      private
+
+      def initialize(x, y, character, strategy)
+        @x = x
+        @y = y
+        @character = character
+        @direction = LEFT
+        @strategy = strategy
+        @active = !strategy.is_a?(ScreenEntryPatrolStrategy)
+        @last_update_time = Time.now
+      end
+    end
+
+    class PatrolStrategy
+      def initialize(left_bound:, right_bound:, speed:)
+        @left_bound = left_bound
+        @right_bound = right_bound
+        @speed = speed
+      end
+
+      def update(enemy, elapsed_time)
+      end
+    end
+
+    class FixedPatrolStrategy < PatrolStrategy
+    end
+
+    class HorizontalPatrolStrategy < PatrolStrategy
+      def update(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
+      end
+    end
+
+    class ScreenEntryPatrolStrategy < PatrolStrategy
+      def update(enemy, elapsed_time)
+        return unless enemy.active?
+        enemy.x += @speed * elapsed_time * enemy.direction
+      end
+    end
+  end
+end

data/lib/road_to_rubykaigi/sprite/player.rb

@@ -0,0 +1,178 @@
+module RoadToRubykaigi
+  module Sprite
+    class Player
+      attr_reader :x, :y
+      attr_accessor :vy
+
+      WALK_ACCEL = 15.0
+      WALK_MAX_SPEED = 20.0
+      WALK_FRICTION = 1.0
+
+      BASE_Y = 26
+      JUMP_INITIAL_VELOCITY = -40.0
+      JUMP_GRAVITY = 80.0
+
+      KEY_INPUT_THRESHOLD = 0.5
+      ANIMETION_FRAME_SECOND = 0.5
+      STUN_SECOND = 2.0
+
+      RIGHT = 1
+      LEFT = -1
+
+      def right
+        move(RIGHT)
+      end
+
+      def left
+        move(LEFT)
+      end
+
+      def jump
+        unless jumping?
+          @jumping = true
+          @vy = JUMP_INITIAL_VELOCITY
+        end
+      end
+
+      def land(land_y)
+        @y = land_y - height
+        @vy = 0
+        @jumping = false
+        # Not change stompable since stompable will not change from true
+      end
+
+      def fall
+        unless @jumping
+          @jumping = true
+          @vy = 0
+          @stompable = true
+        end
+      end
+
+      def stun
+        @stunned_until = Time.now + STUN_SECOND
+      end
+
+      def stunned?
+        Time.now < @stunned_until
+      end
+
+      def stompable?
+        @stompable
+      end
+
+      def update
+        return @coordinate_updated_time = Time.now if stunned?
+
+        now = Time.now
+        if (now - @animetion_updated_time) >= ANIMETION_FRAME_SECOND
+          @walking_frame = (@walking_frame + 1) % current_character.size
+          @animetion_updated_time = now
+        end
+
+        elapsed_time = now - @coordinate_updated_time
+        @coordinate_updated_time = now
+        if jumping?
+          @vy += JUMP_GRAVITY * elapsed_time
+          @y += @vy * elapsed_time
+          @stompable = @vy.positive?
+          if @y >= BASE_Y
+            @y = BASE_Y
+            @vy = 0
+            @jumping = false
+          end
+        else
+          @stompable = false
+          if current_direction == RIGHT
+            @vx -= friction * elapsed_time
+            @vx = [@vx, 0].max # vx must be positive
+          else
+            @vx += friction * elapsed_time
+            @vx = [@vx, 0].min # vx must be negative
+          end
+        end
+        @x += @vx * elapsed_time
+
+        @x = @x.round.to_i
+        @y = @y.round.to_i
+      end
+
+      def build_buffer(offset_x:)
+        buffer = Array.new(Map::VIEWPORT_HEIGHT) { Array.new(Map::VIEWPORT_WIDTH) { "" } }
+        relative_x = @x - offset_x - 1
+        relative_y = @y - 1
+        current_character[@walking_frame].each_with_index do |row, i|
+          row.each_with_index do |character, j|
+            buffer[relative_y+i][relative_x+j] = character
+          end
+        end
+        buffer
+      end
+
+      def enforce_boundary(map, offset_x:)
+        @x, @y = map.clamp_position(
+          dx: @vx.round.clamp(-1, 1) * -1,
+          dy: @vy.round.clamp(-1, 1) * -1,
+          **bounding_box
+        )
+      end
+
+      def bounding_box
+        { x: @x, y: @y, width: width, height: height }
+      end
+
+      def width
+        @width ||= current_character.first.map(&:size).max
+      end
+
+      def height
+        @height ||= current_character.first.size
+      end
+
+      private
+
+      def initialize(x = 10, y = BASE_Y)
+        @x = x
+        @y = y
+        @vx = 0.0
+        @vy = 0.0
+        @walking_frame = 0
+        @coordinate_updated_time = Time.now
+        @animetion_updated_time = Time.now
+        @key_input_time = Time.now
+        @jumping = false
+        @stompable = false
+        @stunned_until = Time.now
+      end
+
+      def move(dx)
+        unless current_direction == dx
+          @vx = 0
+        end
+        @vx += WALK_ACCEL * dx
+        @vx = @vx.clamp(-WALK_MAX_SPEED, WALK_MAX_SPEED)
+      end
+
+      def current_character
+        status = stunned? ? :stunned : :normal
+        Graphics::Player.character(status, current_direction)
+      end
+
+      def jumping?
+        @jumping
+      end
+
+      def friction
+        if (Time.now - @key_input_time) >= KEY_INPUT_THRESHOLD
+          WALK_MAX_SPEED
+        else
+          WALK_FRICTION
+        end
+      end
+
+      def current_direction
+        (@vx >= 0) ? RIGHT : LEFT
+      end
+    end
+  end
+end

data/lib/road_to_rubykaigi/sprite/sprite.rb

@@ -0,0 +1,22 @@
+module RoadToRubykaigi
+  module Sprite
+    class Sprite
+      def characters
+        yield.map do |character|
+          fullwidth?(character) ? [character, ANSI::NULL] : character
+        end.flatten
+      end
+
+      private
+
+      def fullwidth?(character)
+        code = character.ord
+        (0x1F300..0x1F5FF).cover?(code) ||
+          (0x1F600..0x1F64F).cover?(code) ||
+          (0x1F680..0x1F6FF).cover?(code) ||
+          (0x1F700..0x1F77F).cover?(code) ||
+          code == 0x2615
+      end
+    end
+  end
+end

data/lib/road_to_rubykaigi/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RoadToRubykaigi
+  VERSION = "0.1.0"
+end

data/lib/road_to_rubykaigi.rb

@@ -0,0 +1,46 @@
+require_relative "road_to_rubykaigi/version"
+require_relative "road_to_rubykaigi/ansi"
+require_relative "road_to_rubykaigi/fireworks"
+require_relative "road_to_rubykaigi/game"
+require_relative "road_to_rubykaigi/map"
+require_relative "road_to_rubykaigi/opening_screen"
+require_relative "road_to_rubykaigi/score_board"
+require_relative "road_to_rubykaigi/manager/collision_manager"
+require_relative "road_to_rubykaigi/manager/drawing_manager"
+require_relative "road_to_rubykaigi/manager/game_manager"
+require_relative "road_to_rubykaigi/manager/update_manager"
+require_relative "road_to_rubykaigi/sprite/sprite"
+require_relative "road_to_rubykaigi/sprite/attack"
+require_relative "road_to_rubykaigi/sprite/bonus"
+require_relative "road_to_rubykaigi/sprite/deadline"
+require_relative "road_to_rubykaigi/sprite/effect"
+require_relative "road_to_rubykaigi/sprite/enemy"
+require_relative "road_to_rubykaigi/sprite/player"
+require_relative "road_to_rubykaigi/graphics/fireworks"
+require_relative "road_to_rubykaigi/graphics/mask"
+require_relative "road_to_rubykaigi/graphics/map"
+require_relative "road_to_rubykaigi/graphics/player"
+require "io/console"
+
+module RoadToRubykaigi
+  class Error < StandardError; end
+  END_POSITION = Map.new.height + 2
+
+  def self.start
+    ANSI.cursor_off
+    at_exit do
+      print "\e[#{END_POSITION};1H"
+      ANSI.cursor_on
+    end
+
+    OpeningScreen.new.display && Game.new.run
+  end
+
+  def self.debug
+    @debug ||= []
+  end
+
+  def self.debug_add(string)
+    @debug << "\e[#{END_POSITION+@debug.size};1H" + string
+  end
+end

data/sig/road_to_rubykaigi.rbs

@@ -0,0 +1,4 @@
+module RoadToRubykaigi
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: road_to_rubykaigi
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- makicamel
+bindir: bin
+cert_chain: []
+date: 2025-02-27 00:00:00.000000000 Z
+dependencies: []
+description: Road to RubyKaigi is a Ruby gem that delivers a nostalgic, text-based
+  action game experience. Dodge obstacles, overcome bugs, and beat the deadline to
+  reach RubyKaigi. All in your terminal.
+email:
+- unright@gmail.com
+executables:
+- road_to_rubykaigi
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".standard.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/road_to_rubykaigi
+- lib/road_to_rubykaigi.rb
+- lib/road_to_rubykaigi/ansi.rb
+- lib/road_to_rubykaigi/fireworks.rb
+- lib/road_to_rubykaigi/game.rb
+- lib/road_to_rubykaigi/graphics/fireworks.rb
+- lib/road_to_rubykaigi/graphics/fireworks.txt
+- lib/road_to_rubykaigi/graphics/map.rb
+- lib/road_to_rubykaigi/graphics/map.txt
+- lib/road_to_rubykaigi/graphics/mask.rb
+- lib/road_to_rubykaigi/graphics/mask.txt
+- lib/road_to_rubykaigi/graphics/player.rb
+- lib/road_to_rubykaigi/manager/collision_manager.rb
+- lib/road_to_rubykaigi/manager/drawing_manager.rb
+- lib/road_to_rubykaigi/manager/game_manager.rb
+- lib/road_to_rubykaigi/manager/update_manager.rb
+- lib/road_to_rubykaigi/map.rb
+- lib/road_to_rubykaigi/opening_screen.rb
+- lib/road_to_rubykaigi/score_board.rb
+- lib/road_to_rubykaigi/sprite/attack.rb
+- lib/road_to_rubykaigi/sprite/bonus.rb
+- lib/road_to_rubykaigi/sprite/deadline.rb
+- lib/road_to_rubykaigi/sprite/effect.rb
+- lib/road_to_rubykaigi/sprite/enemy.rb
+- lib/road_to_rubykaigi/sprite/player.rb
+- lib/road_to_rubykaigi/sprite/sprite.rb
+- lib/road_to_rubykaigi/version.rb
+- sig/road_to_rubykaigi.rbs
+homepage: https://github.com/makicamel/road_to_rubykaigi
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/makicamel/road_to_rubykaigi
+  source_code_uri: https://github.com/makicamel/road_to_rubykaigi
+  changelog_uri: https://github.com/makicamel/road_to_rubykaigi/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: A retro ASCII action game where Rubyist overcomes a looming deadline and
+  bugs on your way to RubyKaigi
+test_files: []