adventure_rl 0.0.1.pre.ld42

data/lib/AdventureRL/Mask.rb

@@ -0,0 +1,462 @@
+module AdventureRL
+  # The Mask is basically a bounding box or rectangle.
+  # It has a position (Point) and a size.
+  class Mask < Point
+    include Helpers::MethodHelper
+
+    # This array will be filled with any created Masks.
+    # Just so they won't get garbage collected
+    # <em>(not sure how garbage collection works)</em>.
+    MASKS = []
+
+    # Default settings for Mask.
+    # Are superseded by settings passed to <tt>#initialize</tt>.
+    DEFAULT_SETTINGS = Settings.new({
+      position: {
+        x: 0,
+        y: 0
+      },
+      size: {
+        width:  64,
+        height: 64
+      },
+      origin: {
+        x: :left,
+        y: :top
+      },
+      assign_to: nil
+    })
+
+    # Pass settings Hash or <tt>AdventureRL::Settings</tt> as argument.
+    # Supersedes <tt>DEFAULT_SETTINGS</tt>.
+    def initialize settings_arg = {}
+      MASKS << self
+      settings = DEFAULT_SETTINGS.merge settings_arg
+      super *settings.get(:position).values
+      @size             = settings.get(:size)
+      @origin           = settings.get(:origin)
+      @assigned_to    = []
+      assign_to settings.get(:assign_to)  if (settings.get(:assign_to))
+      @layer            = nil
+      call_setup_method settings_arg
+    end
+
+    # Assign this Mask to an instance.
+    # This will make all Mask methods available as
+    # a fallback on the instance itself.
+    # This also gives the possibility to define event methods
+    # on the <tt>object</tt>.
+    def assign_to object
+      Helpers::PipeMethods.pipe_methods_from object, to: self
+      @assigned_to << object
+    end
+
+    # Returns all objects this Mask was assigned to.
+    def get_assigned
+      return @assigned_to
+    end
+
+    # Returns true if the Mask has been
+    # assigned to the passed <tt>object</tt>.
+    def assigned_to? object
+      return @assigned_to.include? object
+    end
+
+    # Returns self.
+    # Used to get an instance's mask when it has been assigned to it.
+    def get_mask
+      return self
+    end
+
+    # Returns <tt>true</tt>.
+    # Used to verify if an instance has a Mask assigned to it.
+    def has_mask?
+      return true
+    end
+
+    # Returns the size of the Mask.
+    # Can pass an optional <tt>target</tt> argument,
+    # which can be either an axis (<tt>:width</tt> or <tt>:height</tt>),
+    # or <tt>:all</tt>, which returns a Hash with both values.
+    def get_size target = :all
+      target = target.to_sym
+      return @size          if (target == :all)
+      return @size[target]  if (@size.key?(target))
+      return nil
+    end
+
+    # Set a new Mask size.
+    # <tt>args</tt> are very similar to Point#set_position,
+    # only that the axes (<tt>:x</tt> and <tt>:y</tt>) are replaced with
+    # <tt>:width</tt> and <tt>:height</tt>.
+    def set_size *args
+      new_size = parse_size(*args)
+      @size[:width]  = new_size[:width]   if (new_size.key? :width)
+      @size[:height] = new_size[:height]  if (new_size.key? :height)
+    end
+    alias_method :resize, :set_size
+
+    # Returns the set origin.
+    # Can 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 returns a Hash with both values.
+    def get_origin target = :all
+      target = target.to_sym
+      return @origin          if (target == :all)
+      return @origin[target]  if (@origin.key?(target))
+      return nil
+    end
+
+    # Returns the position Integer of a specific side.
+    # Takes one mandatory argument, <tt>side</tt>,
+    # which can be one of the following:
+    # <tt>:left</tt> or <tt>:right</tt>::
+    #   Returns the x position of the left or right side/border, respectively.
+    # <tt>:top</tt> or <tt>:bottom</tt>::
+    #   Returns the y position of the top or bottom side/border, respectively.
+    def get_side side
+      side = side.to_sym
+      case side
+      when :left
+        return get_side_left
+      when :right
+        return get_side_right
+      when :top
+        return get_side_top
+      when :bottom
+        return get_side_bottom
+      else
+        return nil
+      end
+    end
+
+    # Returns the real window position of <tt>side</tt>.
+    # See #get_side for usage.
+    def get_real_side side
+      axis = :x  if ([:left, :right].include? side)
+      axis = :y  if ([:top, :bottom].include? side)
+      side_pos  = get_side(side) * get_scale(axis)
+      return side_pos  unless (has_layer?)
+      case side
+      when :left, :right
+        return get_layer.get_real_side(:left) + side_pos
+      when :top, :bottom
+        return get_layer.get_real_side(:top) + side_pos
+      else
+        return nil
+      end
+    end
+
+    # Returns the positions of all four sides.
+    def get_sides
+      return {
+        left:   get_side(:left),
+        right:  get_side(:right),
+        top:    get_side(:top),
+        bottom: get_side(:bottom)
+      }
+    end
+
+    # Returns the real window positions of all four sides.
+    def get_real_sides
+      return {
+        left:   get_real_side(:left),
+        right:  get_real_side(:right),
+        top:    get_real_side(:top),
+        bottom: get_real_side(:bottom)
+      }
+    end
+
+    # Returns a Point with the position of a specific corner.
+    # Takes two mandatory arguments:
+    # <tt>side_x</tt>:: Either <tt>:left</tt> or <tt>:right</tt>.
+    # <tt>side_y</tt>:: Either <tt>:top</tt> or <tt>:bottom</tt>.
+    def get_corner side_x, side_y
+      side_x = side_x.to_sym
+      side_y = side_y.to_sym
+      return Point.new(
+        get_side(side_x),
+        get_side(side_y)
+      )  unless ([side_x, side_y].include? :center)
+      if    (side_x == side_y)
+        center = get_center.values
+        return Point.new(*center)
+      elsif (side_x == :center)
+        return Point.new(
+          get_center(:x),
+          get_side(side_y)
+        )
+      elsif (side_y == :center)
+        return Point.new(
+          get_side(side_x),
+          get_center(:y)
+        )
+      end
+      return nil
+    end
+
+    # Returns the real window position of the corner.
+    # See #get_corner for usage.
+    def get_real_corner side_x, side_y
+      side_x = side_x.to_sym
+      side_y = side_y.to_sym
+      return Point.new(
+        get_real_side(side_x),
+        get_real_side(side_y)
+      )  unless ([side_x, side_y].include? :center)
+      if    (side_x == side_y)
+        center = get_real_center.values
+        return Point.new(*center)
+      elsif (side_x == :center)
+        return Point.new(
+          get_real_center(:x),
+          get_real_side(side_y)
+        )
+      elsif (side_y == :center)
+        return Point.new(
+          get_real_side(side_x),
+          get_real_center(:y)
+        )
+      end
+      return nil
+    end
+
+    # Returns the center Point of the Mask.
+    # An optional <tt>target</tt> argument can be passed,
+    # which can either be an axis (<tt>:x</tt> or <tt>:y</tt>),
+    # or <tt>:all</tt>, which returns a Hash with both values.
+    def get_center target = :all
+      target = target.to_sym
+      return Point.new(
+        get_center_x,
+        get_center_y
+      )  if (target == :all)
+      return method("get_center_#{target.to_s}".to_sym).call  if (get_point.keys.include? target)
+      return nil
+    end
+
+    # Returns the real window position of this center.
+    # See #get_center for usage.
+    def get_real_center target = :all
+      scale = get_scale
+      side = :left  if (target == :x)
+      side = :top   if (target == :y)
+      return Point.new(
+        (get_real_side(:left) + (get_center_x * scale[:x])),
+        (get_real_side(:top)  + (get_center_y * scale[:y]))
+      )  if (target == :all)
+      return (
+        get_real_side(side) + (method("get_center_#{target.to_s}".to_sym).call * scale[target])
+      )  if (get_point.keys.include? target)
+      return nil
+    end
+
+    # Returns true if this Mask collides with <tt>other</tt> ...
+    # - Mask,
+    # - Point,
+    # - or Hash with keys <tt>:x</tt> and <tt>:y</tt>.
+    def collides_with? other
+      return collides_with_mask?  other  if (other.has_mask?  rescue false)
+      return collides_with_point? other  if (other.has_point? rescue false)
+      return collides_with_hash?  other  if (other.is_a?(Hash))
+    end
+
+    # Returns true if this Mask collides with <tt>other</tt> Mask.
+    def collides_with_mask? mask, checked = false
+      this_sides  = get_real_sides
+      other_sides = mask.get_real_sides
+      return (
+        (
+          (
+            other_sides[:left] >= this_sides[:left] &&
+            other_sides[:left] <= this_sides[:right]
+          ) || (
+            other_sides[:right] >= this_sides[:left] &&
+            other_sides[:right] <= this_sides[:right]
+          ) || (
+            other_sides[:left]  <= this_sides[:left] &&
+            other_sides[:right] >= this_sides[:right]
+          )
+        ) && (
+          (
+            other_sides[:top] >= this_sides[:top] &&
+            other_sides[:top] <= this_sides[:bottom]
+          ) || (
+            other_sides[:bottom] >= this_sides[:top] &&
+            other_sides[:bottom] <= this_sides[:bottom]
+          ) || (
+            other_sides[:top]    <= this_sides[:top] &&
+            other_sides[:bottom] >= this_sides[:bottom]
+          )
+        )
+      ) || (!checked && mask.collides_with_mask?(self, true))
+    end
+
+    # Returns true if this Mask collides with <tt>other</tt> Point.
+    def collides_with_point? point
+      real_point = point.get_real_point
+      real_sides = get_real_sides
+      return (
+        real_point.x >= real_sides[:left]  &&
+        real_point.x <= real_sides[:right] &&
+        real_point.y >= real_sides[:top]   &&
+        real_point.y <= real_sides[:bottom]
+      )
+    end
+
+    # Returns true if this Mask collides with <tt>other</tt> Hash.
+    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
+
+    # 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 Mask has a parent Layer.
+    def has_layer?
+      return !!@layer
+    end
+
+    private
+
+      def call_setup_method args
+        return  unless (method_exists?(:setup))
+        if (method_takes_arguments?(:setup))
+          setup args
+        else
+          setup
+        end
+      end
+
+      def call_method_on_assigned method_name, *args
+        get_assigned.each do |assigned_to|
+          meth = nil
+          meth = assigned_to.method(method_name)  if (assigned_to.methods.include?(method_name))
+          meth.call(*args)                        if (meth)
+        end
+      end
+
+      def parse_size *args
+        size = {}
+        case args.size
+        when 2
+          size[:width]  = args[0]
+          size[:height] = args[1]
+        when 1
+          Helpers::Error.error(
+            "Ambiguous argument `#{args[0]}' for Mask##{__method__}"
+          )  unless (args[0].is_a?(Hash))
+          Helpers::Error.error(
+            "Hash must include either :width, :height, or both keys for Mask##{__method__}"
+          )  unless (args[0].keys.include_any?(:width, :height))
+          size[:width]  = args[0][:width]   if (args[0][:width])
+          size[:height] = args[0][:height]  if (args[0][:height])
+        else
+          Helpers::Error.error(
+            "Invalid amount of arguments for Mask##{__method__}.",
+            "Pass either two arguments representing the width and height axes, respectively, or",
+            "pass a single hash with the keys :width and :height with their respective axes values."
+          )
+        end
+        return size
+      end
+
+      # Returns this Masks Layer scale, if it has one.
+      def get_scale target = :all
+        return get_layer.get_real_scale target  if (has_layer?)
+        scale = { x: 1.0, y: 1.0 }
+        return scale[target]  if (scale.key? target)
+        return scale          if (target == :all)
+        return nil
+      end
+
+      def get_side_left
+        case get_origin(:x)
+        when :left
+          return get_position(:x)
+        when :right
+          return get_position(:x) - get_size(:width)
+        when :center
+          return get_position(:x) - (get_size(:width) * 0.5)
+        else
+          return nil
+        end
+      end
+
+      def get_side_right
+        case get_origin(:x)
+        when :left
+          return get_position(:x) + get_size(:width)
+        when :right
+          return get_position(:x)
+        when :center
+          return get_position(:x) + (get_size(:width) * 0.5)
+        else
+          return nil
+        end
+      end
+
+      def get_side_top
+        case get_origin(:y)
+        when :top
+          return get_position(:y)
+        when :bottom
+          return get_position(:y) - get_size(:height)
+        when :center
+          return get_position(:y) - (get_size(:height) * 0.5)
+        else
+          return nil
+        end
+      end
+
+      def get_side_bottom
+        case get_origin(:y)
+        when :top
+          return get_position(:y) + get_size(:height)
+        when :bottom
+          return get_position(:y)
+        when :center
+          return get_position(:y) + (get_size(:height) * 0.5)
+        else
+          return nil
+        end
+      end
+
+      def get_center_x
+        case get_origin(:x)
+        when :left
+          return get_position(:x) + (get_size(:width) * 0.5)
+        when :right
+          return get_position(:x) - (get_size(:width) * 0.5)
+        when :center
+          return get_position(:x)
+        end
+      end
+
+      def get_center_y
+        case get_origin(:y)
+        when :top
+          return get_position(:y) + (get_size(:height) * 0.5)
+        when :bottom
+          return get_position(:y) - (get_size(:height) * 0.5)
+        when :center
+          return get_position(:y)
+        end
+      end
+  end
+end

data/lib/AdventureRL/Menu.rb

@@ -0,0 +1,92 @@
+module AdventureRL
+  class Menu < Layer
+    # This Array will be filled with creaed Menus.
+    MENUS = []
+
+    def self.button_down btnid
+      get_active_menus.each do |menu|
+        menu.button_down btnid
+      end
+    end
+    def self.button_up btnid
+      get_active_menus.each do |menu|
+        menu.button_up btnid
+      end
+    end
+    def self.update
+      get_active_menus.each(&:update)
+    end
+    def self.get_active_menus
+      return MENUS.select(&:is_active?)
+    end
+
+    DEFAULT_SETTINGS = Settings.new(
+      active:         false,
+      auto_update:    false,
+      mouse_buttons_event_handler: {
+        auto_update:        false,
+        only_mouse_buttons: true
+      }
+    )
+
+    def initialize settings = {}
+      @settings = DEFAULT_SETTINGS.merge settings
+      @mouse_buttons_event_handler = EventHandlers::MouseButtons.new @settings.get(:mouse_buttons_event_handler)
+      super @settings
+      @active = @settings.get :active
+      MENUS << self  if (@settings.get(:auto_update))
+    end
+
+    # Overwrite #add_object method, so we can
+    # validate, that the given <tt>object</tt> is a Button.
+    def add_object object, id = DEFAULT_INVENTORY_ID
+      #Helpers::Error.error(
+      #  "Expected given object to be a Button, but got",
+      #  "'#{object.inspect}:#{object.class.name}`."
+      #)  unless (object.is_a? Button)
+      super
+      @mouse_buttons_event_handler.subscribe object  if (object.is_a? Button)
+    end
+    alias_method :add_button, :add_object
+    alias_method :add_item,   :add_object
+    alias_method :add,        :add_object
+    alias_method :<<,         :add_object
+
+    def activate
+      @active = true
+    end
+
+    def deactivate
+      @active = false
+    end
+
+    def is_active?
+      return !!@active
+    end
+
+    def is_inactive?
+      return !is_active?
+    end
+
+    def button_down btnid
+      return  if (is_inactive?)
+      @mouse_buttons_event_handler.button_down btnid
+    end
+
+    def button_up btnid
+      return  if (is_inactive?)
+      @mouse_buttons_event_handler.button_up btnid
+    end
+
+    def update
+      return  if (is_inactive?)
+      @mouse_buttons_event_handler.update
+      super
+    end
+
+    def draw
+      return  if (is_inactive?)
+      super
+    end
+  end
+end

data/lib/AdventureRL/Modifiers/Gravity.rb

@@ -0,0 +1,60 @@
+module AdventureRL
+  module Modifiers
+    module Gravity
+      #include AdventureRL::Modifiers::Velocity  # NOTE: This modifier relies on Modifiers::Velocity
+
+      DEFAULT_GRAVITY_SETTINGS = Settings.new(
+        gravity_force:     1000.0,
+        gravity_direction: {
+          x: 0.0,
+          y: 1.0
+        }
+      )
+
+      def initialize settings = {}
+        @settings          = DEFAULT_GRAVITY_SETTINGS.merge settings
+        @gravity           = 0.0
+        @gravity_force     = @settings.get :gravity_force
+        @gravity_direction = @settings.get :gravity_direction
+        #@max_velocity = @max_velocity_original.dup
+        super @settings
+        @max_velocity_original[:y] = Float::INFINITY
+        @max_velocity[:y]          = @max_velocity_original[:y].dup
+        @velocity_decay[:y]        = 0
+      end
+
+      # Apply gravitational force.
+      def gravitize
+        previous_position = get_position.dup
+        get_gravity_directions.each do |axis, multiplier|
+          next  if (@has_increased_velocity_for[axis])
+          set_position axis => (get_position(axis) + multiplier)  unless (multiplier == 0)
+          if (in_collision?)
+            @velocity[axis] = 0.0
+          else  #if ([0, @gravity_direction[axis].sign].include? get_velocity(axis).sign)
+            increase_velocity_by(
+              axis => ((@gravity_force * @gravity_direction[axis]) * @velocity_deltatime.dt),
+              no_quick_turn_around: true
+            )
+          end
+          set_position previous_position
+        end
+      end
+
+      # Overwrite Modifiers::Velocity#move,
+      # so we can update the gravity.
+      def move
+        super
+        gravitize
+      end
+
+      private
+
+        def get_gravity_directions
+          return @gravity_direction.select do |axis, value|
+            next value != 0
+          end
+        end
+    end
+  end
+end