or2d 0.0.0

data/lib/or2d/instance.rb

@@ -0,0 +1,186 @@
+module OR2D
+  # The Instance object represents a single running instance of OR2D. It maintains a list of all entities in the
+  # current instance, and a list of all scenes in the current instance. It also maintains a reference to the current
+  # scene. There should only be one instance of OR2D::Instance at any given time.
+  class Instance
+    include Singleton
+
+    # @!attribute [r] entities
+    # @return [Hash] a hash of all entities in the game instance
+    attr_reader :entities
+
+    # @!attribute [r] scene
+    # @return [OR2D::Scene] the current scene
+    attr_reader :scene
+
+    # @!attribute [r] window
+    # @return [Ruby2D::Window] the game window
+    attr_reader :window
+
+    # @!attribute [r] modifiers
+    # @return [Array] the currently held modifier keys
+    attr_reader :modifiers
+
+    # @!attribute [r] mouse
+    # @return [OR2D::Mouse] the mouse state
+    attr_reader :mouse
+
+    # Constructs a new OR2D instance.
+    def initialize
+      super()
+      setup
+    end
+
+    # Run the game instance.
+    def run
+      @window.render do
+        @scene.render unless @scene.nil? || @scene.rendered? || @scene.finished?
+      rescue StandardError => e
+        puts "An error occurred while rendering the scene: #{e.message}"
+        puts e.backtrace if OR2D.debug?
+      end
+
+      @window.update do
+        process_animations
+        process_scene
+      rescue StandardError => e
+        puts "An error occurred while updating the scene: #{e.message}"
+        puts e.backtrace if OR2D.debug?
+      end
+
+      @window.show
+    end
+
+    # Schedule an animation for an entity.
+    def animate(entity_id, &_)
+      @animations[entity_id] ||= Set.new
+      @animations[entity_id].add(OR2D::Animation.new(entity_id, &_))
+    end
+
+    # Adds a scene to the game instance.
+    # @param scene [OR2D::Scene] the scene to add
+    def add_scene(scene)
+      @scenes.add(scene)
+    end
+
+    # Adds an entity to the game instance.
+    # @param entity [OR2D::Entity] the entity to add
+    def add_entity(entity)
+      @entities[entity.id] = entity
+    end
+
+    # Removes an entity from the game instance.
+    # @param entity_id [String] the ID of the entity to remove
+    # @return [OR2D::Entity] the removed entity
+    def remove_entity(entity_id)
+      @entities.delete(entity_id)
+    end
+
+    # Is the current frame a key frame?
+    # @param frame [Integer] the key frame interval
+    # @return [Boolean] whether or not the current frame is a key frame
+    def key_frame?(frame = 60)
+      (@window.get(:frames) % frame).zero?
+    end
+
+    # Close the game instance.
+    def quit
+      @window.close
+    end
+
+    private
+
+    def setup
+      @window = Ruby2D::Window.new(title: ENV['OR2D_TITLE'] || 'OR2D Game',
+                                   width: ENV['OR2D_WIDTH']&.to_i || OR2D.lowest_scalable_width,
+                                   height: ENV['OR2D_HEIGHT']&.to_i || OR2D.lowest_scalable_height,
+                                   vsync: ENV['OR2D_VSYNC'] || true)
+
+      @projectiles = Set.new
+      @animations = {}
+      @entities = {}
+      @modifiers = { shift: false, control: false, alt: false, meta: false, backspace: false }
+      @mouse = { left: false, right: false, middle: false }
+      @scenes = Set.new
+
+      @window.on(:key_up) do |event|
+        case event.key
+        when /shift/ then @modifiers[:shift] = false
+        when /ctrl|control/ then @modifiers[:control] = false
+        when /alt/ then @modifiers[:alt] = false
+        when /meta/ then @modifiers[:meta] = false
+        when /backspace/ then @modifiers[:backspace] = false
+        end
+      end
+
+      @window.on(:key_held) do |event|
+        case event.key
+        when /shift/ then @modifiers[:shift] = true
+        when /ctrl|control/ then @modifiers[:control] = true
+        when /alt/ then @modifiers[:alt] = true
+        when /meta/ then @modifiers[:meta] = true
+        when /backspace/ then @modifiers[:backspace] = true
+        end
+      end
+
+      @window.on(:mouse_down) do |event|
+        case event.button
+        when :left then @mouse[:left] = true
+        when :right then @mouse[:right] = true
+        when :middle then @mouse[:middle] = true
+        end
+      end
+
+      @window.on(:mouse_up) do |event|
+        case event.button
+        when :left then @mouse[:left] = false
+        when :right then @mouse[:right] = false
+        when :middle then @mouse[:middle] = false
+        end
+      end
+
+      Signal.trap('INT') do
+        Thread.new do
+          puts 'Caught SIGINT, exiting...'
+          quit
+        end.join
+      end
+
+      Signal.trap('TERM') do
+        Thread.new do
+          puts 'Caught SIGTERM, exiting...'
+          quit
+        end.join
+      end
+    end
+
+    def process_animations
+      return if @animations.empty?
+
+      @animations.each do |id, bundle|
+        bundle.each(&:resume)
+        bundle.delete_if(&:complete?)
+        @animations.delete(id) if bundle.empty?
+      end
+    end
+
+    def process_scene
+      if @scene.nil? || @scene.finished?
+        if @scenes.empty?
+          @scene = OR2D::Scenes::PlaceholderScene.new
+        else
+          @scene = @scenes.first
+          @scenes.delete(@scene)
+        end
+
+        @scene.render
+      end
+
+      @scene.update
+    rescue StandardError => e
+      puts "An error occurred while processing the current scene: #{e.message}"
+      puts e.backtrace if OR2D.debug?
+    end
+
+  end
+end

data/lib/or2d/patches/music.rb

@@ -0,0 +1,30 @@
+module Ruby2D
+  class Music
+
+    attr :playing
+
+    def playing?
+      @playing
+    end
+
+    def play
+      @playing ||= true
+      ext_play
+    end
+
+    def pause
+      @playing = false
+      ext_pause
+    end
+
+    def resume
+      @playing = true
+      ext_resume
+    end
+
+    def stop
+      @playing = false
+      ext_stop
+    end
+  end
+end

data/lib/or2d/patches/renderable.rb

@@ -0,0 +1,5 @@
+module Ruby2D::Renderable
+  def to_entity
+    OR2D::Entity.new(:entity, { resource: self })
+  end
+end

data/lib/or2d/patches/sound.rb

@@ -0,0 +1,18 @@
+module Ruby2D
+  class Sound
+
+    def play
+      @playing = true
+      ext_play
+    end
+
+    def playing?
+      @playing
+    end
+
+    def stop
+      @playing = false
+      ext_stop
+    end
+  end
+end

data/lib/or2d/patches/sprite.rb

@@ -0,0 +1,20 @@
+module Ruby2D
+  class Sprite
+
+    attr_reader :animations, :defaults, :playing
+
+    # Explicitly set the frame of the Sprite.
+    # The animation hash is expected to be in either of the following formats:
+    # { animation_name: [frame_1, frame_2, ...] }
+    # { animation_name: frame_range }
+    # This function will grab the explicit frame index of the given animation and set it.
+    def set_explicit_frame(animation, frame = 0)
+      _set_explicit_frame(@animations[animation][frame])
+    end
+
+    def default_frame(animation, frame = 0)
+      @defaults[:animation] = animation
+      @defaults[:frame] = frame
+    end
+  end
+end

data/lib/or2d/patches/window.rb

@@ -0,0 +1,9 @@
+module Ruby2D
+  class Window
+    attr_reader :objects
+
+    def rendered?(object)
+      @objects.include?(object)
+    end
+  end
+end

data/lib/or2d/resource.rb

@@ -0,0 +1,182 @@
+# The Resource module contains helper methods for creating resources.
+# @author Patrick W.
+# @since 2023-04-20
+module OR2D::Resource
+
+  # Construct a new resource of the given type with the passed options.
+  # @param type [Symbol] the type of resource to create
+  # @param options [Hash] the options to pass to the resource
+  def create(type, options)
+    case type
+    when :image then OR2D::Resource.create_image(options)
+    when :sprite then OR2D::Resource.create_sprite(options)
+    when :text then OR2D::Resource.create_text(options)
+    when :tileset then OR2D::Resource.create_tileset(options)
+    when :triangle then OR2D::Resource.create_triangle(options)
+    when :quad then OR2D::Resource.create_quad(options)
+    when :circle then OR2D::Resource.create_circle(options)
+    when :square then OR2D::Resource.create_square(options)
+    when :line then OR2D::Resource.create_line(options)
+    when :rectangle then OR2D::Resource.create_rectangle(options)
+    else raise "Unknown resource type: #{type}!"
+    end
+  end
+
+  # Create a Ruby2D::Circle object from the given options.
+  # @param options [Hash] the options to pass to the Circle
+  # @return [Ruby2D::Circle] the created Circle
+  def create_circle(options)
+    Ruby2D::Circle.new(x: options[:x] || 0,
+                       y: options[:y] || 0,
+                       z: options[:z] || 0,
+                       radius: options[:radius] || 50,
+                       sectors: options[:sectors] || 30,
+                       color: options[:color] || 'yellow',
+                       opacity: options[:opacity] || 1.0)
+  end
+
+  # Create a Ruby2D::Image object from the given options.
+  # @param options [Hash] the options to pass to the Image
+  # @return [Ruby2D::Image] the created Image
+  def create_image(options)
+    Ruby2D::Image.new(options[:path],
+                      atlas: options[:atlas],
+                      width: options[:width] * OR2D.scale || 4,
+                      height: options[:height] * OR2D.scale || 4,
+                      opacity: options[:opacity] || 1.0,
+                      rotate: options[:rotate] || 0,
+                      x: options[:x] || 0,
+                      y: options[:y] || 0,
+                      z: options[:z] || 0)
+  end
+
+  # Create a Ruby2D::Line object from the given options.
+  # @param options [Hash] the options to pass to the Line
+  # @return [Ruby2D::Line] the created Line
+  def create_line(options)
+    Ruby2D::Line.new(x1: options[:x1],
+                     y1: options[:y1],
+                     x2: options[:x2],
+                     y2: options[:y2],
+                     z: options[:z],
+                     width: options[:width] * OR2D.scale || 2,
+                     color: options[:color] || 'yellow',
+                     opacity: options[:opacity] || 1.0)
+  end
+
+  # Create a Ruby2D::Rectangle object from the given options.
+  # @param options [Hash] the options to pass to the Rectangle
+  # @return [Ruby2D::Rectangle] the created Rectangle
+  def create_rectangle(options)
+    Ruby2D::Rectangle.new(x: options[:x] || 0,
+                          y: options[:y] || 0,
+                          z: options[:z] || 0,
+                          width: options[:width] * OR2D.scale,
+                          height: options[:height] * OR2D.scale,
+                          color: options[:color] || 'yellow',
+                          opacity: options[:opacity] || 1.0)
+  end
+
+  # Create a Ruby2D::Sprite object from the given options.
+  # @param options [Hash] the options to pass to the Sprite
+  # @return [Ruby2D::Sprite] the created Sprite
+  def create_sprite(options)
+    Ruby2D::Sprite.new(options[:path],
+                       atlas: options[:atlas],
+                       width: options[:width] ? options[:width] * OR2D.scale : nil,
+                       height: options[:height] ? options[:height] * OR2D.scale : nil,
+                       rotate: options[:rotate] || 0,
+                       opacity: options[:opacity] || 1.0,
+                       loop: options[:loop] || false,
+                       time: options[:time] || 100,
+                       animations: options[:animations] || {},
+                       default: options[:default] || 0,
+                       clip_height: options[:clip_height],
+                       clip_width: options[:clip_width],
+                       clip_x: options[:clip_x] || 0,
+                       clip_y: options[:clip_y] || 0,
+                       x: options[:x] || 0,
+                       y: options[:y] || 0,
+                       z: options[:z] || 0)
+  end
+
+  # Create a Ruby2D::Square object from the given options.
+  # @param options [Hash] the options to pass to the Square
+  # @return [Ruby2D::Square] the created Square
+  def create_square(options)
+    Ruby2D::Square.new(x: options[:x] || 0,
+                       y: options[:y] || 0,
+                       z: options[:z] || 0,
+                       size: options[:size],
+                       color: options[:color] || 'yellow',
+                       opacity: options[:opacity] || 1.0)
+  end
+
+  # Create a Ruby2D::Text object from the given options.
+  # @param options [Hash] the options to pass to the Text
+  # @return [Ruby2D::Text] the created Text
+  def create_text(options)
+    Ruby2D::Text.new(options[:text],
+                     x: options[:x] || 0,
+                     y: options[:y] || 0,
+                     z: options[:z] || 0,
+                     size: (options[:size] || 16) * OR2D.scale,
+                     style: options[:style],
+                     font: options[:font] || Ruby2D::Font.default,
+                     color: options[:color] || 'yellow',
+                     rotate: options[:rotate] || 0,
+                     opacity: options[:opacity] || 1.0)
+  end
+
+  # Create a Ruby2D::Tileset object from the given options.
+  # @param options [Hash] the options to pass to the Tileset
+  # @return [Ruby2D::Tileset] the created Tileset
+  def create_tileset(options)
+    Ruby2D::Tileset.new(options[:path],
+                        tile_width: options[:tile_width] || 16,
+                        tile_height: options[:tile_height] || 16,
+                        width: options[:width],
+                        height: options[:height],
+                        z: options[:z] || 100,
+                        padding: options[:padding] || 0,
+                        spacing: options[:spacing] || 0,
+                        scale: options[:scale] || 1,
+                        show: options[:show] || false)
+  end
+
+  # Create a Ruby2D::Triangle object from the given options.
+  # @param options [Hash] the options to pass to the Triangle
+  # @return [Ruby2D::Triangle] the created Triangle
+  def create_triangle(options)
+    Ruby2D::Triangle.new(x1: options[:x1],
+                         y1: options[:y1],
+                         x2: options[:x2],
+                         y2: options[:y2],
+                         x3: options[:x3],
+                         y3: options[:y3],
+                         z: options[:z],
+                         color: options[:color] || 'yellow',
+                         opacity: options[:opacity] || 1.0)
+  end
+
+  # Create a Ruby2D::Quad object from the given options.
+  # @param options [Hash] the options to pass to the Quad
+  # @return [Ruby2D::Quad] the created Quad
+  def create_quad(options)
+    Ruby2D::Quad.new(x1: options[:x1],
+                     y1: options[:y1],
+                     x2: options[:x2],
+                     y2: options[:y2],
+                     x3: options[:x3],
+                     y3: options[:y3],
+                     x4: options[:x4],
+                     y4: options[:y4],
+                     z: options[:z],
+                     color: options[:color] || 'yellow',
+                     opacity: options[:opacity] || 1.0)
+  end
+
+  class << self
+    include OR2D::Resource
+  end
+end

data/lib/or2d/scene.rb

@@ -0,0 +1,160 @@
+module OR2D
+  # A Scene object represents a single scene in an OR2D instance. Each Scene maintains two internal lists to keep
+  # track of the visibility state of Entities in the scene. It provides 3 functions to control how the Scene is updated,
+  # rendered, and whether or not it should be redrawn. It is recommended to use inheritance to create new scenes.
+  # @example Inheritance
+  #   class MyScene < OR2D::Scene
+  #     def initialize
+  #       super('my_scene')
+  #     end
+  #
+  #     private
+  #
+  #     def setup_render
+  #      super do
+  #        # Render code here
+  #       end
+  #     end
+  #
+  #     def setup_update
+  #       super do
+  #         # Update code here
+  #       end
+  #     end
+  #
+  #     def setup_redraw
+  #       super do
+  #         # Redraw code here
+  #       end
+  #     end
+  #   end
+  #
+  # @author Patrick W.
+  # @since 2023-04-12
+  class Scene
+
+    # @!attribute [r] id
+    # @return [String] the ID of the scene
+    attr_reader :id
+
+    # Constructs a new Scene object.
+    # @param id [String] the ID of the scene
+    # @param procs [Hash] a hash of procs to be used for the scene
+    def initialize(id, procs = {})
+      @id = id
+      @descriptors = {}
+      @workers = {}
+      @visible = Set.new
+      @hidden = Set.new
+      @rendered = false
+      @finish = false
+
+      procs[:redraw?].nil? ? setup_redraw : setup_redraw(&procs[:redraw?])
+      procs[:update].nil? ? setup_update : setup_update(&procs[:update])
+      procs[:render].nil? ? setup_render : setup_render(&procs[:render])
+
+      self
+    end
+
+    # Updates the scene.
+    def update
+      @workers[:update].resume(self)
+    end
+
+    # Render the scene.
+    def render
+      @workers[:render].resume
+    end
+
+    # Should the scene be redrawn?
+    # @return [Boolean] true if the scene should be redrawn, false otherwise
+    def redraw?
+      @workers[:redraw?].resume
+    end
+
+    # Finishes the scene.
+    def finish
+      @descriptors.each_value { |descriptor| OR2D.game.window.off(descriptor) }
+      @finish = true
+    end
+
+    # Has the scene finished?
+    # @return [Boolean] true if the scene has finished, false otherwise
+    def finished?
+      @finish
+    end
+
+    # Has the scene been rendered?
+    def rendered?
+      @rendered
+    end
+
+    private
+
+    # Halts the running fiber, stopping the scene.
+    def halt
+      Fiber.yield
+    end
+
+    # Setup event descriptors.
+    def setup_descriptor(label, event, &block)
+      @descriptors[label] = OR2D.game.window.on(event, &block)
+    end
+
+    # Setup the Scene's render worker.
+    def setup_render(&_)
+      @workers[:render] = Fiber.new do
+        loop do
+          break if finished?
+
+          @visible.each { |entity_id| OR2D::Game.source.add(OR2D::Game.entities[entity_id]) }
+          @hidden.each { |entity_id| OR2D::Game.source.remove(OR2D::Game.entities[entity_id]) }
+
+          yield if block_given?
+        rescue StandardError => e
+          puts e.message
+          puts e.backtrace if OR2D.debug?
+        ensure
+          @rendered = true
+          Fiber.yield unless finished?
+        end
+      end
+    end
+
+    # Setup the Scene's update worker.
+    def setup_update(&_)
+      @workers[:update] = Fiber.new do |scene|
+        loop do
+          break if finished?
+
+          yield(scene) if block_given?
+        rescue StandardError => e
+          puts e.message
+          puts e.backtrace if OR2D.debug?
+        ensure
+          Fiber.yield unless finished?
+        end
+      end
+    end
+
+    # Setup the Scene's redraw? worker.
+    def setup_redraw(&_)
+      @workers[:redraw?] = Fiber.new do
+        loop do
+          break if finished?
+
+          if rendered? && block_given?
+            Fiber.yield(yield)
+          elsif rendered?
+            Fiber.yield(true)
+          else
+            Fiber.yield(false)
+          end
+        rescue StandardError => e
+          puts e.message
+          puts e.backtrace if OR2D.debug?
+        end
+      end
+    end
+  end
+end

data/lib/or2d/scenes/placeholder_scene.rb

@@ -0,0 +1,70 @@
+module OR2D::Scenes
+  # The PlaceholderScene class is a placeholder scene for the OR2D gem. When no other scenes are enqueued or displayed, this scene will be displayed.
+  class PlaceholderScene < OR2D::Scene
+
+    # Construct a new PlaceholderScene object.
+    def initialize
+      super('PLACEHOLDER_SCENE')
+      @cursor_position = OR2D::Entity.new(:text, { color: 'white', x: 0, y: 0, size: 16, height: 16, width: 16 })
+
+      setup_events
+      setup_console
+    end
+
+    # Complete processing of the scene
+    def finish
+      @console.remove
+      @cursor_position.destroy
+      @descriptors.each_value { |descriptor| OR2D.game.window.off(descriptor) }
+      super
+    end
+
+    private
+
+    def setup_console
+      @console = OR2D::Console.new
+    end
+
+    def setup_render
+      super do
+        @cursor_position.show
+      end
+    end
+
+    def setup_update
+      super do
+        @cursor_position.x = OR2D.game.window.get(:mouse_x)
+        @cursor_position.y = OR2D.game.window.get(:mouse_y)
+        @console.update
+      end
+    end
+
+    def setup_events
+      setup_descriptor(:mouse_input, :mouse) do |event|
+        @cursor_position.resource.text = "[x: #{event.x}, y: #{event.y}]"
+        @cursor_position.width = @cursor_position.resource.text.length * (6 * OR2D.scale)
+      end
+
+      setup_descriptor(:debug_input, :key_up) do |event|
+        case event.key
+        when 'g' then @cursor_position.grow(factor: 0.2)
+        when 'z' then @cursor_position.shrink(factor: 0.2)
+        when 't' then @cursor_position.fade(speed: 0.01)
+        when 'r'
+          if OR2D.game.modifiers[:control]
+            OR2D.game.entities.each_value(&:rotate) && @cursor_position.rotate
+          elsif OR2D.game.modifiers[:meta]
+            @cursor_position.rotation(speed: 1.0, angle: 360, clockwise: false)
+          else
+            @cursor_position.rotation(speed: 1.0, angle: 360, clockwise: true)
+          end
+        when 'b'
+          if OR2D.game.modifiers[:control]
+            OR2D.game.entities.each_value(&:toggle_boundary) && @cursor_position.toggle_boundary
+          end
+        when 'escape' then finish
+        end
+      end
+    end
+  end
+end