adventure_rl 0.0.1.pre.ld42

data/lib/AdventureRL/SolidsManager.rb

@@ -0,0 +1,170 @@
+module AdventureRL
+  class SolidsManager
+    DEFAULT_SOLID_TAG = :default
+
+    DEFAULT_SETTINGS = Settings.new(
+      use_cache: false
+    )
+
+    def initialize settings = {}
+      @settings    = DEFAULT_SETTINGS.merge settings
+      @quadtrees   = {}
+      @reset_queue = {}
+      @cache       = {}
+      @use_cache   = @settings.get :use_cache
+    end
+
+    # Add one (or multiple) <tt>object</tt>(s)
+    # with one (or multiple) <tt>solid_tag</tt>(s).
+    def add_object object, solid_tag = DEFAULT_SOLID_TAG
+      objects    = [object].flatten
+      solid_tags = [solid_tag].flatten
+      solid_tags.each do |tag|
+        if (@quadtrees[tag])
+          @quadtrees[tag].add_object objects
+        else
+          @quadtrees[tag] = Quadtree.new objects: objects
+        end
+      end
+    end
+    alias_method :add, :add_object
+
+    def remove_object object, solid_tag = DEFAULT_SOLID_TAG
+      objects    = [object].flatten
+      solid_tags = [solid_tag].flatten
+      objects.each do |obj|
+        @cache.delete obj
+      end
+      get_quadtrees_for(solid_tags).each do |quadtree|
+        quadtree.remove_object objects
+      end
+    end
+    alias_method :remove, :remove_object
+
+    def remove_object_from_all_quadtrees object
+      objects    = [object].flatten
+      objects.each do |obj|
+        @cache.delete obj
+      end
+      @quadtrees.values.flatten.each do |quadtree|
+        quadtree.remove_object objects
+      end
+    end
+    alias_method :remove_from_all_quadtrees, :remove_object_from_all_quadtrees
+
+    # Returns <tt>true</tt> if the given <tt>object</tt> (or multiple objects),
+    # collide with any other objects with a mutual <tt>solid_tag</tt>.
+    def collides? object, solid_tag = DEFAULT_SOLID_TAG
+      objects    = [object].flatten
+      solid_tags = [solid_tag].flatten
+      return objects.any? do |obj|
+        handle_collides_cache_for obj, solid_tags
+        next @cache[obj][:collides?]
+      end  if (@use_cache)
+      return objects.any? do |obj|
+        next get_quadtrees_for(solid_tags).any? do |quadtree|
+          next quadtree.collides?(obj)
+        end
+      end
+    end
+
+    # Returns all objects colliding with <tt>object</tt>(s).
+    def get_colliding_objects object, solid_tag = DEFAULT_SOLID_TAG
+      objects    = [object].flatten
+      solid_tags = [solid_tag].flatten
+      return objects.map do |obj|
+        handle_colliding_objects_cache_for obj, solid_tags
+        next @cache[obj][:colliding_objects]
+      end .flatten  if (@use_cache)
+      return objects.map do |obj|
+        next get_quadtrees_for(solid_tags).map do |quadtree|
+          next quadtree.get_colliding_objects(obj)
+        end
+      end .flatten
+    end
+
+    # Pass an <tt>object</tt> (or multiple), to queue it/them for
+    # resetting next update.
+    def reset_object object, solid_tag = DEFAULT_SOLID_TAG
+      objects = [object].flatten
+      solid_tags = [solid_tag].flatten
+      solid_tags.each do |tag|
+        @reset_queue[tag] ||= []
+        @reset_queue[tag].concat objects
+      end
+    end
+
+    # Resets for every object in <tt>@reset_queue</tt>.
+    def reset
+      @reset_queue.each do |solid_tag, objects|
+        @quadtrees.map do |quadtree_tag, quadtree|
+          next quadtree  if (solid_tag == quadtree_tag)
+          next nil
+        end .compact.each do |quadtree|
+          quadtree.reset_object objects
+        end
+        @reset_queue[solid_tag] = []
+      end
+    end
+
+    def reset_cache_for object
+      @collides_cache.delete          object
+      @colliding_objects_cache.delete object
+    end
+
+    # Called once every frame by Window.
+    def update
+      reset
+    end
+
+    private
+
+      def get_quadtrees_for solid_tag = DEFAULT_SOLID_TAG
+        solid_tags = [solid_tag].flatten
+        return @quadtrees.map do |quadtree_tag, quadtree|
+          next quadtree  if (solid_tags.include?(quadtree_tag))
+          next nil
+        end .compact
+      end
+
+      def handle_collides_cache_for object, solid_tags
+        cached = @cache[object]
+        update_collides_cache_for object, solid_tags  unless (
+          # TODO: Remove cache or improve, it can break stuff
+          @use_cache &&
+          cached                                     &&
+          (cached[:position] == object.get_position) &&
+          (cached[:size]     == object.get_size)
+        )
+      end
+
+      def update_collides_cache_for object, solid_tags
+        @cache[object] ||= {}
+        @cache[object][:position]  = object.get_position.dup
+        @cache[object][:size]      = object.get_size.dup
+        @cache[object][:collides?] = get_quadtrees_for(solid_tags).any? do |quadtree|
+          next quadtree.collides?(object)
+        end
+      end
+
+      def handle_colliding_objects_cache_for object, solid_tags
+        cached = @cache[object]
+        update_colliding_objects_cache_for object, solid_tags  unless (
+          # TODO: Remove cache or improve, it can break stuff
+          @use_cache &&
+          cached                                     &&
+          (cached[:position] == object.get_position) &&
+          (cached[:size]     == object.get_size)
+        )
+      end
+
+      def update_colliding_objects_cache_for object, solid_tags
+        @cache[object] ||= {}
+        @cache[object][:position]          = object.get_position.dup
+        @cache[object][:size]              = object.get_size.dup
+        @cache[object][:colliding_objects] = get_quadtrees_for(solid_tags).map do |quadtree|
+          next quadtree.get_colliding_objects(object)
+        end .flatten
+      end
+  end
+end

data/lib/AdventureRL/Textbox.rb

@@ -0,0 +1,195 @@
+module AdventureRL
+  # This is similar to a Rectangle, but it can display text
+  # with basic formatting.
+  class Textbox < Rectangle
+    DEFAULT_SETTINGS = Settings.new(
+      text:       '',
+      font_size:  24,
+      font_name:  'MonoSpace',
+      font_color: 0xff_ffffff,
+      text_alignment: {
+        x: :center,
+        y: :center
+      },
+      border_padding: {
+        x: 16,
+        y: 8
+      },
+      border_color: 0xff_000000,
+      border_size: {
+        width:  0,
+        height: 0
+      },
+      background_color: 0xff_000000,
+      z_index: 0,
+      position: {
+        x: 0,
+        y: 0
+      },
+      size: {
+        width:  256,
+        height: 64
+      },
+      origin: {
+        x: :left,
+        y: :top
+      }
+    )
+
+    def initialize settings = {}
+      @settings = DEFAULT_SETTINGS.merge settings
+      @font_cache = {}  # This Hash will be filled with any loaded Gosu::Font (see #set_font_size)
+      set_font_size @settings.get(:font_size)
+      @text           = @settings.get :text
+      @font_color     = @settings.get :font_color
+      @text_alignment = @settings.get :text_alignment
+      @border_padding = @settings.get :border_padding
+      @border_color   = @settings.get :border_color
+      @border_size    = @settings.get :border_size
+      super @settings
+      @color_original = @settings.get :background_color
+    end
+
+    def get_text
+      return @text
+    end
+
+    def set_text text
+      @text = text.to_s
+    end
+
+    # NOTE:
+    # This method is expensive, because it loads a new Gosu::Font.
+    # Call this sparingly.
+    # Once a new Gosu::Font is created, it is cached,
+    # wo when you resize to a previously used font it will not need to load a new Gosu::Font.
+    def set_font_size size
+      @font = @font_cache[size]
+      return  if (@font)
+      @font = Gosu::Font.new(
+        size,
+        name: @settings.get(:font_name)
+      )
+      @font_cache[size] = @font
+    end
+
+    # TODO: This doesn't really work, it still takes a while to draw a Font the first time; look into this.
+    # Pass any amount of integers, which will each preload a new Gosu::Font,
+    # with the size of the integer.
+    def preload_font_sizes *sizes
+      sizes.flatten.each do |size|
+        Helpers::Error.error(
+          "Expected size to be an Integer, but got",
+          "`#{size.inspect}:#{size.class.name}'."
+        )  unless (size.is_a? Integer)
+        @font_cache[size] ||= Gosu::Font.new(
+          size,
+          name: @settings.get(:font_name)
+        )
+      end
+    end
+
+    def draw
+      draw_border
+      draw_background
+      draw_text
+      @color_temporary = nil
+    end
+
+    private
+
+      def draw_border
+        return  unless (has_border?)
+        corner = get_corner :left, :top
+        Gosu.draw_rect(
+          corner.x, corner.y,
+          get_size(:width), get_size(:height),
+          @border_color,
+          @z_index
+        )
+      end
+
+      def draw_background
+        pos  = get_position_for_background
+        size = get_size_for_background
+        Gosu.draw_rect(
+          pos.x, pos.y,
+          size[:width], size[:height],
+          get_color,
+          @z_index
+        )
+      end
+
+      def draw_text
+        pos = get_position_for_text
+        rel = get_relative_for_text
+        @font.draw_rel(
+          @text,
+          pos[:x], pos[:y], @z_index,
+          rel[:x], rel[:y],
+          1, 1,  # Scale
+          @font_color
+        )
+      end
+
+      def has_border?
+        return @border_size.values.any? do |size|
+          next size > 0
+        end
+      end
+
+      def get_position_for_background
+        corner = get_corner :left, :top
+        return corner  unless (has_border?)
+        pos = corner.dup
+        pos.set_position(
+          x: (corner.x + @border_size[:width]),
+          y: (corner.y + @border_size[:height])
+        )
+        return pos
+      end
+
+      def get_size_for_background
+        size = get_size
+        return size  unless (has_border?)
+        return {
+          width:  (size[:width]  - (@border_size[:width]  * 2)),
+          height: (size[:height] - (@border_size[:height] * 2))
+        }
+      end
+
+      def get_position_for_text
+        return [:x, :y].map do |axis|
+          alignment = @text_alignment[axis]
+          case alignment
+          when :center
+            pos = get_center axis
+          else
+            mult =  1  if ([:left,  :top].include?    alignment)
+            mult = -1  if ([:right, :bottom].include? alignment)
+            pos = (
+              (@border_size[(axis == :x) ? :width : :height] * mult) +
+              (@border_padding[axis] * mult) +
+              get_side(alignment)
+            )
+          end
+          next [axis, pos]
+        end .to_h
+      end
+
+      def get_relative_for_text
+        return [:x, :y].map do |axis|
+          alignment = @text_alignment[axis]
+          case alignment
+          when :center
+            pos = 0.5
+          when :left, :top
+            pos = 0.0
+          when :right, :bottom
+            pos = 1.0
+          end
+          next [axis, pos]
+        end .to_h
+      end
+  end
+end

data/lib/AdventureRL/TimingHandler.rb

@@ -0,0 +1,225 @@
+module AdventureRL
+  # The TimingHandler has nice methods to handle timing.
+  # It can #set_timeout or #set_interval for methods.
+  class TimingHandler
+    include Helpers::Error
+
+    def initialize
+      @queue = {
+        timeouts:  [],
+        intervals: []
+      }
+      @elapsed_seconds = 0.0
+      @deltatime = Deltatime.new
+      @is_running = true
+    end
+
+    # #update should be called every frame,
+    # this is where it checks if any methods need to be called
+    # and calls them if necessary.
+    def update
+      return  if (is_paused?)
+      handle_timeouts
+      handle_intervals
+      @elapsed_seconds += @deltatime.dt
+      @deltatime.update
+    end
+
+    def continue
+      return  if (is_running?)
+      @is_running = true
+      reset
+    end
+
+    def pause
+      return  if (is_paused?)
+      @is_running = false
+    end
+
+    def is_running?
+      return !!@is_running
+    end
+
+    def is_paused?
+      return !is_running?
+    end
+
+    # Reset the Deltatime
+    def reset
+      @deltatime.reset
+    end
+
+    # Set a timeout for a method.
+    # Call a method after a specified amount of time has passed.  
+    # The passed <tt>args</tt> Hash should include the following keys:
+    # <tt>:method</tt>::                        The method to be called. Can be one of the following:
+    #                                           - a Method                  -- <tt>method(:my_method)</tt>
+    #                                           - a Proc                    -- <tt>Proc.new { puts 'My method!' }</tt>
+    #                                           - a method name as a Symbol -- <tt>:my_method</tt>
+    # <tt>:seconds</tt> _or_ <tt>:secs</tt>::   Integer or Float. The time to wait in seconds, before calling the method.
+    # <tt>:arguments</tt> _or_ <tt>:args</tt>:: Optional Array of arguments, which will be passed to the target method.
+    # <tt>:id</tt>::                            Optional value which can be used to remove the timeout afterwards. See #remove_timeout.
+    # You can also pass a block to the method,
+    # which will be used instead of the <tt>:method</tt> key's value.
+    def set_timeout args = {}, &block
+      validate_args args, !!block
+      _args = get_unified_args args, &block
+      at    = get_time_in _args[:seconds]
+      @queue[:timeouts] << {
+        method:    _args[:method],
+        at:        at,
+        arguments: _args[:arguments],
+        id:        _args[:id]
+      }
+    end
+    alias_method :in, :set_timeout
+
+    # Set an interval for a method.
+    # Call a method in regular intervals.  
+    # The passed <tt>args</tt> Hash should include the following keys:
+    # <tt>:method</tt>::                        The method to be called. Can be one of the following:
+    #                                           - a Method                  -- <tt>method(:my_method)</tt>
+    #                                           - a Proc                    -- <tt>Proc.new { puts 'My method!' }</tt>
+    #                                           - a method name as a Symbol -- <tt>:my_method</tt>
+    # <tt>:seconds</tt> _or_ <tt>:secs</tt>::   Integer or Float. The time to wait in seconds, before calling the method.
+    # <tt>:arguments</tt> _or_ <tt>:args</tt>:: Optional Array of arguments, which will be passed to the target method.
+    # <tt>:id</tt>::                            Optional value which can be used to remove the interval afterwards. See #remove_interval.
+    # You can also pass a block to the method,
+    # which will be used instead of the <tt>:method</tt> key's value.
+    def set_interval args = {}, &block
+      validate_args args, !!block
+      _args = get_unified_args args, &block
+      at    = get_time_in _args[:seconds]
+      @queue[:intervals] << {
+        method:    _args[:method],
+        interval:  _args[:seconds],
+        at:        at,
+        arguments: _args[:arguments],
+        id:        _args[:id]
+      }
+    end
+    alias_method :every, :set_interval
+
+    # If you passed an <tt>:id</tt> to your timeout when you set it with #set_timeout,
+    # then you can remove / clear it before it executes by calling this method and
+    # passing the same <tt>id</tt>.
+    def remove_timeout id
+      @queue[:timeouts].reject! do |timeout|
+        next timeout[:id] == id
+      end
+    end
+    alias_method :clear_timeout, :remove_timeout
+
+    # If you passed an <tt>:id</tt> to your interval when you set it with #set_interval,
+    # then you can remove / clear it by calling this method and
+    # passing the same <tt>id</tt>.
+    # If you did _not_ pass an <tt>id</tt>, then your interval will be running endlessly!
+    def remove_interval id
+      @queue[:intervals].reject! do |interval|
+        next interval[:id] == id
+      end
+    end
+    alias_method :clear_interval, :remove_interval
+
+    # Returns <tt>true</tt> if the given <tt>id</tt> exists as a timeout,
+    # and <tt>false</tt> if not.
+    def has_timeout? id
+      return @queue[:timeouts].any? do |timeout|
+        next timeout[:id] == id
+      end
+    end
+
+    # Returns <tt>true</tt> if the given <tt>id</tt> exists as an interval,
+    # and <tt>false</tt> if not.
+    def has_interval? id
+      return @queue[:intervals].any? do |interval|
+        next interval[:id] == id
+      end
+    end
+
+    private
+
+      def handle_timeouts
+        current_seconds = get_elapsed_seconds
+        @queue[:timeouts].reject! do |timeout|
+          next false  unless (current_seconds >= timeout[:at])
+          timeout[:method].call *timeout[:arguments]
+          next true
+        end
+      end
+
+      def handle_intervals
+        current_seconds = get_elapsed_seconds
+        @queue[:intervals].each do |interval|
+          next  unless (current_seconds >= interval[:at])
+          interval[:method].call *interval[:arguments]
+          interval[:at] = get_time_in interval[:interval]
+        end
+      end
+
+      def validate_args args, block_given = false
+        error(
+          "Passed argument must be a Hash."
+        )  unless (args.is_a? Hash)
+        unless (block_given)
+          error(
+            "Passed args Hash must include the key `:method'."
+          )  unless (args.key? :method)
+          method_class = args[:method].class
+          error(
+            "Key `:method' must be a Method, Proc, or Symbol, but is a `#{method_class.name}'"
+          )  unless ([Method, Proc, Symbol].include? method_class)
+        end
+        error(
+          "Passed args Hash must include the key `:seconds' or `:secs'."
+        )  unless (args.key?(:seconds) || args.key?(:secs))
+        seconds_key   = :secs     if (args.key? :secs)
+        seconds_key   = :seconds  if (args.key? :seconds)
+        seconds_class = args[seconds_key].class
+        error(
+          "Key `:#{seconds_key.to_s}' must be an Integer or Float, but is a `#{seconds_class.name}'"
+        )  unless ([Integer, Float].include? seconds_class)
+        if (args.key?(:arguments) || args.key?(:args))
+          arguments_key   = :args       if (args.key? :args)
+          arguments_key   = :arguments  if (args.key? :arguments)
+          arguments_class = args[arguments_key].class
+          error(
+            "Key `:#{arguments_key.to_s}' must be an Array, but is a `#{arguments_class.name}'"
+          )  unless (arguments_class == Array)
+        end
+      end
+
+      def get_unified_args args, &block
+        prc = get_proc_from(block || args[:method])
+        return {
+          method:    prc,
+          seconds:   args[:seconds]   || args[:secs],
+          arguments: args[:arguments] || args[:args] || [],
+          id:        args[:id]
+        }
+      end
+
+      def get_proc_from meth
+        prc = nil
+        if    (meth.is_a? Method)
+          prc = meth.to_proc
+        elsif (meth.is_a? Proc)
+          prc = meth
+        elsif (meth.is_a? Symbol)
+          error(
+            "Method `:#{meth.to_s}' is not available in this scope."
+          )  unless (methods.include? meth)
+          prc = method(meth).to_proc
+        end
+        return prc
+      end
+
+      def get_time_in seconds
+        return get_elapsed_seconds + seconds
+      end
+
+      def get_elapsed_seconds
+        return @elapsed_seconds
+      end
+  end
+end