phosphor 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21f8fe8fed4153375b120bb9f15fde3ea1501d225274731dc4f73fefedaa922d
-  data.tar.gz: b63eb1a1bfa080004ef0cd5c1ffd2feb85f5b04633243c6cd786a135fca355c1
+  metadata.gz: 7f86fb424ff88c87d5579e97dbe670fdd81baaa6a6143e125b6d042ce251775d
+  data.tar.gz: 4066a49f238b8ad0f96f4e482dabac21c9a99265063bee7944218bdb3ebdee40
 SHA512:
-  metadata.gz: d5d0a29df062d80ec4918b9670bdd1db524d6fb330d98d9cc273173b7e283e4a3ce4c7b82258219383954111bd5e0b75446294cf83eff823f75d7ffcf78d70e9
-  data.tar.gz: 595929050f00724b15b7d26abf4fd8ccbe17f75504593a08c42d327cfa3db4662335e4f215e470c7ce743a68ca2b6d7d087cfdf5a00ec58dcd81183476193255
+  metadata.gz: 6ee0f5f2441e5f278d96edbee0f83163a1024942daa4990a9c471620d68e38659f09b7bf217e5ee13b014971f53d1ebee14ac31fa1ad5e1de11a71c11d4bfc04
+  data.tar.gz: 777a032f696369294a3f5b2c65bfc336d64f9bea907d6203ad902b4927bbeadc66b63c33f3a6152ad640ca8f27d93e6363c020cd2cd81442cb066d1715a31d27

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "phosphor"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/phosphor/app.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Phosphor
+  class App
+    include Phosphor::Objects
+    include Phosphor::Rendering
+
+    attr_reader :canvas, :runner, :renderer
+
+    def initialize(
+      runner: Runners::RawRunner,
+      renderer: Renderers::CursesRenderer
+    )
+      @runner = runner
+      @renderer = renderer
+    end
+
+    def start
+      Phosphor::App.instance = self
+
+      @renderer.setup
+
+      @canvas = Canvas.new(@renderer.cols, @renderer.lines)
+
+      @runner.run do
+        Phosphor::Events::MainReactor.start
+
+        @runner.next_tick do
+          on_start
+        end
+
+        @runner.add_periodic_timer(1.0 / 1000) do
+          @canvas.clear
+          update
+          render
+          after_render
+        end
+      end
+    end
+
+    def update
+      on_update
+    end
+
+    def render
+      game_objects.each do |go|
+        next unless go.to_render?
+
+        go.render
+      end
+
+      @canvas.render
+
+      @renderer.refresh
+    end
+
+    def after_render
+    end
+
+    def stop
+      @renderer.close_screen
+
+      Phosphor::Mouse::Utils.disable_xterm_1003
+
+      Phosphor::App.instance = nil
+    end
+
+    def game_objects
+      @game_objects ||= []
+    end
+
+    def on(event_name, &block)
+      Phosphor::Events::MainReactor.on(event_name, &block)
+    end
+
+    class << self
+      attr_accessor :instance
+    end
+  end
+end

data/lib/phosphor/events/input_event_reactor.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Phosphor
+  module Events
+    class InputEventReactor
+      class << self
+        def start
+          app_instance = Phosphor::App.instance
+          app_instance.runner.add_periodic_timer(0.01) do
+            loop do
+              ch = app_instance.renderer.get_char
+              break if ch.nil?
+
+              case ch
+              when "q"
+                return stop
+              when "\e"
+                case app_instance.renderer.get_char
+                when "["
+                  csi = ""
+                  loop do
+                    d = app_instance.renderer.get_char
+                    csi += d
+                    break if d.ord >= 0x40 && d.ord <= 0x7E
+                  end
+                  if /<(\d+);(\d+);(\d+)(m|M)/ =~ csi
+                    button = Regexp.last_match(1).to_i
+                    x = Regexp.last_match(2).to_i
+                    y = Regexp.last_match(3).to_i
+                    state = Regexp.last_match(4)
+
+                    event = Phosphor::Events::MouseEvent.new(
+                      raw_button: button,
+                      raw_state: state,
+                      x_pos: x,
+                      y_pos: y
+                    )
+
+                    MainReactor.queue.push(event)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phosphor/events/main_reactor.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Phosphor
+  module Events
+    class MainReactor
+      class << self
+        attr_accessor :queue
+
+        def event_listeners
+          @event_listeners ||= {}
+        end
+
+        def start
+          @queue = Phosphor::App.instance.runner.queue_class.new
+
+          InputEventReactor.start
+
+          start_events_consumer
+        end
+
+        def on(event_name, &block)
+          event_listeners[event_name.to_sym] ||= []
+          event_listeners[event_name.to_sym] << block
+        end
+
+        def emit(event)
+          @queue.push(event)
+        end
+
+        private
+
+        def start_events_consumer
+          @queue.pop do |event|
+            event_listeners[event.name.to_sym]&.each { |b| b.call(event) }
+          ensure
+            start_events_consumer
+          end
+        end
+      end
+    end
+  end
+end

data/lib/{razor → phosphor}/events/mouse_event.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Razor
+module Phosphor
   module Events
     class MouseEvent
       attr_reader :kind, :button, :direction, :x_pos, :y_pos
@@ -57,7 +57,7 @@ module Razor
       end
 
       def pressed?
-        @raw_state == 'M'
+        @raw_state == "M"
       end
     end
   end

data/lib/{razor → phosphor}/events/ray_collision_event.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Razor
+module Phosphor
   module Events
     class RayCollisionEvent
       attr_reader :x_pos, :y_pos, :target, :distance, :des_distance

data/lib/{razor → phosphor}/mouse/utils.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Razor
+module Phosphor
   module Mouse
     class Utils
       def self.enable_xterm_1003

data/lib/{razor → phosphor}/objects/base.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-module Razor
+module Phosphor
   module Objects
     class Base
       attr_accessor :app_instance
 
       def initialize(*_)
-        @app_instance = Razor::App.instance
+        @app_instance = Phosphor::App.instance
         @visible = true
 
         @app_instance.game_objects << self
@@ -39,7 +39,7 @@ module Razor
       end
 
       def on(event_name, &block)
-        Razor::Events::InputEventReactor.on(event_name) do |event|
+        Phosphor::Events::MainReactor.on(event_name) do |event|
           next unless app_instance.canvas.entity_on(event.y_pos, event.x_pos) == self
 
           block.call(event, self)
@@ -47,6 +47,16 @@ module Razor
 
         self
       end
+
+      def self.on(event_name, &block)
+        Phosphor::Events::MainReactor.on(event_name) do |event|
+          next unless Phosphor::App.instance.canvas.entity_on(event.y_pos, event.x_pos).class == self
+
+          block.call(event, self)
+        end
+
+        self
+      end
     end
   end
 end

data/lib/{razor → phosphor}/objects/box.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Razor
+module Phosphor
   module Objects
     class Box < Base
       attr_accessor :x_pos, :y_pos,

data/lib/phosphor/objects/circle.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Phosphor
+  module Objects
+    class Circle < Base
+      attr_accessor :radius, :x_pos, :y_pos,
+                    :x_anchor, :y_anchor,
+                    :stroke_char, :fill_char
+
+      def initialize(
+        radius,
+        dot_count,
+        x_pos = 0,
+        y_pos = 0,
+        x_anchor: :start,
+        y_anchor: :start,
+        stroke_char: "*",
+        fill_char: nil
+      )
+        @radius = radius
+        @dot_count = dot_count
+
+        @x_pos = x_pos
+        @y_pos = y_pos
+
+        @x_anchor = x_anchor
+        @y_anchor = y_anchor
+
+        @stroke_char = stroke_char
+        @fill_char = fill_char
+
+        super
+      end
+
+      def anchor_from(anchor, dimension)
+        case anchor
+        when :start
+          0
+        when :middle
+          dimension / 2
+        when :end
+          dimension
+        end
+      end
+
+      def x_pos_start = @x_pos - anchor_from(@x_anchor, @width)
+      def x_pos_end = x_pos_start + @width
+
+      def y_pos_start = @y_pos - anchor_from(@x_anchor, @height) / 2
+      def y_pos_end = y_pos_start + @height / 2
+
+      def render
+        @dot_count.times do |i|
+          percent = i / @dot_count.to_f
+
+          angle_in_rads = percent * Math::PI * 2
+
+          new_x_pos = @x_pos + radius * Math.sin(angle_in_rads)
+          new_y_pos = @y_pos + radius * Math.cos(angle_in_rads) / 2
+
+          3.times do |i|
+            3.times do |j|
+              app_instance.canvas.print_at(new_x_pos - 1 + i, new_y_pos + j - 1, @stroke_char, self)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phosphor/objects/image.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "chunky_png"
+
+module Phosphor
+  module Objects
+    class Image < Base
+      attr_accessor :x_pos, :y_pos,
+                    :scale
+
+      def initialize(
+        image_path,
+        x_pos = 0,
+        y_pos = 0,
+        scale: 1
+      )
+        @x_pos = x_pos
+        @y_pos = y_pos
+        @scale = scale
+
+        image = ChunkyPNG::Image.from_file(image_path)
+
+        @width = image.width
+        @height = image.height
+
+        @pixels = {}
+
+        @width.times do |image_x|
+          @height.times do |image_y|
+            pixel = image.get_pixel(image_x, image_y)
+
+            next unless pixel
+
+            @pixels[image_x] ||= {}
+
+            @pixels[image_x][image_y] = Rendering::ColorPair.from_foreground_hex(pixel.to_s(16).rjust(8, "0")[0..5])
+          end
+        end
+
+        super
+      end
+
+      def render
+        canvas = app_instance.canvas
+
+        @width.times do |image_x|
+          @height.times do |image_y|
+            scale.round.times do |scaled_y|
+              canvas.print_at(
+                (@x_pos + image_x * 2 * scale).round,
+                (@y_pos + image_y * scale + scaled_y).round,
+                "██" * @scale.round,
+                self,
+                color_pair: @pixels[image_x][image_y]
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/{razor → phosphor}/objects/line.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Razor
+module Phosphor
   module Objects
     class Line < Base
       attr_accessor :x1_pos, :y1_pos, :x2_pos, :y2_pos, :stroke_char
@@ -10,7 +10,8 @@ module Razor
         y1_pos,
         x2_pos,
         y2_pos,
-        stroke_char: '*'
+        stroke_char: '*',
+        stroke_color_pair: nil
       )
         @x1_pos = x1_pos
         @y1_pos = y1_pos
@@ -19,6 +20,7 @@ module Razor
         @y2_pos = y2_pos
 
         @stroke_char = stroke_char
+        @stroke_color_pair = stroke_color_pair
 
         super
       end
@@ -40,7 +42,13 @@ module Razor
         err = dx - dy
 
         loop do
-          app_instance.canvas.print_at(x0, y0, @stroke_char, self)
+          app_instance.canvas.print_at(
+            x0,
+            y0,
+            @stroke_char,
+            self,
+            color_pair: @stroke_color_pair
+          )
 
           break if x0 == x1 && y0 == y1
 

data/lib/{razor → phosphor}/objects/ray.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Razor
+module Phosphor
   module Objects
     class Ray < Base
       attr_accessor :x1_pos, :y1_pos, :x2_pos, :y2_pos, :stroke_char
@@ -60,7 +60,7 @@ module Razor
           target = app_instance.canvas.entity_on(x0, y0)
 
           if target && target.class != self.class
-            event = Razor::Events::RayCollisionEvent.new(
+            event = Phosphor::Events::RayCollisionEvent.new(
               x_pos: x0,
               y_pos: y0,
               target:,

data/lib/{razor → phosphor}/objects/text.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Razor
+module Phosphor
   module Objects
     class Text < Base
       attr_accessor :text, :x_pos, :y_pos

data/lib/phosphor/renderers/curses_renderer.rb

@@ -0,0 +1,58 @@
+require "curses"
+
+module Phosphor
+  module Renderers
+    class CursesRenderer
+      def self.setup
+        Curses.init_screen
+        Curses.noecho
+        Curses.curs_set(0)
+        Curses.cbreak
+        # Curses.stdscr.keypad(true)
+        Curses.stdscr.nodelay = true
+
+        Curses.start_color
+        Curses.use_default_colors
+      end
+
+      def self.print_at(x, y, char, color_pair)
+        Curses.attron(Curses.color_pair(color_pair || 0)) do
+          Curses.setpos(y, x)
+          Curses.addstr(char)
+        end
+      end
+
+      def self.cols
+        Curses.cols
+      end
+
+      def self.lines
+        Curses.lines
+      end
+
+      def self.refresh
+        Curses.refresh
+      end
+
+      def self.close_screen
+        Curses.close_screen
+      end
+
+      def self.init_color(color_id, red, green, blue)
+        Curses.init_color(color_id, red, green, blue)
+      end
+
+      def self.get_char
+        Curses.get_char
+      end
+
+      def self.init_pair(pair_id, foreground_color_id, background_color_id)
+        Curses.init_pair(
+          pair_id,
+          foreground_color_id,
+          background_color_id
+        )
+      end
+    end
+  end
+end

data/lib/phosphor/rendering/canvas.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Phosphor
+  module Rendering
+    class Canvas
+      attr_reader :width, :height, :objects_at
+
+      def initialize(width, height)
+        @width  = width
+        @height = height
+        @mutex  = Mutex.new
+        clear
+      end
+
+      def clear
+        @mutex.synchronize do
+          @pixels = Array.new(@height) { Array.new(@width, " ") }
+          @color_pairs = Array.new(@height) { Array.new(@width, nil) }
+          @objects_at = Array.new(@height) { Array.new(@width, nil) }
+        end
+      end
+
+      def was_changed?
+        @was_changed
+      end
+
+      def print_at(x_pos, y_pos, string, owner = nil, color_pair: nil, foreground_color: nil, background_color: nil)
+        @mutex.synchronize do
+          return if y_pos.negative? || y_pos >= @height
+
+          @was_changed = true
+
+          string.chars.each_with_index do |ch, i|
+            px = x_pos + i
+            break if px >= @width
+            next if px.negative?
+
+            if color_pair || foreground_color || background_color
+              @color_pairs[y_pos][px] = color_pair&.pair_id
+              @color_pairs[y_pos][px] ||=
+                ColorPair.new(foreground_color, background_color).pair_id
+            end
+            @pixels[y_pos][px] = ch
+            @objects_at[y_pos][px] = owner
+          end
+        end
+      end
+
+      def entity_on(x_pos, y_pos)
+        (objects_at[y_pos] || {})[x_pos]
+      end
+
+      def render
+        @mutex.synchronize do
+          return unless was_changed?
+
+          @was_changed = false
+
+          @pixels.each_with_index do |row, y|
+            row.each_with_index do |char, x|
+              Phosphor::App.instance.renderer.print_at(x, y, char, @color_pairs[y][x] || 0)
+            end
+          end
+        end
+      end
+
+      def x_center_pos
+        (width / 2).floor
+      end
+
+      def y_center_pos
+        (height / 2).floor
+      end
+    end
+  end
+end

data/lib/phosphor/rendering/color.rb

@@ -0,0 +1,60 @@
+module Phosphor
+  module Rendering
+    class Color
+      attr_reader :color_id, :red_thousand, :green_thousand, :blue_thousand
+
+      def initialize(red_thousand, green_thousand, blue_thousand)
+        @color_id = self.class.generate_new_color_id
+
+        @red_thousand = red_thousand
+        @green_thousand = green_thousand
+        @blue_thousand = blue_thousand
+
+        Phosphor::App.instance.renderer.init_color(@color_id, red_thousand, green_thousand, blue_thousand)
+      end
+
+      def foreground_pair
+        ColorPair.new(self)
+      end
+
+      def hex
+        [
+          red_thousand,
+          green_thousand,
+          blue_thousand
+        ].map do |a|
+          self.class.thousand_to_hex(a).to_s(16)
+        end.join.upcase
+      end
+
+      class << self
+        def from_rgb(red, green, blue)
+          from_hex(rgb_to_hex(red, green, blue))
+        end
+
+        def from_hex(hex)
+          red, green, blue = hex.scan(/.{2}/).map { |a| (a.to_i(16) / 255.to_f * 1000).round }
+
+          colors[hex] ||= new(red, green, blue)
+        end
+
+        def colors
+          @colors ||= {}
+        end
+
+        def generate_new_color_id
+          @last_color_id ||= 16
+          @last_color_id += 1
+        end
+
+        def thousand_to_hex(value)
+          (value / 1000.to_f * 255).round
+        end
+
+        def rgb_to_hex(red, green, blue)
+          [red, green, blue].map { |a| (a / 100.to_f * 255).round.to_s(16).rjust(2, '0') }.join.upcase
+        end
+      end
+    end
+  end
+end