adventure_rl 0.0.1.pre.ld42

data/lib/AdventureRL/Point.rb

@@ -0,0 +1,188 @@
+module AdventureRL
+  class Point
+    # This array will be filled with any created Points.
+    # Just so they won't get garbage collected
+    # <em>(not sure how garbage collection works)</em>.
+    POINTS = []
+
+    # Initialize with two arguments:
+    # <tt>x</tt>:: x position
+    # <tt>y</tt>:: y position
+    # <tt>args = {}</tt>:: Optional hash with extra options.
+    #                      Currently, the only valid hash key is <tt>:assign_to</tt>,
+    #                      to assign this Point to an object upon initialization.
+    def initialize x, y, args = {}
+      POINTS << self
+      @position = {
+        x: x,
+        y: y
+      }
+      @assigned_to = []
+      assign_to args[:assign_to]  if (args[:assign_to])
+      @layer      = nil
+      @real_point = nil
+    end
+
+    def assign_to object
+      Helpers::PipeMethods.pipe_methods_from object, to: self
+      @assigned_to << object
+    end
+
+    # Returns all objects this Point was assigned to.
+    def get_assigned
+      return @assigned_to
+    end
+
+    # Returns true if the Point has been
+    # assigned to the passed <tt>object</tt>.
+    def assigned_to? object
+      return @assigned_to.include? object
+    end
+
+    # Returns self.
+    def get_point
+      return self
+    end
+
+    def has_point?
+      return true
+    end
+
+    def x
+      return get_position :x
+    end
+
+    def y
+      return get_position :y
+    end
+
+    def get_position target = :all
+      target = target.to_sym
+      return @position          if (target == :all)
+      return @position[target]  if (@position.keys.include?(target))
+      return nil
+    end
+
+    # Set the new position with the given arguments.
+    # <tt>args</tt> may be:
+    #   Two integers, representing the <tt>x</tt> and <tt>y</tt> axes, respectively.
+    #   A hash containing one or both of the keys <tt>:x</tt> and <tt>:y</tt>.
+    def set_position *args
+      @real_point = nil
+      new_position = parse_position *args
+      @position[:x] = new_position[:x]  if (new_position.key? :x)
+      @position[:y] = new_position[:y]  if (new_position.key? :y)
+      return get_position
+    end
+    alias_method :move_to, :set_position
+
+    # Move the Point relative to the given arguments.
+    # <tt>args</tt> may be:
+    #   Two integers, representing the <tt>x</tt> and <tt>y</tt> axes, respectively.
+    #   A hash containing one or both of the keys <tt>:x</tt> and <tt>:y</tt>.
+    def move_by *args
+      @real_point = nil
+      incremental_position = parse_position *args
+      @position[:x] += incremental_position[:x]  if (incremental_position.key? :x)
+      @position[:y] += incremental_position[:y]  if (incremental_position.key? :y)
+      return get_position
+    end
+
+    def collides_with? other
+      return collides_with_mask?  other  if (defined? other.has_mask?)
+      return collides_with_point? other  if (defined? other.has_point?)
+      return collides_with_hash?  other  if (other.is_a?(Hash))
+    end
+
+    def collides_with_mask? mask
+      return mask.collides_with_point? self
+    end
+
+    def collides_with_point? point
+      return get_real_position == point.get_real_position
+    end
+
+    def collides_with_hash? hash
+      if (hash.keys.include_all?(:x, :y))
+        point = Point.new hash[:x], hash[:y]
+        return collides_with_point? point
+      end
+      return nil
+    end
+
+    def keys
+      sorted_keys = [:x, :y]
+      return @position.keys.sort do |axis|
+        next sorted_keys.index axis
+      end
+    end
+
+    def values
+      return @position.sort_by_keys(keys).values
+    end
+
+    # Set the parent Layer.
+    def set_layer layer
+      error(
+        "Passed argument `layer' must be an instance of `Layer', but got",
+        "`#{layer.inspect}:#{layer.class.name}'."
+      )  unless (layer.is_a? Layer)
+      @layer = layer
+    end
+
+    # Returns the parent Layer.
+    def get_layer
+      return @layer
+    end
+
+    # Returns true if this Point has a parent Layer.
+    def has_layer?
+      return !!@layer
+    end
+
+    # Returns a new Point with the real window position of this Point.
+    def get_real_point
+      return self         unless (has_layer?)
+      return @real_point  if (@real_point)
+      layer_point = get_layer.get_real_corner :left, :top
+      @real_point = Point.new(
+        (layer_point.x + x),
+        (layer_point.y + y)
+      )
+      return @real_point
+    end
+
+    # Returns the real window position of this Point as a Hash.
+    def get_real_position
+      return get_real_point.get_position
+    end
+
+    private
+
+      def parse_position *args
+        position = {}
+        args[0] = args[0].get_position  if (args[0].is_a? Point)
+        case args.size
+        when 2
+          position[:x] = args[0]
+          position[:y] = args[1]
+        when 1
+          Helpers::Error.error(
+            "Ambiguous argument `#{args[0]}' for Point##{__method__}"
+          )  unless (args[0].is_a?(Hash))
+          Helpers::Error.error(
+            "Hash must include either :x, :y, or both keys for Point##{__method__}"
+          )  unless (args[0].keys.include_any?(:x, :y))
+          position[:x] = args[0][:x]  if (args[0][:x])
+          position[:y] = args[0][:y]  if (args[0][:y])
+        else
+          Helpers::Error.error(
+            "Invalid amount of arguments for Point##{__method__}.",
+            "Pass either two arguments representing the x and y axes, respectively, or",
+            "pass a single hash with the keys :x and :y with their respective axes values."
+          )
+        end
+        return position
+      end
+  end
+end

data/lib/AdventureRL/Quadtree.rb

@@ -0,0 +1,237 @@
+module AdventureRL
+  class Quadtree < Mask
+    include Helpers::MethodHelper
+
+    DEFAULT_SETTINGS = Settings.new(
+      max_objects: 4,
+      position: {
+        x: 0,
+        y: 0
+      },
+      size: {
+        width:  960,
+        height: 540
+      },
+      origin: {
+        x: :left,
+        y: :top
+      }
+    )
+
+    def self.get_default_settings
+      window = Window.get_window
+      return Settings.new(
+        position: (window ? window.get_position : DEFAULT_SETTINGS.get(:window, :position) || DEFAULT_SETTINGS[:position]),
+        size:     (window ? window.get_size     : DEFAULT_SETTINGS.get(:window, :size)     || DEFAULT_SETTINGS[:size]),
+        origin:   (window ? window.get_origin   : DEFAULT_SETTINGS.get(:window, :origin)   || DEFAULT_SETTINGS[:origin]),
+      )
+    end
+
+    def initialize settings = {}
+      @settings = DEFAULT_SETTINGS.merge(Quadtree.get_default_settings).merge(settings)
+      super @settings
+      @max_objects     = @settings.get :max_objects
+      @quadtrees = {
+        top_left:     nil,
+        top_right:    nil,
+        bottom_left:  nil,
+        bottom_right: nil
+      }
+      @objects = []
+      add_object [@settings.get(:objects)].flatten.compact
+    end
+
+    # Add the given Mask <tt>object</tt>(s) into the Quadtree,
+    # and split into smaller quadtrees if necessary.
+    def add_object object
+      objects = [object].flatten
+      objects.each do |obj|
+        validate_object_has_mask_or_point obj
+        add_object_to_quadtree obj
+      end
+    end
+    alias_method :add, :add_object
+
+    def add_object_to_quadtree object
+      return false  unless (collides_with? object)
+      return false  if     (@objects.include? object)
+
+      if (@objects.size < @max_objects)
+        @objects << object
+        return true
+      end
+
+      split_quadtrees  unless (has_quadtrees?)
+
+      return get_quadtrees.map do |quadtree|
+        next quadtree.add_object_to_quadtree(object)
+      end .any?
+    end
+
+    # Returns <tt>true</tt> if the given <tt>object</tt>
+    # collides with any other object and <tt>false</tt> if not.
+    def collides? object
+      validate_object_has_mask_or_point object
+      return collides_for?(object)
+    end
+
+    def collides_for? object
+      return false  unless (collides_with? object)
+      return (
+        @objects.any? do |obj|
+          next obj != object && obj.collides_with?(object)
+        end ||
+        get_quadtrees.any? do |quadtree|
+          next quadtree.collides_for?(object)
+        end
+      )
+    end
+
+    # Returns all objects, that collide with <tt>object</tt>.
+    def get_colliding_objects object
+      validate_object_has_mask_or_point object
+      return get_colliding_objects_for(object)
+    end
+
+    def get_colliding_objects_for object
+      colliding_objects = []
+      return colliding_objects  unless (collides_with? object)
+      colliding_objects.concat(@objects.select do |obj|
+        next obj != object && obj.collides_with?(object)
+      end)
+      get_quadtrees.each do |quadtree|
+        colliding_objects.concat quadtree.get_colliding_objects_for(object)
+      end
+      return colliding_objects
+    end
+
+    # Reset this and all child Quadtrees.
+    # Removes all stored objects.
+    def reset
+      @objects.clear
+      get_quadtrees.each &:reset
+    end
+
+    # Remove and (try to) re-add the given <tt>object</tt>(s) (single or multiple).
+    def reset_object object
+      objects = [object].flatten
+      objects.each do |obj|
+        @objects.delete obj
+        add_object_to_quadtree obj
+      end
+    end
+
+    # Remove the given <tt>object</tt>(s) (single or multiple) from the Quadtree (or any children).
+    def remove_object object
+      objects = [object].flatten
+      objects.each do |obj|
+        @objects.delete obj
+        get_quadtrees.each do |quadtree|
+          quadtree.remove_object obj
+        end
+      end
+    end
+
+    private
+
+      def validate_object_has_mask_or_point object
+        object.has_point?  rescue error(  # NOTE: #has_point? method must be available for both Point and Mask
+          "Expected an instance of Mask/Point or an object that has a Mask/Point, but got",
+          "`#{object.inspect}:#{object.class.name}'."
+        )
+      end
+
+      # Returns all the children Quadtrees.
+      def get_quadtrees
+        return @quadtrees.values.compact
+      end
+
+      # Returns <tt>true</tt> if this Quadtree has already been split
+      # and has children Quadtrees.
+      def has_quadtrees?
+        return @quadtrees.values.all?
+      end
+
+      def split_quadtrees
+        @quadtrees = @quadtrees.keys.map do |corner|
+          new_quadtree = get_split_quadtree_for_corner corner
+          next [corner, new_quadtree]  if (new_quadtree)
+          next nil
+        end .compact.to_h
+        #move_objects_to_quadtrees  if (@objects.any?)  # NOTE: Doing this will break stuff.
+      end
+
+      def get_split_quadtree_for_corner corner
+        method_name = "get_split_quadtree_#{corner.to_s}".to_sym
+        error(
+          "Method `#{method_name.to_s}' doesn't exist for `#{self.inspect}:#{self.class}'."
+        )  unless (method_exists? method_name)
+        return method(method_name).call
+      end
+
+      def get_split_quadtree_top_left
+        return Quadtree.new(Settings.new(
+          position:    get_position,
+          size:        get_size.map do |side, size|
+            next [side, (size.to_f * 0.5).round]
+          end .to_h,
+          origin:      get_origin,
+          max_objects: @max_objects
+        ))
+      end
+
+      def get_split_quadtree_top_right
+        return Quadtree.new(Settings.new(
+          position:    get_position.map do |axis, pos|
+            next [axis, pos + (get_size(:width).to_f * 0.5).round]  if (axis == :x)
+            next [axis, pos]
+          end .to_h,
+          size:        get_size.map do |side, size|
+            next [side, (size.to_f * 0.5).round]
+          end .to_h,
+          origin:      get_origin,
+          max_objects: @max_objects
+        ))
+      end
+
+      def get_split_quadtree_bottom_left
+        return Quadtree.new(Settings.new(
+          position:    get_position.map do |axis, pos|
+            next [axis, pos + (get_size(:height).to_f * 0.5).round]  if (axis == :y)
+            next [axis, pos]
+          end .to_h,
+          size:        get_size.map do |side, size|
+            next [side, (size.to_f * 0.5).round]
+          end .to_h,
+          origin:      get_origin,
+          max_objects: @max_objects
+        ))
+      end
+
+      def get_split_quadtree_bottom_right
+        return Quadtree.new(Settings.new(
+          position:    get_position.map do |axis, pos|
+            next [axis, pos + (get_size(:width).to_f  * 0.5).round]  if (axis == :x)
+            next [axis, pos + (get_size(:height).to_f * 0.5).round]  if (axis == :y)
+          end .to_h,
+          size:        get_size.map do |side, size|
+            next [side, (size.to_f * 0.5).round]
+          end .to_h,
+          origin:      get_origin,
+          max_objects: @max_objects
+        ))
+      end
+
+      # NOTE: Shouldn't be used, breaks stuff currently.
+      #       Life is easier without this method.
+      def move_objects_to_quadtrees
+        return  if (@objects.empty?)
+        @objects.each do |object|
+          get_quadtrees.detect do |quadtree|
+            next quadtree.add_object_to_quadtree(object)
+          end
+        end
+        @objects.clear
+      end
+  end
+end

data/lib/AdventureRL/Rectangle.rb

@@ -0,0 +1,62 @@
+module AdventureRL
+  class Rectangle < Mask
+    include Helpers::Error
+
+    # Default settings for Rectangle.
+    # <tt>settings</tt> passed to #new take precedence.
+    DEFAULT_SETTINGS = Settings.new(
+      color:   0xff_ffffff,
+      z_index: 0,
+      position: {
+        x: 0,
+        y: 0
+      },
+      size: {
+        width:  128,
+        height: 128
+      },
+      origin: {
+        x: :left,
+        y: :top
+      }
+    )
+
+    # Initialize with a Settings object <tt>settings</tt>.
+    def initialize settings = {}
+      @settings = DEFAULT_SETTINGS.merge settings
+      super @settings
+      @color           = nil
+      @color_temporary = nil
+      @color_original  = @settings.get :color
+      @z_index         = @settings.get :z_index
+    end
+
+    def set_color color
+      @color = color
+    end
+
+    # Set the color only for the next frame.
+    def set_temporary_color color
+      @color_temporary = color
+    end
+
+    def get_color
+      return @color_temporary || @color || @color_original
+    end
+
+    def reset_color
+      @color = nil
+    end
+
+    def draw
+      corner = get_corner :left, :top
+      Gosu.draw_rect(
+        corner.x, corner.y,
+        get_size(:width), get_size(:height),
+        get_color,
+        @z_index
+      )
+      @color_temporary = nil
+    end
+  end
+end

data/lib/AdventureRL/Settings.rb

@@ -0,0 +1,80 @@
+module AdventureRL
+  class Settings
+    include Helpers::Error
+    attr_reader :content
+
+    # Initialize Settings with either a string representing
+    # a path to a YAML file, or a hash with your settings.
+    def initialize arg
+      if    ([String, Pathname].include? arg.class)
+        @file = Pathname.new arg
+        validate_file_exists @file
+        @content = get_file_content(@file).keys_to_sym
+      elsif (arg.is_a? Hash)
+        @content = arg.keys_to_sym
+      elsif (arg.is_a? Settings)
+        @content = arg.get
+      end
+    end
+
+    # Returns the settings, following the structure of the passed <tt>keys</tt>.
+    # Similar to <tt>Hash#dig</tt>
+    def get *keys
+      current_content = @content
+      keys.each do |key|
+        key = key.to_sym  if (key.is_a? String)
+        if (current_content.is_a?(Hash) && !current_content[key].nil?)
+          current_content = current_content[key]
+        else
+          current_content = nil
+          break
+        end
+      end
+      return current_content
+    end
+
+    # Merge self Settings content with other_settings Settings content or Hash.
+    # Can pass unlimited optional arguments as keys.
+    # If <tt>keys</tt> are given, then it will only merge the content
+    # from the keys <tt>keys</tt> for both Settings instances.
+    # Returns a new Settings object where the values of the <tt>keys</tt> keys
+    # are its settings content.
+    def merge other_settings, *keys
+      merged_settings = nil
+      if    (other_settings.is_a? Settings)
+        merged_settings = Settings.new get(*keys).merge(other_settings.get(*keys))
+      elsif (other_settings.is_a? Hash)
+        merged_settings = Settings.new get(*keys).merge(other_settings)
+      else
+        error(
+          "Argument needs to be an instance of `AdventureRL::Settings' or a Hash",
+          "but got a `#{other_settings.class.name}'"
+        )
+      end
+      return merged_settings
+    end
+
+    def each
+      return get.each
+    end
+
+    private
+
+      def validate_file_exists file = @file
+        error_no_file file  unless (file_exists? file)
+      end
+
+      def get_file_content file = @file
+        file = Pathname.new file  unless (file.is_a? Pathname)
+        begin
+          return YAML.load_file(file.to_path) || {}
+        rescue
+          begin
+            return JSON.parse(file.read, symbolize_names: true)
+          rescue
+            error "Couldn't load settings file: '#{file.to_path}'", 'Is it a valid YAML or JSON file?'
+          end
+        end
+      end
+  end
+end