adventure_rl 0.0.1.pre.ld42

data/lib/AdventureRL/Modifiers/Inventory.rb

@@ -0,0 +1,104 @@
+module AdventureRL
+  module Modifiers
+    module Inventory
+      DEFAULT_INVENTORY_ID = :NO_NAME
+
+      def initialize *args
+        @inventory = {}
+        super
+      end
+
+      # Add any object to this Inventory.
+      # Pass an optional <tt>id</tt>, which can be used to
+      # access or remove the object afterwards.
+      def add_object object, id = DEFAULT_INVENTORY_ID
+        @inventory[id] = []  unless (@inventory[id])
+        @inventory[id] << object
+      end
+      alias_method :add_item, :add_object
+      alias_method :add,      :add_object
+      alias_method :<<,       :add_object
+
+      # Returns true, if object with <tt>id</tt> has been added to this Inventory.
+      # <tt>id</tt> can also be the object itself.
+      def added_object? id
+        return (
+          @inventory.key?(id) ||
+          get_objects.include?(id)
+        )
+      end
+      alias_method :added_item?, :added_object?
+      alias_method :added?,      :added_object?
+      alias_method :has?,        :added_object?
+
+      # Returns all its objects.
+      # If optional argument <tt>id</tt> is passed,
+      # then return all objects with that <tt>id</tt>.
+      def get_objects id = nil
+        return @inventory.values.flatten  unless (id)
+        return @inventory[id]
+      end
+
+      # Returns the _last_ object with the given <tt>id</tt>.
+      # If no <tt>id</tt> is passed, return the last object with the unnamed <tt>id</tt>.
+      def get_object id = DEFAULT_INVENTORY_ID
+        return @inventory[id].last
+      end
+      alias_method :get, :get_object
+
+      # Removes all objects with the given <tt>id</tt>.
+      # <tt>id</tt> can also be an added object itself;
+      # all objects with the same <tt>id</tt> will be removed.
+      # If no <tt>id</tt> is given, remove _all_ objects.
+      def remove_objects id = nil
+        unless (id)
+          get_objects.each do |object|
+            object.removed  if (object.methods.include? :removed)
+          end
+          return @inventory.clear
+        end
+        if (@inventory.key? id)
+          objects = @inventory.delete(id)
+          objects.each do |object|
+            object.removed  if (object.methods.include? :removed)
+          end
+          return objects
+        end
+        return @inventory.delete((@inventory.detect do |key, val|
+          if (id == val)
+            @inventory[key].each do |object|
+              object.removed  if (object.methods.include? :removed)
+            end
+            next true
+          end
+          next false
+        end || []).first)
+      end
+
+      # Removes the _last_ object with the given <tt>id</tt>.
+      # <tt>id</tt> can also be the object to be removed itself.
+      # If no <tt>id</tt> is given, remove the _last_ object with the unnamed <tt>id</tt>.
+      def remove_object id = DEFAULT_INVENTORY_ID, call_removed_method = true
+        if (@inventory.key? id)
+          object = @inventory[id].delete_at(-1)
+          object.removed  if (call_removed_method && object.methods.include?(:removed))
+          return object
+        end
+        key = (@inventory.detect do |k, val|
+          next val.include?(id)
+        end || []) .first
+        return nil  unless (@inventory.key? key)
+        object = @inventory[key].delete id
+        object.removed  if (call_removed_method && object.methods.include?(:removed))
+        return object
+      end
+      alias_method :remove, :remove_object
+
+      # When removed is called on an object that has an Inventory,
+      # then also call #remove_objects on that object.
+      def removed
+        remove_objects
+      end
+    end
+  end
+end

data/lib/AdventureRL/Modifiers/Pusher.rb

@@ -0,0 +1,61 @@
+module AdventureRL
+  module Modifiers
+    # A Modifiers::Pusher is a Modifers::Solid Mask,
+    # which has the ability to __push other solid Masks__ (that are _not static_)
+    # out of the way when moving with #move_by.
+    module Pusher
+      #include AdventureRL::Modifiers::Solid  # NOTE: This modifier relies on Modifiers::Solid
+
+      # Overwrite Modifiers::Solid#move_by to add the
+      # <tt>:pushed_by_pusher</tt> option.
+      # This skips pushing the Pusher that pushed this Pusher,
+      # to avoid an endless pushing of Pushers, where one Pusher
+      # pushes the other Pusher before that Pusher pushes the first Pusher, ...
+      def move_by *args
+        return  if (is_static?)
+
+        if (args.last.is_a?(Hash))
+          @pushed_by_pusher = [args.last[:pushed_by_pusher], self].flatten.reject { |x| !x }
+        else
+          @pushed_by_pusher = [self]
+        end
+        super
+        @pushed_by_pusher = false
+      end
+
+      private
+
+        def move_by_handle_collision_with_previous_position previous_position
+          colliding_objects = get_colliding_objects
+          if (colliding_objects.any?)
+            if (colliding_objects.any? &:is_static?)
+              @position = previous_position
+              return false
+            end
+            direction = get_position_difference_from previous_position
+            if (push_objects(colliding_objects, direction))
+              return true
+            else
+              @position = previous_position
+              return false
+            end
+          end
+          return true
+        end
+
+        def get_position_difference_from previous_position
+          return get_position.map do |axis, position|
+            next [axis, (position - previous_position[axis])]
+          end .to_h
+        end
+
+        def push_objects objects, direction
+          direction[:precision_over_performance] = @precision_over_performance
+          return objects.all? do |object|
+            next true  if (@pushed_by_pusher && @pushed_by_pusher.include?(object))
+            next object.move_by(direction.merge(pushed_by_pusher: @pushed_by_pusher))
+          end
+        end
+    end
+  end
+end

data/lib/AdventureRL/Modifiers/Solid.rb

@@ -0,0 +1,302 @@
+module AdventureRL
+  module Modifiers
+    # This module is supposed to be <tt>include</tt>d in Mask child classes.
+    # It will tag that Mask instance as <tt>'solid'</tt>,
+    # and check collision with other solid Masks when calling #move_by.
+    # You can give it a specific <tt>solid_tag</tt>, which can be passed as
+    # the <tt>:solid_tag</tt> key's value upon initialization.
+    # Multiple solid tags may be passed as an array.
+    # Solid Masks will only collide with other Solid Masks that have a mutual solid tag.
+    # The default solid tag is <tt>:default</tt>.
+    module Solid
+      # NOTE: possible <tt>:precision_over_performance</tt> values:
+      # :low (or anything other than the higher values)::
+      #   Lowest precision, highest performance.
+      #   Never check every pixel between previous and new positions.
+      #   If there is collision at new position, jump to previous position and return.
+      #   The larger the movement steps, the more distance there will be to the colliding object.
+      #   - -- __CANNOT__ fully close gaps to Solids.
+      #   - -- __CAN__ phase through Solids at high speeds (especially when it lags).
+      #   - -- __CAN__ get stuck in place temporarily when moving on both axes but only colliding on one of them.
+      #   - + Only __one collision check__ per call to #move_by, highest performance.
+      #
+      # :medium::
+      #   Medium precision, medium (varying) performance.
+      #   Only checks every pixel in path if the expected destination collides.
+      #   Even then, collision checking is used somewhat sparingly.
+      #   - -- __CAN__ phase through Solids at high speeds (especially when it lags).
+      #   - -- __CAN__ get stuck in place temporarily when moving on both axes but only colliding on one of them.
+      #   - + __CAN__ _almost_ fully close gaps to Solids (no sub-pixel collision checks).
+      #
+      # :high::
+      #   High precision, low to medium (varying) performance.
+      #   Only checks every pixel in path if the expected destination collides.
+      #   When checking every pixel in path, check both axes separately, to improve precision.
+      #   - -- __CAN__ phase through Solids at high speeds (especially when it lags).
+      #   - + __CANNOT__ get stuck in place temporarily when moving on both axes but only colliding on one of them.
+      #   - + __CAN__ fully close gaps to Solids.
+      #
+      # :highest::
+      #   Highest precision, least performance.
+      #   Always check every pixel between previous and new positions.
+      #   Depending on the amount of (moving) Solid objects on screen,
+      #   - -- Depending on the amount of (moving) Solids,
+      #     this can get very laggy at high speeds                    =>
+      #     lag produces larger steps (usually), because of Deltatime =>
+      #     larger steps produce more collision checks and more lag.
+      #   - + __CANNOT__ phase through Solids, no matter what the speed is.
+      #   - + __CANNOT__ get stuck in place temporarily when moving on both axes but only colliding on one of them.
+      #   - + __CAN__ fully close gaps to Solids.
+      DEFAULT_SOLID_SETTINGS = Settings.new(
+        solid_tag:                  SolidsManager::DEFAULT_SOLID_TAG,
+        solid_tag_collides_with:    nil,
+        precision_over_performance: :medium,
+        static:                     false,
+        auto_update:                false
+      )
+
+      # Additionally to the Mask's settings Hash or Settings instance,
+      # you may pass the extra key <tt>:solid_tag</tt>, to define
+      # a custom solid tag (or multiple solid tags) upon initialization.
+      # They are used for collision checking with other Solid Mask objects
+      # that have a mutual solid tag.
+      def initialize settings = {}
+        @settings                   = DEFAULT_SOLID_SETTINGS.merge settings
+        @solid_tags                 = [@settings.get(:solid_tag)].flatten.sort
+        @solid_tags_collides_with   = [@settings.get(:solid_tag_collides_with) || @solid_tags].flatten.sort
+        @solid_static               = @settings.get :static  # Basically disables #move_by
+        @precision_over_performance = @settings.get :precision_over_performance
+        assign_to_solids_manager  if (@settings.get :auto_update)
+        super @settings
+      end
+
+      def add_to_solids_manager solids_manager
+        Helpers::Error.error(
+          "Expected argument to be a SolidsManager, but got",
+          "'#{solids_manager.inspect}:#{solids_manager.class.name}`."
+        )  unless (solids_manager.is_a? SolidsManager)
+        @solids_manager = solids_manager
+        @solids_manager.add_object self, get_solid_tags
+      end
+
+      # Overwrite #set_layer method, so we can get the SolidsManager
+      # from the Layer, if it has one.
+      def set_layer layer
+        super
+        assign_to_solids_manager  if (@settings.get :auto_update)
+      end
+
+      # This method is called when this object is removed from an Inventory.
+      def removed
+        remove_from_solids_manager
+      end
+
+      # When it is removed, also remove it from the SolidsManager.
+      # TODO: Do this properly.
+      def remove_from_solids_manager
+        #@solids_manager.remove_object self, [get_solid_tags, get_solid_tags_collides_with].flatten  if (@solids_manager)
+        @solids_manager.remove_object_from_all_quadtrees self  if (@solids_manager)
+      end
+
+      # Overwrite #move_by method, so that collision checking with other objects
+      # with a mutual solid tag is done, and movement prevented if necessary.
+      def move_by *args
+        return false  if     (is_static?)
+        return super  unless (@solids_manager)
+
+        @real_point = nil
+        previous_position = get_position.dup
+        incremental_position = parse_position(*args)
+        expected_position = {
+          x: (previous_position[:x] + (incremental_position.key?(:x) ? incremental_position[:x] : 0)),
+          y: (previous_position[:y] + (incremental_position.key?(:y) ? incremental_position[:y] : 0))
+        }
+
+        # NOTE:
+        # This is a bit of a hacky workaround for some
+        # weird Pusher behavior with Velocity and Gravity.
+        previous_precision_over_performance = @precision_over_performance.dup
+        opts = args.last.is_a?(Hash) ? args.last : nil
+
+        @precision_over_performance = opts[:precision_over_performance]  if (opts.key? :precision_over_performance)
+
+        if ([:highest].include? @precision_over_performance)
+          move_by_steps incremental_position
+        else
+          @position[:x] += incremental_position[:x]  if (incremental_position.key? :x)
+          @position[:y] += incremental_position[:y]  if (incremental_position.key? :y)
+
+          # TODO
+          #puts 'PUSHING'  if (is_a?(Player) && opts && opts[:pushed_by_pusher])
+
+          unless (move_by_handle_collision_with_previous_position previous_position)
+            move_by_steps incremental_position  if ([:medium, :high].include? @precision_over_performance)
+          end
+        end
+
+        @precision_over_performance = previous_precision_over_performance
+        @solids_manager.reset_object self, get_solid_tags  unless (@position == previous_position)
+        return @position == expected_position
+      end
+
+      # Overwrite the #move_to method, so we can
+      # reset the object for the solids_manager if necessary.
+      def move_to *args
+        previous_position = get_position.dup
+        super
+        return  unless (@solids_manager)
+        @solids_manager.reset_object self, get_solid_tags  if (@position != previous_position)
+      end
+
+      # Returns <tt>true</tt> if this Mask is currently in collision
+      # with another solid Mask which has a mutual solid tag.
+      # TODO: Write documentation for callback method.
+      def in_collision?
+        if (@solids_manager)
+          is_colliding = @solids_manager.collides?(self, get_solid_tags_collides_with)
+        else
+          is_colliding = false
+        end
+        is_colliding  if (is_colliding && methods.include?(:is_colliding))
+        return is_colliding
+      end
+
+      # Returns all currently colliding objects (if any).
+      # TODO: Write documentation for callback method.
+      def get_colliding_objects
+        if (@solids_manager)
+          colliding_objects = @solids_manager.get_colliding_objects(self, get_solid_tags_collides_with)
+        else
+          colliding_objects = []
+        end
+        is_colliding_with_objects colliding_objects  if (colliding_objects.any? && methods.include?(:is_colliding_with_objects))
+        return colliding_objects
+      end
+
+      # Makes this Solid Mask static.
+      def make_static
+        @solid_static = true
+      end
+
+      # Returns <tt>true</tt> if this is a static solid Mask,
+      # which means it cannot be moved with #move_by.
+      def is_static?
+        return !!@solid_static
+      end
+
+      def set_solid_tags *new_solid_tags
+        @solids_manager.remove_object self, get_solid_tags  if (@solids_manager)
+        @solid_tags = [new_solid_tags].flatten.compact
+        @solids_manager.add_object self,    get_solid_tags  if (@solids_manager)
+      end
+
+      def set_solid_tags_collides_with *new_solid_tags_collides_with
+        @solid_tags_collides_with = [new_solid_tags_collides_with].flatten.compact
+      end
+
+      # Returns this Mask's solid tags,
+      # which other Masks use to check collision against _this_ Mask.
+      def get_solid_tags
+        return @solid_tags
+      end
+
+      # Returns the solid tags,
+      # which this Mask uses to check collision against _other_ Masks.
+      def get_solid_tags_collides_with
+        return @solid_tags_collides_with || @solid_tags
+      end
+
+      private
+
+        def assign_to_solids_manager
+          layer = get_layer
+          return  unless (layer && layer.has_solids_manager?)
+          @solids_manager = layer.get_solids_manager
+          @solids_manager.add_object self, get_solid_tags  if (@solids_manager)
+        end
+
+        # This is the ugliest method in the project.
+        # I can live with there being __one__ ugly method.
+        # Also, it _does_ do some complicated stuff, so cut it some slack.
+        # It didn't ask to be this way.
+        def move_by_steps incremental_position
+          incremental_position[:x] ||= 0
+          incremental_position[:y] ||= 0
+
+          larger_axis = :x  if (incremental_position[:x].abs >= incremental_position[:y].abs)
+          larger_axis = :y  if (incremental_position[:y].abs >  incremental_position[:x].abs)
+          smaller_axis = (larger_axis == :x) ? :y : :x
+          larger_axis_sign  = incremental_position[larger_axis].sign
+          smaller_axis_sign = incremental_position[smaller_axis].sign
+          smaller_axis_increment_at = (incremental_position[larger_axis].abs.to_f / incremental_position[smaller_axis].abs.to_f).round  rescue nil
+          remaining_values = {
+            larger_axis  => ((incremental_position[larger_axis].abs  % 1) * larger_axis_sign),
+            smaller_axis => ((incremental_position[smaller_axis].abs % 1) * smaller_axis_sign),
+          }
+
+          return  unless (move_by_steps_for_remaining_values remaining_values)
+
+          # NOTE
+          # We use #to_i here, because a negative float's #floor method decreases its value. Example:
+          #   1.75.floor   # =>  1.0
+          #   -1.75.floor  # => -2.0
+          #   1.75.to_i    # =>  1.0
+          #   -1.75.to_i   # => -1.0
+          incremental_position[larger_axis].to_i.abs.times do |axis_index|
+            initial_previous_position = @position.dup
+
+            tmp_in_collision_count = 0
+
+            previous_position = @position.dup
+            @position[larger_axis] += larger_axis_sign
+            tmp_in_collision_count += 1  unless (
+              move_by_handle_collision_with_previous_position(previous_position)
+            )  if ([:high, :highest].include? @precision_over_performance)
+
+            if (smaller_axis_increment_at &&
+                (((axis_index + 1) % smaller_axis_increment_at) == 0)
+               )
+              previous_position = @position.dup
+              @position[smaller_axis] += smaller_axis_sign
+              tmp_in_collision_count += 1  unless (
+                move_by_handle_collision_with_previous_position(previous_position)
+              )  if ([:high, :highest].include? @precision_over_performance)
+            end
+
+            return  unless (tmp_in_collision_count < 2)
+            if ([:medium].include? @precision_over_performance)
+              return  unless (move_by_handle_collision_with_previous_position initial_previous_position)
+            end
+          end
+        end
+
+        def move_by_steps_for_remaining_values remaining_values
+          return true  unless ([:high, :highest].include? @precision_over_performance)
+          return true  if     (remaining_values.values.all? { |val| val == 0 })
+          tmp_in_collision_count = 0
+          remaining_values.each do |remaining_axis, remaining_value|
+            next  if (remaining_value == 0)
+            previous_position = @position.dup
+            @position[remaining_axis] += remaining_value
+            remaining_values[remaining_axis] = 0
+            unless (move_by_handle_collision_with_previous_position previous_position)
+              tmp_in_collision_count += 1
+              next  # break
+            end
+          end
+          return false  if (tmp_in_collision_count == 2)  # NOTE: Slight performance improvement
+          return true
+        end
+
+        # Returns <tt>true</tt> if there was no collision, and
+        # returns <tt>false</tt> if there was and it had to reset to the <tt>previous_position</tt>.
+        def move_by_handle_collision_with_previous_position previous_position
+          if (in_collision?)
+            @position = previous_position
+            return false
+          end
+          return true
+        end
+    end
+  end
+end

data/lib/AdventureRL/Modifiers/Velocity.rb

@@ -0,0 +1,163 @@
+module AdventureRL
+  module Modifiers
+    module Velocity
+      DEFAULT_VELOCITY_SETTINGS = Settings.new(
+        # Does NOT use Deltatime
+        max_velocity: {
+          x: 100,
+          y: 100
+        },
+        # DOES use Deltatime
+        velocity_decay: {
+          x: 750,
+          y: 750
+        },
+        # Does NOT use Deltatime
+        base_velocity: {
+          x: 0,
+          y: 0
+        },
+        quick_turn_around: false
+      )
+
+      def initialize settings = {}
+        @settings = DEFAULT_VELOCITY_SETTINGS.merge settings
+        @velocity = {
+          x: 0.0,
+          y: 0.0
+        }
+        @max_velocity_original      = @settings.get :max_velocity
+        @max_velocity               = @max_velocity_original.dup
+        @velocity_decay             = @settings.get :velocity_decay
+        @velocity_quick_turn_around = @settings.get :quick_turn_around
+        @base_velocity              = @settings.get :base_velocity
+        @velocity_deltatime         = Deltatime.new
+        @has_increased_velocity_for = {
+          x: false,
+          y: false
+        }
+        super @settings
+      end
+
+      # Returns the velocity.
+      # Pass an optional <tt>target</tt> argument,
+      # which can be either an axis (<tt>:x</tt> or <tt>:y</tt>),
+      # or <tt>:all</tt>, which will return a Hash with both values.
+      def get_velocity target = :all
+        target = target.to_sym
+        return @velocity          if (target == :all)
+        return @velocity[target]  if (@velocity.keys.include?(target))
+        return nil
+      end
+
+      # Returns the max velocity.
+      # Pass an optional <tt>target</tt> argument,
+      # which can be either an axis (<tt>:x</tt> or <tt>:y</tt>),
+      # or <tt>:all</tt>, which will return a Hash with both values.
+      def get_max_velocity target = :all
+        target = target.to_sym
+        return @max_velocity          if (target == :all)
+        return @max_velocity[target]  if (@max_velocity.keys.include?(target))
+        return nil
+      end
+
+      def set_velocity *args
+        new_velocity = parse_position *args
+        @velocity[:x] = new_velocity[:x]  if (new_velocity.key? :x)
+        @velocity[:y] = new_velocity[:y]  if (new_velocity.key? :y)
+      end
+
+      # Increase the velocity.
+      # <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 increase_velocity_by *args
+        opts = {}
+        opts = args.last  if (args.last.is_a? Hash)
+        quick_turn_around = @velocity_quick_turn_around
+        quick_turn_around = opts[:quick_turn_around]  unless (opts[:quick_turn_around].nil?)
+        incremental_velocity = parse_position *args
+        @velocity.keys.each do |axis|
+          next  unless (incremental_velocity.key? axis)
+          velocity_sign = @velocity[axis].sign
+          incremental_velocity_sign = incremental_velocity[axis].sign
+          @velocity[axis]  = 0  unless (velocity_sign == incremental_velocity_sign)  if (quick_turn_around && !opts[:no_quick_turn_around])
+          @velocity[axis]  = @base_velocity[axis] * incremental_velocity_sign        if (@velocity[axis] == 0)
+          @velocity[axis] += incremental_velocity[axis]
+          case velocity_sign
+          when 1
+            @velocity[axis] = get_max_velocity(axis)   if (@velocity[axis] > get_max_velocity(axis))
+          when -1
+            @velocity[axis] = -get_max_velocity(axis)  if (@velocity[axis] < -get_max_velocity(axis))
+          end
+          @has_increased_velocity_for[axis] = true
+        end
+      end
+      alias_method :add_velocity, :increase_velocity_by
+
+      def set_max_velocity *args
+        new_max_velocity = parse_position *args
+        @max_velocity_original.keys.each do |axis|
+          @max_velocity_original[axis] = new_max_velocity[axis]  if (new_max_velocity.key? axis)
+        end
+        @max_velocity = @max_velocity_original.dup
+      end
+
+      def set_temporary_max_velocity *args
+        new_max_velocity = parse_position *args
+        @max_velocity.keys.each do |axis|
+          @max_velocity[axis] = new_max_velocity[axis]  if (new_max_velocity.key? axis)
+        end
+      end
+
+      # Resets the max velocity to the original values.
+      def reset_max_velocity
+        @max_velocity = @max_velocity_original.dup
+      end
+
+      # Call this every frame to move with the stored velocity.
+      def move
+        move_by get_incremental_position_for_velocity  if (any_velocity?)
+        decrease_velocity
+        @has_increased_velocity_for = {
+          x: false,
+          y: false
+        }
+        @velocity_deltatime.update
+      end
+
+      private
+
+        # Returns <tt>true</tt> if there is any stored velocity,
+        # for any axis.
+        def any_velocity?
+          return @velocity.values.any? do |velocity|
+            next velocity != 0
+          end
+        end
+
+        def get_incremental_position_for_velocity
+          return get_velocity.map do |axis, speed|
+            next [axis, speed * @velocity_deltatime.dt]
+          end .to_h
+        end
+
+        # Decrease the velocity, based on the decay rate
+        # and deltatime.
+        def decrease_velocity
+          return  unless (any_velocity?)
+          @velocity.keys.each do |axis|
+            next  if (@velocity[axis] == 0 || @has_increased_velocity_for[axis])
+            case @velocity[axis].sign
+            when 1
+              @velocity[axis] -= @velocity_decay[axis] * @velocity_deltatime.dt
+              @velocity[axis]  = 0  if (@velocity[axis] < 0)
+            when -1
+              @velocity[axis] += @velocity_decay[axis] * @velocity_deltatime.dt
+              @velocity[axis]  = 0  if (@velocity[axis] > 0)
+            end
+          end
+        end
+    end
+  end
+end