or2d 0.0.0

data/lib/or2d/composites/sprite.rb

@@ -0,0 +1,245 @@
+module OR2D::Composites
+  # The Composite Sprite class is a composite entity that is made up of multiple sprites entities that behave as the composite layers.
+  class Sprite < OR2D::Composite
+    include OR2D::Animations::CompositeAnimations
+
+    # Constructs a new Composite Sprite object.
+    # @param options [Hash] a hash of options
+    def initialize(options)
+      super(options[:id] || "SpriteComposite_#{SecureRandom.uuid}")
+      if options[:layers]
+        options[:layers].each do |layer|
+          add_layer(layer[:type], layer, entity: layer[:entity])
+        end
+      else
+        add_layer(:sprite, options)
+      end
+    end
+
+    # Add a layer to the Sprite. This will also reorder the z-index of all other layers in the Sprite.
+    # @param type [Symbol] the type of Entity object to add
+    # @param options [Hash] a hash of options to pass to the Entity object
+    # @param entity [OR2D::Entity] an optional Entity object to add if the type is :entity
+    # @param position [Symbol] the position to add the layer to, either :top or :bottom
+    def add_layer(type, options, entity: nil, position: :top)
+      if @layers.empty?
+        super(type, options, entity: entity)
+        id = @layers.keys.first
+      elsif position == :top
+        super(type, options.merge(z: OR2D.game.entities[@layers.keys.first].resource.z + 1), entity: entity)
+        sort_by_z
+        id = @layers.keys.first
+      elsif position == :bottom
+        super(type, options.merge(z: OR2D.game.entities[@layers.keys.last].resource.z - 1), entity: entity)
+        sort_by_z
+        id = @layers.keys.last
+      else
+        add_layer(type, options, entity: entity, position: :top)
+      end
+
+      @layers[id][:offsets] = [options[:x_offset] || 0,
+                               options[:y_offset] || 0,
+                               options[:width_offset] || 0,
+                               options[:height_offset] || 0]
+      apply_offsets(id)
+      id
+    end
+
+    # Remove a layer from the Sprite. This will also reorder the z-index of all other layers in the Sprite.
+    # @param id [String] the id of the layer to remove
+    def remove_layer(id)
+      super(id)
+      sort_by_z unless @layers.empty? || @layers.size == 1
+    end
+
+    # Bring a layer to the front of the Sprite. This will also reorder the z-index of all other layers in the Sprite.
+    # @param id [String] the id of the layer to bring to the front
+    def bring_to_front(id)
+      OR2D.game.entities[id].resource.z = OR2D.game.entities[@layers.keys.first].resource.z
+      @layers.each_key do |key|
+        next if key == id
+
+        OR2D.game.entities[key].resource.z -= 1
+      end
+      sort_by_z
+    end
+
+    # Send a layer to the back of the Sprite. This will also reorder the z-index of all other layers in the Sprite.
+    # @param id [String] the id of the layer to send to the back
+    def send_to_back(id)
+      OR2D.game.entities[id].resource.z = OR2D.game.entities[@layers.keys.last].resource.z
+      @layers.each_key do |key|
+        next if key == id
+
+        OR2D.game.entities[key].resource.z += 1
+      end
+      sort_by_z
+    end
+
+    # Swap the z-index of two layers in the Sprite. This will also reorder the z-index of all other layers in the Sprite.
+    # @param from_idx [String] the index of the id of the layer to swap
+    # @param to_idx [String] the index of the id of the layer to swap with
+    def swap(from_idx, to_idx)
+      from = @layers.keys[from_idx]
+      to = @layers.keys[to_idx]
+      OR2D.game.entities[from].resource.z, OR2D.game.entities[to].resource.z = OR2D.game.entities[to].resource.z, OR2D.game.entities[from].resource.z
+      sort_by_z
+    end
+
+    # Set the height of all layers in the Sprite.
+    # @param height [Integer] the height to set
+    def height=(height)
+      @layers.each_key do |id|
+        OR2D.game.entities[id].height = height + @layers[id][:offsets][3]
+      end
+    end
+
+    # Get the height of a specific layer.
+    # @param layer_idx [Integer] the index of the layer to get the height of
+    def get_layer_height(layer_idx = -1)
+      OR2D.game.entities[@layers.keys[layer_idx]].height
+    end
+
+    # Set the height of the Sprite or a specific layer with or without offsets.
+    # @param height [Integer] the height to set
+    # @param layer_id [String] the id of the layer to set the height of
+    # @param offsets [Boolean] whether or not to apply offsets to the height
+    def set_layer_height(layer_id, height, offsets: true)
+      OR2D.game.entities[layer_id].height = offsets ? height + @layers[layer_id][:offsets][3] : height
+    end
+
+    # Set the width of the Sprite.
+    # @param width [Integer] the width to set
+    def width=(width)
+      @layers.each_key do |id|
+        OR2D.game.entities[id].width = width + @layers[id][:offsets][2]
+      end
+    end
+
+    # Get the width of a specific layer.
+    # @param layer_idx [Integer] the index of the layer to get the width of
+    def get_layer_width(layer_idx = -1)
+      OR2D.game.entities[@layers.keys[layer_idx]].width
+    end
+
+    # Set the width of the Sprite or a specific layer with or without offsets.
+    # @param width [Integer] the width to set
+    # @param layer_id [String] the id of the layer to set the width of
+    # @param offsets [Boolean] whether or not to apply offsets to the width
+    def set_layer_width(layer_id, width, offsets: true)
+      OR2D.game.entities[layer_id].width = offsets ? width + @layers[layer_id][:offsets][2] : width
+    end
+
+    # Get the x-coordinate of the Sprite. This is determined by the last layer's x-coordinate.
+    # @return [Integer] the x-coordinate of the Sprite
+    def x
+      OR2D.game.entities[@layers.keys.last].x
+    end
+
+    # Set the x-coordinate of the Sprite with offsets.
+    # @param x_coordinate [Integer] the x-coordinate to set
+    def x=(x_coordinate)
+      @layers.each_key do |id|
+        OR2D.game.entities[id].x = x_coordinate + @layers[id][:offsets][0]
+      end
+    end
+
+    # Get the x-coordinate of a specific layer.
+    # @param layer_idx [Integer] the index of the layer to get the x-coordinate of
+    def get_layer_x(layer_idx = -1)
+      OR2D.game.entities[@layers.keys[layer_idx]].x
+    end
+
+    # Set the x-coordinate of a specific layer with or without offsets.
+    # @param x_coordinate [Integer] the x-coordinate to set
+    # @param layer_id [Integer] the layer to set the x-coordinate of
+    # @param offsets [Boolean] whether or not to apply offsets
+    def set_layer_x(layer_id, x_coordinate, offsets: true)
+      OR2D.game.entities[layer_id].x = offsets ? x_coordinate + @layers[layer_id][:offsets][0] : x_coordinate
+    end
+
+    # Get the y-coordinate of the Sprite. This is determined by the last layer's y-coordinate.
+    # @return [Integer] the y-coordinate of the Sprite
+    def y
+      OR2D.game.entities[@layers.keys.last].y
+    end
+
+    # Set the y-coordinate of the Sprite with offsets.
+    # @param y_coordinate [Integer] the y-coordinate to set
+    def y=(y_coordinate)
+      @layers.each_key do |id|
+        OR2D.game.entities[id].y = y_coordinate + @layers[id][:offsets][1]
+      end
+    end
+
+    # Get the y-coordinate of a specific layer.
+    # @param layer_idx [Integer] the index of the layer to get the y-coordinate of
+    def get_layer_y(layer_idx = -1)
+      OR2D.game.entities[@layers.keys[layer_idx]].y
+    end
+
+    # Set the y-coordinate of the Sprite or a specific layer with or without offsets.
+    # @param y_coordinate [Integer] the y-coordinate to set
+    # @param layer_id [String] the id of the layer to set the y-coordinate of
+    # @param offsets [Boolean] whether or not to apply offsets to the y-coordinate
+    def set_layer_y(layer_id, y_coordinate, offsets: true)
+      OR2D.game.entities[layer_id].y = offsets ? y_coordinate + @layers[layer_id][:offsets][1] : y_coordinate
+    end
+
+    # Plays all animations for layers that are visible.
+    # @param options [Hash] the options to play the animations with
+    # @note Animations should be passed using the following convention:
+    def play(options = {})
+      if options.key?(:layers)
+        options[:layers].each do |layer_id, options|
+          next unless @layers[layer_id][:show]
+          next unless OR2D.game.entities[layer_id].resource.respond_to?(:play)
+          next if options[:except].include?(layer_id)
+
+          OR2D.game.entities[layer_id].resource.play(animation: options[:animation],
+                                                     loop: options[:loop],
+                                                     flip: options[:flip],
+                                                     &options[:done])
+
+        end
+      elsif options.key?(:layer)
+        return unless @layers[options[:layer]][:show]
+        return unless OR2D.game.entities[options[:layer]].resource.respond_to?(:play)
+
+        OR2D.game.entities[options[:layer]].resource.play(animation: options[:animation],
+                                                          loop: options[:loop],
+                                                          flip: options[:flip],
+                                                          &options[:done])
+      else
+        @layers.each do |id, properties|
+          next unless properties[:show]
+          next unless OR2D.game.entities[id].resource.respond_to?(:play)
+          next if options[:except].include?(id)
+
+          OR2D.game.entities[id].resource.play(animation: options[:animation],
+                                               loop: options[:loop],
+                                               flip: options[:flip],
+                                               &options[:done])
+        end
+      end
+    end
+
+    # Sort the layers of the Sprite by their by z-coordinate.
+    def sort_by_z
+      @layers.keys
+             .sort_by! { |key| -OR2D.game.entities[key].resource.z }
+             .each { |k| @layers[k] = @layers.delete(k) }
+    end
+
+    private
+
+    def apply_all_offsets
+      @layers.each_key { |id| apply_offsets(id) }
+    end
+
+    def apply_offsets(layer_id)
+      OR2D.game.entities[layer_id].x += @layers[layer_id][:offsets][0]
+      OR2D.game.entities[layer_id].y += @layers[layer_id][:offsets][1]
+    end
+  end
+end

data/lib/or2d/composites/text.rb

@@ -0,0 +1,167 @@
+module OR2D::Composites
+  # The Composite Text class is a composite entity that can be used to display multiple lines of text. It displays each line of text on a separate layer. It displays sentences character by character.
+  class Text < OR2D::Composite
+    include OR2D::Animations::CompositeAnimations
+
+    # Construct a new Composite Text object.
+    # @param options [Hash] the options to create the Composite Text object with
+    # @option options [Integer] :limit (24) the maximum number of characters that can be displayed on a single line
+    # @option options [Integer] :lines (0) the number of lines that can be displayed
+    # @option options [Integer] :update_interval (5) the number of frames between each update
+    def initialize(options = {})
+      super(options[:id] || "TextComposite_#{SecureRandom.uuid}")
+      @limit = options[:limit] || 24
+      @lines = 0
+      @update_interval = options[:update_interval] || 5
+      if options[:lines]
+        options[:lines].each do |line_opt|
+          add_line(line_opt)
+        end
+      elsif options[:line]
+        add_line(options[:line])
+      end
+    end
+
+    # Get the x coordinate of the text object.
+    # @param last [Boolean] whether to get the x coordinate of the last layer or the first layer
+    # @return [Integer] the x coordinate of the text object
+    def x(last: false)
+      OR2D.game.entities[last ? @layers.keys.last : @layers.keys.first].x
+    end
+
+    # Get the y coordinate of the text object.
+    # @param last [Boolean] whether to get the y coordinate of the last layer or the first layer
+    # @return [Integer] the y coordinate of the text object
+    def y(last: false)
+      OR2D.game.entities[last ? @layers.keys.last : @layers.keys.first].y
+    end
+
+    # Set the y coordinate of the text object.
+    # @param value [Integer] the y coordinate to set
+    def y=(value)
+      @layers.each_key do |key|
+        offset = if key == @layers.keys.first
+                   0
+                 else
+                   previous = @layers.keys[@layers.keys.index(key) - 1]
+                   OR2D.game.entities[previous].y + (OR2D.game.entities[previous].resource.size / OR2D.scale)
+                 end
+        OR2D.game.entities[key].y = value + offset
+      end
+    end
+
+    # Set the x coordinate of the text object.
+    # @param value [Integer] the x coordinate to set
+    def x=(value)
+      @layers.each_key do |key|
+        OR2D.game.entities[key].x = value
+      end
+    end
+
+    # Clear text for a specific layer or all layers
+    # @param layer_idx [Integer, Symbol] the index of the layer to clear or :all to clear all layers
+    def clear(layer_idx)
+      if layer_idx == :all
+        @layers.each do |id, properties|
+          properties[:buffer] = String.new
+          properties[:cursor] = 0
+        end
+      else
+        @layers[@layers.keys[layer_idx]][:buffer] = String.new
+        @layers[@layers.keys[layer_idx]][:cursor] = 0
+      end
+    end
+
+    # Add a new line to the text object. If there are no layers, the line will be added in place. If there are layers, the line will be added below the last layer.
+    # @param options [Hash] the options to create the layer with
+    def add_line(options = {})
+      @lines += 1
+      unless @layers.empty?
+        options.merge!(y: OR2D.game.entities[@layers.keys.last].y + (OR2D.game.entities[@layers.keys.last].resource.size + OR2D.scale))
+      end
+      add_layer(options)
+    end
+
+    # Set the text for a specific layer.
+    # @param text [String] the text to set
+    # @param layer_idx [Integer, Symbol] the index of the layer to set the text for
+    def set_text(text, layer_idx)
+      @layers[@layers.keys[layer_idx]][:buffer] = text.slice(0, @limit)
+      @layers[@layers.keys[layer_idx]][:cursor] = 0
+    end
+
+    # Append text to a specific layer.
+    # @param text [String] the text to append
+    # @param layer_idx [Integer, Symbol] the index of the layer to append the text to
+    def append_text(text, layer_idx)
+      return if @layers[@layers.keys[layer_idx]][:buffer].length >= @limit
+
+      @layers[@layers.keys[layer_idx]][:buffer] += text
+      @layers[@layers.keys[layer_idx]][:buffer] = @layers[@layers.keys[layer_idx]][:buffer].slice(0, @limit)
+    end
+
+    # Is the text object empty?
+    # @return [Boolean] whether the text object is empty
+    def empty?
+      @layers.empty?
+    end
+
+    # Update the text object. This works by updating the text for each layer one character at a time only on key frames determined by the update interval.
+    def update(force: false)
+      return unless force || OR2D.game.key_frame?(@update_interval)
+
+      @layers.each do |id, properties|
+        OR2D.game.entities[id].resource.text = properties[:buffer].slice(0, properties[:cursor])
+        properties[:cursor] += 1 if properties[:cursor] < properties[:buffer].length
+      end
+    end
+
+    # Show the text object. This works by showing each layer one at a time.
+    def show
+      @lines.times do |iteration|
+        if iteration == 1
+          OR2D.game.entities[@layers.keys[0]].show if @layers[@layers.keys[0]][:show]
+        elsif @layers[@layers.keys[iteration - 1]][:show]
+          OR2D.game.entities[@layers.keys[iteration - 1]].show
+        end
+      end
+    end
+
+    # Remove a layer from the text object. This works by removing the layer and adjusting the y coordinates of the remaining layers.
+    def remove_layer(id, adjust: true)
+      if adjust && @lines > 1
+        @lines.times do |index|
+          OR2D.game.entities[@layers.keys[index - 1]].y -= OR2D.game.entities[id].resource.size + OR2D.scale
+        end
+      end
+      @lines -= 1
+      super(id)
+    end
+
+    # Hide the text object. This works by hiding each layer one at a time.
+    def hide
+      @lines.times do |index|
+        OR2D.game.entities[@layers.keys[index]].hide
+      end
+    end
+
+    # Destroy the text object. This works by destroying each layer one at a time.
+    # @note This will also destroy the text object.
+    def destroy
+      @lines.times do |index|
+        OR2D.game.entities[@layers.keys[index]].destroy
+      end
+      super
+    end
+
+    private
+
+    def add_layer(options = {})
+      buffer = options[:text] || String.new
+      id = super(:text, options.merge(text: ''))
+      @layers[id][:buffer] = buffer
+      @layers[id][:cursor] = 0
+      show
+    end
+  end
+end

data/lib/or2d/console.rb

@@ -0,0 +1,199 @@
+module OR2D
+  # The Console class is used to construct Console objects that allow execution of Ruby code at runtime.
+  class Console
+
+    # @!attribute [r] display
+    # @return [OR2D::Composites::Text] the display of the Console object
+    attr_reader :display
+
+    # @!attribute [r] boundary
+    # @return [Ruby2D::Rectangle] the boundary of the Console object
+    attr_reader :boundary
+
+    # Constructs a new Console object.
+    # @param options [Hash] the options to create the console with
+    def initialize(options = {})
+      @boundary = Ruby2D::Rectangle.new(x: 0, y: -(OR2D.game.window.get(:height) / 2), z: 0,
+                                        width: OR2D.game.window.get(:width),
+                                        height: (OR2D.game.window.get(:height) / 2),
+                                        color: 'green', opacity: 0.25)
+      OR2D.game.window.add(@boundary)
+      @properties = { input_size: (8 * OR2D.scale), output_size: (4 * OR2D.scale), max_length: options[:max_length] || 24 }
+      @properties[:max_lines] = (@boundary.height / (@properties[:output_size] * OR2D.scale)).to_i - @properties[:output_size]
+
+
+      @prompt = options[:prompt] || '>> '
+      @buffer = String.new
+      @display = OR2D::Composites::Text.new
+      @display.add_line(text: 'OR2D Console', color: 'yellow', size: @properties[:output_size],
+                        x: @boundary.x + 16, y: @boundary.y + (16 * OR2D.scale), z: @boundary.z + 1)
+      @input = OR2D::Entity.new(:text, { text: @prompt, color: 'white',
+                                         x: @boundary.x + 16, y: (@boundary.y + @boundary.height) - (16 * OR2D.scale),
+                                         z: @boundary.z + 1, size: @properties[:input_size],
+                                         show: true })
+      @state = State.new(:RETRACTED, false, false)
+
+      setup_events
+    end
+
+    # Add a line of text to the console.
+    def add_line(options)
+      @display.add_line(options.merge(size: @properties[:output_size]))
+    end
+
+    # Remove the console text displays from the game instance window.
+    def remove
+      @input.destroy
+      @display.destroy
+      OR2D.game.window.remove(@boundary)
+      @descriptors.each_value { |descriptor| OR2D.game.window.off(descriptor) }
+    end
+
+    # Update the console.
+    def update
+      case @state.animation
+      when :RETRACTED
+        if @boundary.y >= -@boundary.height
+          @boundary.y -= 16
+          @input.y -= 16
+          @display.y -= 16 unless @display.empty?
+        else
+          @state.animation = :DRAWN
+          @state.drawn = false
+        end
+      when :PULL_DOWN
+        if @boundary.y <= -16 * OR2D.scale
+          @boundary.y += 16
+          @input.y += 16
+          @display.y += 16 unless @display.empty?
+        else
+          @state.animation = :DRAWN
+          @state.drawn = true
+        end
+      end
+
+      @display.update
+      @display.remove_layer(@display.layers.keys.first) if @display.layers.length > @properties[:max_lines]
+      @input.resource.text = @prompt + @buffer if @state.drawn
+      OR2D.game.window.add(@boundary)
+    end
+
+    # Retracts the console from view.
+    def retract
+      @state.animation = :RETRACTED
+    end
+
+    # Pulls the console into view.
+    def pull_down
+      @state.animation = :PULL_DOWN
+    end
+
+    private
+
+    # Contains the state of the console.
+    State = Struct.new(:animation, :drawn, :enabled) do
+
+      # Enables console input
+      def enable
+        self.enabled = true
+      end
+
+      # Disables console input
+      def disable
+        self.enabled = false
+      end
+
+      # Toggle console input
+      def toggle
+        self.enabled = !self.enabled
+      end
+    end
+
+    def setup_events
+      @descriptors = {}
+
+      @descriptors[:std_input] = OR2D.game.window.on(:key_up) do |event|
+        case event.key
+        when '`'
+          @state.toggle
+          @state.enabled ? pull_down : retract
+        end
+
+        if @state.drawn &&
+          ((!event.key.match?(/escape/) &&
+            !event.key.match?(/enter/) &&
+            !event.key.match?(/return/) &&
+            !event.key.match?(/backspace/) &&
+            !event.key.match?(/space/) &&
+            !event.key.match?(/shift/) &&
+            !event.key.match?(/control/) &&
+            !event.key.match?(/alt/) &&
+            !event.key.match?(/tab/) &&
+            !event.key.match?(/capslock/) &&
+            !event.key.match?(/pageup/) &&
+            !event.key.match?(/pagedown/) &&
+            !event.key.match?(/end/) &&
+            !event.key.match?(/home/) &&
+            !event.key.match?(/left/) &&
+            !event.key.match?(/up/) &&
+            !event.key.match?(/right/) &&
+            !event.key.match?(/down/) &&
+            !event.key.match?(/insert/) &&
+            !event.key.match?(/delete/) &&
+            !event.key.match?(/f1|f2|f3|f4|f5|f6|f7|f8|f9|f10/)) &&
+            event.key =~ /[a-zA-Z0-9]/ &&
+            (@properties[:max_length].zero? || @buffer.length < @properties[:max_length]))
+          @buffer.concat(OR2D.game.modifiers[:shift] ? event.key.capitalize : event.key)
+        end
+      end
+
+      @descriptors[:special_input] = OR2D.game.window.on(:key_up) do |event|
+        case event.key
+        when /enter|return/
+          begin
+            output = instance_eval(@buffer)
+          rescue StandardError => e
+            output = e.message
+            puts e.backtrace
+          end
+
+          @display.add_line(text: "#{@buffer} #=> #{output}", 
+                            size: @properties[:output_size], 
+                            color: 'white',
+                            show: true)
+          @buffer.clear
+        when /backspace/ then @buffer.slice!(-1)
+        when /delete/ then @buffer.clear
+        when /space/ then @buffer << ' '
+        when /-|minus|hyphen/ then @buffer << (OR2D.game.modifiers[:shift] ? '_' : '-')
+        when '\\' then @buffer << (OR2D.game.modifiers[:shift] ? '|' : '\\')
+        when '.' then @buffer << (OR2D.game.modifiers[:shift] ? '>' : '.')
+        when ',' then @buffer << (OR2D.game.modifiers[:shift] ? '<' : ',')
+        when ';' then @buffer << (OR2D.game.modifiers[:shift] ? ':' : ';')
+        when '{' then @buffer << (OR2D.game.modifiers[:shift] ? '[' : '{')
+        when '}' then @buffer << (OR2D.game.modifiers[:shift] ? ']' : '}')
+        when '[' then @buffer << (OR2D.game.modifiers[:shift] ? '{' : '[')
+        when ']' then @buffer << (OR2D.game.modifiers[:shift] ? '}' : ']')
+        when /=|equals/ then @buffer << (OR2D.game.modifiers[:shift] ? '+' : '=')
+        when "'" then @buffer << (OR2D.game.modifiers[:shift] ? '"' : "'")
+        end
+      end
+
+      # Numbers
+      @descriptors[:numeric_input] = OR2D.game.window.on(:key_up) do |event|
+        case event.key
+        when '1' then @buffer << (OR2D.game.modifiers[:shift] ? '!' : '1')
+        when '2' then @buffer << (OR2D.game.modifiers[:shift] ? '@' : '2')
+        when '3' then @buffer << (OR2D.game.modifiers[:shift] ? '#' : '3')
+        when '4' then @buffer << (OR2D.game.modifiers[:shift] ? '$' : '4')
+        when '5' then @buffer << (OR2D.game.modifiers[:shift] ? '%' : '5')
+        when '6' then @buffer << (OR2D.game.modifiers[:shift] ? '^' : '6')
+        when '7' then @buffer << (OR2D.game.modifiers[:shift] ? '&' : '7')
+        when '8' then @buffer << (OR2D.game.modifiers[:shift] ? '*' : '8')
+        when '9' then @buffer << (OR2D.game.modifiers[:shift] ? '(' : '9')
+        when '0' then @buffer << (OR2D.game.modifiers[:shift] ? ')' : '0')
+        end
+      end
+    end
+  end
+end

data/lib/or2d/entity.rb

@@ -0,0 +1,78 @@
+module OR2D
+
+  # A Entity object represents a single entity in an OR2D instance. All entities have an ID, and a natural boundary
+  # that is provided by it's parent class (i.e. Ruby2D::Rectangle). It may also have a resource that can be rendered to
+  # the screen. It is recommended to use inheritance to create new entities.
+  class Entity < Ruby2D::Rectangle
+    include OR2D::Animations::EntityAnimations
+
+    # @!attribute [r] id
+    # @return [String] the entity's ID
+    attr_reader :id
+
+    # @!attribute [r] resource
+    # @return [Ruby2D::Image, Ruby2D::Sprite, Ruby2D::Text, Ruby2D::Triangle, Ruby2D::Quad, Ruby2D::Circle, Ruby2D::Square, Ruby2D::Line, Ruby2D::Rectangle] the entity's resource
+    attr_reader :resource
+
+    # Constructs a new Entity object.
+    # @param type [Symbol] the type of entity to create
+    # @param options [Hash] the options to create the entity with
+    def initialize(type, options = {})
+      super(x: options[:x] || 0,
+            y: options[:y] || 0,
+            width: options[:width].nil? ? 1 : options[:width] * OR2D.scale,
+            height: options[:height].nil? ? 1 : options[:height] * OR2D.scale,
+            opacity: options[:show_boundary] ? 0.55 : 0.0,
+            color: 'green')
+      @id = options[:id] || SecureRandom.uuid
+      @resource = options[:resource] || OR2D::Resource.create(type, options)
+      @width = @resource.width if @resource.respond_to?(:width)
+      @height = @resource.height if @resource.respond_to?(:height)
+      show if options[:show]
+    ensure
+      OR2D.game.add_entity(self)
+    end
+
+    # Set the Entity x coordinate.
+    # @param x_coordinate [Integer] the x coordinate of the Entity on the screen
+    def x=(x_coordinate)
+      super(x_coordinate)
+      @resource.x = x_coordinate if @resource.respond_to?(:x=)
+    end
+
+    # Set the Entity y coordinate.
+    # @param y_coordinate [Integer] the y coordinate of the Entity on the screen
+    def y=(y_coordinate)
+      super(y_coordinate)
+      @resource.y = y_coordinate if @resource.respond_to?(:y=)
+    end
+
+    # Show the entity's boundary.
+    def toggle_boundary
+      @color.opacity = if @color.opacity <= 0.0
+                         0.35
+                       else
+                         0.0
+                       end
+    end
+
+    # Show the entity on the game instance window.
+    def show
+      OR2D.game.window.add(self)
+      OR2D.game.window.add(@resource) if @resource
+    end
+
+    # Hide the entity from the game instance window.
+    def hide
+      OR2D.game.window.remove(self)
+      OR2D.game.window.remove(@resource) if @resource
+    end
+
+    # Remove the entity from the game instance window, and from the game instance's entity list.
+    def destroy
+      OR2D.game.window.remove(self)
+      OR2D.game.window.remove(@resource) if @resource
+      OR2D.game.remove_entity(@id)
+    end
+  end
+end