rich_engine 0.0.0

data/examples/timer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "rich_engine"
+
+class TimerExample < RichEngine::Game
+  def on_create
+    @timer = RichEngine::Timer.new
+    @canvas.bg = "·"
+  end
+
+  def on_update(elapsed_time, key)
+    quit! if key == :q
+
+    @timer.update(elapsed_time)
+    @canvas.clear
+    @canvas.write_string("Elapsed: #{@timer.get.round(1)}s", x: 1, y: 1)
+
+    quit! if @timer.get > 10
+  end
+end
+
+TimerExample.play

data/lib/rich_engine/canvas.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative "string_colors"
+
+module RichEngine
+  class Canvas
+    using StringColors
+
+    attr_reader :canvas, :bg
+
+    def initialize(width, height, bg: " ")
+      @width = width
+      @height = height
+      @bg = bg
+      clear
+    end
+
+    def dimensions
+      [@width, @height]
+    end
+
+    def each_coord(&block)
+      (0...@width).each do |x|
+        (0...@height).each do |y|
+          block.call(x, y)
+        end
+      end
+    end
+
+    def rows
+      @canvas.each_slice(@width)
+    end
+
+    def draw_sprite(sprite, x: 0, y: 0, fg: :white)
+      sprite.split("\n").each.with_index do |line, i|
+        line.each_char.with_index do |char, j|
+          next if char == " "
+
+          self[x + j, y + i] = char.fg(fg)
+        end
+      end
+    end
+
+    def write_string(str, x: 0, y: 0, fg: :white, bg: :transparent)
+      if x == :center
+        x = (@width - str.length) / 2
+      end
+
+      if y == :center
+        y = (@height - str.length) / 2
+      end
+
+      fg = Array(fg).cycle
+      bg = Array(bg).cycle
+
+      str.to_s.each_char.with_index do |char, i|
+        self[x + i, y] = char.fg(fg.next).bg(bg.next)
+      end
+    end
+
+    def draw_rect(x:, y:, width:, height:, char: "█", color: :white)
+      x = x.round
+      y = y.round
+      width = width.round
+      height = height.round
+
+      (x..(x + width - 1)).each do |x_pos|
+        (y..(y + height - 1)).each do |y_pos|
+          self[x_pos, y_pos] = char.fg(color)
+        end
+      end
+    end
+
+    def draw_circle(x:, y:, radius:, char: "█", color: :white)
+      x = x.round
+      y = y.round
+
+      (x - radius..x + radius).each do |x_pos|
+        (y - radius..y + radius).each do |y_pos|
+          next if (x_pos - x)**2 + (y_pos - y)**2 > radius**2
+
+          self[x_pos, y_pos] = char.fg(color)
+        end
+      end
+    end
+
+    def out_of_bounds?(x, y)
+      return true if x < 0
+      return true if x >= @width
+      return true if y < 0
+      return true if y >= @height
+
+      false
+    end
+
+    def [](x, y)
+      x = x.round
+      y = y.round
+
+      @canvas[at(x, y)]
+    end
+
+    def []=(x, y, value)
+      x = x.round
+      y = y.round
+      return if out_of_bounds?(x, y)
+
+      @canvas[at(x, y)] = value
+    end
+
+    def clear
+      @canvas = create_blank_canvas
+    end
+
+    def bg=(bg)
+      @bg = bg
+      clear
+    end
+
+    private
+
+    def at(x, y)
+      y * @width + x
+    end
+
+    def create_blank_canvas
+      (0...(@width * @height)).map { @bg }
+    end
+  end
+end

data/lib/rich_engine/chance.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RichEngine
+  module Chance
+    def self.of(value, rand_gen: method(:rand))
+      percent = if value > 1
+        value / 100.0
+      else
+        value
+      end
+
+      rand_gen.call < percent
+    end
+
+    def self.of_one_in(value, rand_gen: method(:rand))
+      of(1 / value.to_f, rand_gen: rand_gen)
+    end
+  end
+end

data/lib/rich_engine/cooldown.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RichEngine
+  class Cooldown
+    def initialize(target_time)
+      @timer = 0
+      @target_time = target_time
+    end
+
+    def update(dt)
+      @timer += dt
+    end
+
+    def get
+      @timer
+    end
+
+    def reset!
+      @timer = 0
+    end
+
+    def finished?
+      @timer >= @target_time
+    end
+    alias_method :ready?, :finished?
+  end
+end

data/lib/rich_engine/enum/mixin.rb

@@ -0,0 +1,21 @@
+module RichEngine
+  class Enum
+    module Mixin
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def enum(name, enum_options, enum_name: "#{name}s")
+          define_singleton_method(enum_name) do
+            Enum.new(name, enum_options)
+          end
+
+          define_method(name) do
+            self.class.public_send(enum_name).public_send(instance_variable_get("@#{name}"))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rich_engine/enum/value.rb

@@ -0,0 +1,49 @@
+module RichEngine
+  class Enum
+    class Value
+      include Comparable
+
+      attr_reader :enum, :selected
+
+      def initialize(enum:, selected:)
+        @enum = enum
+        @selected = selected
+
+        check_selected_is_a_valid_option
+        define_query_methods
+
+        freeze
+      end
+
+      def value
+        @enum[@selected]
+      end
+
+      def <=>(other)
+        raise ArgumentError, "Can't compare values from different enums" if enum != other.enum
+
+        value <=> other.value
+      end
+
+      def ==(other)
+        return @enum == other.enum && selected == other.selected if other.is_a? self.class
+
+        super
+      end
+
+      private
+
+      def check_selected_is_a_valid_option
+        msg = "Unknown enum value `#{@selected}`. Options are `#{@enum.options.keys}`"
+
+        raise(ArgumentError, msg) unless @enum.options.has_key? @selected
+      end
+
+      def define_query_methods
+        @enum.options.each do |enum_option, _value|
+          define_singleton_method("#{enum_option}?") { enum_option == @selected }
+        end
+      end
+    end
+  end
+end

data/lib/rich_engine/enum.rb

@@ -0,0 +1,29 @@
+require_relative "./enum/value"
+require_relative "./enum/mixin"
+
+module RichEngine
+  class Enum
+    attr_reader :name, :options
+
+    def initialize(name, options)
+      @name = name
+      @options = if options.respond_to? :each_pair
+        options
+      else
+        options.map.with_index.to_h
+      end
+
+      @options.each_pair do |option, _value|
+        define_singleton_method(option) do
+          Enum::Value.new(enum: self, selected: option)
+        end
+      end
+
+      freeze
+    end
+
+    def [](option)
+      @options.fetch(option)
+    end
+  end
+end

data/lib/rich_engine/game.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "canvas"
+require_relative "io"
+
+module RichEngine
+  # Example:
+  #
+  #   class MyGame < RichEngine::Game
+  #     def on_create
+  #       @title = "My Awesome Game"
+  #     end
+  #
+  #     def on_update(elapsed_time, key)
+  #       quit! if key == :q
+  #
+  #       @canvas.write_string(@title, x: 1, y: 1)
+  #     end
+  #   end
+  #
+  #   MyGame.play
+  #
+  class Game
+    class Exit < StandardError; end
+
+    def initialize(width, height)
+      @width = width
+      @height = height
+      @config = {screen_width: @width, screen_height: @height}
+      @io = RichEngine::IO.new(width, height)
+      @canvas = RichEngine::Canvas.new(width, height)
+    end
+
+    def self.play(width: 50, height: 10)
+      new(width, height).play
+    end
+
+    def play
+      prepare_screen
+      on_create
+
+      previous_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      loop do
+        current_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        elapsed_time = current_time - previous_time
+        previous_time = current_time
+
+        check_game_exit do
+          game_loop(elapsed_time)
+        end
+      end
+
+      on_destroy
+    ensure
+      restore_screen
+    end
+
+    def on_create
+    end
+
+    def on_update(_elapsed_time, _key)
+    end
+
+    def on_destroy
+    end
+
+    def quit!
+      raise Exit
+    end
+
+    def game_loop(elapsed_time)
+      key = read_input
+      on_update(elapsed_time, key)
+      render
+    end
+
+    private
+
+    def prepare_screen
+      Terminal.clear
+      Terminal.hide_cursor
+      Terminal.disable_echo
+    end
+
+    def restore_screen
+      Terminal.display_cursor
+      Terminal.enable_echo
+    end
+
+    def read_input
+      @io.read_async
+    end
+
+    def render(use_caching: true)
+      @io.write(@canvas.canvas, use_caching: use_caching)
+    end
+
+    def check_game_exit
+      yield
+    rescue Exit
+      raise StopIteration
+    end
+  end
+end

data/lib/rich_engine/io.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "timeout"
+require "io/console"
+
+module RichEngine
+  class IO
+    Signal.trap("INT") { raise Game::Exit }
+
+    def initialize(width, height)
+      @screen_width = width
+      @screen_height = height
+      delete_cache
+    end
+
+    def write(canvas, use_caching:)
+      delete_cache unless use_caching
+
+      with_caching(canvas) do
+        Terminal::Cursor.goto(0, 0)
+        output = build_output(canvas)
+        $stdout.write output
+      end
+    end
+
+    def read_async
+      key = $stdin.read_nonblock(2)
+      _c1, c2 = key.chars
+
+      if c2 && csi?(key)
+        c3, c4 = $stdin.read_nonblock(2).chars
+
+        if digit?(c3)
+          symbolize_key("#{key}#{c3}#{c4}")
+        else
+          symbolize_key("#{key}#{c3}")
+        end
+      else
+        symbolize_key(key)
+      end
+    rescue ::IO::WaitReadable
+      nil
+    end
+
+    private
+
+    def delete_cache
+      @canvas_cache = nil
+    end
+
+    def with_caching(canvas)
+      return :cache_hit if canvas == @canvas_cache
+
+      yield
+      @canvas_cache = canvas
+
+      :cache_miss
+    end
+
+    def build_output(canvas)
+      output = +""
+
+      i = 0
+      while i < canvas_size
+        output << "#{canvas[i...(i + @screen_width)].join}\n"
+
+        i += @screen_width
+      end
+
+      output
+    end
+
+    def canvas_size
+      @canvas_size ||= @screen_height * @screen_width
+    end
+
+    def symbolize_key(key)
+      return key.downcase.to_sym unless key.start_with?("\e", " ", "\n")
+
+      case key
+      when "\e[A" then :up
+      when "\e[B" then :down
+      when "\e[C" then :right
+      when "\e[D" then :left
+      when "\e" then :esc
+      when " " then :space
+      when "\n" then :enter
+      when "\e[2~" then :insert
+      when "\e[3~" then :delete
+      when "\e[5~" then :pg_up
+      when "\e[6~" then :pg_down
+      when "\e[H" then :home
+      when "\e[F" then :end
+      else raise "Unknown key #{key.inspect}" if ENV["DEBUG"] == "all"
+      end
+    end
+
+    def escape?(char)
+      char == "\e"
+    end
+
+    def csi?(str)
+      str == "\e["
+    end
+
+    def digit?(char)
+      char.between?("0", "9")
+    end
+  end
+end

data/lib/rich_engine/matrix.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RichEngine
+  class Matrix
+    # TODO: implement Enumerable
+
+    attr_accessor :vec
+
+    def initialize(width: 1, height: 1, fill_with: nil)
+      @vec = Array.new(width) { Array.new(height) { fill_with } }
+    end
+
+    def [](x, y)
+      @vec[x][y]
+    end
+
+    def []=(x, y, value)
+      @vec[x][y] = value
+    end
+
+    def any?(&block)
+      @vec.any? { |row| row.any?(&block) }
+    end
+
+    def each
+      @vec.each do |row|
+        row.each do |tile|
+          yield(tile)
+        end
+      end
+    end
+
+    def map(&block)
+      @vec.map do |row|
+        row.map { |value| block.call(value) }
+      end
+    end
+
+    def zip(other)
+      new_matrix = Matrix.new
+      new_matrix.vec = @vec.map.with_index do |row, i|
+        row.map.with_index { |value, j| [value, other[i, j]] }
+      end
+
+      new_matrix
+    end
+
+    def each_with_indexes
+      @vec.each_with_index do |row, i|
+        row.each_with_index do |tile, j|
+          yield(tile, i, j)
+        end
+      end
+    end
+
+    def fill(x:, y:, with:)
+      xs = Iterable(x)
+      ys = Iterable(y)
+
+      xs.each do |x|
+        ys.each do |y|
+          @vec[x][y] = with
+        end
+      end
+    end
+
+    private
+
+    def Iterable(value)
+      value.respond_to?(:each) ? value : [value]
+    end
+  end
+end