chingu 0.5.5.3

data/lib/chingu/require_all.rb

@@ -0,0 +1,133 @@
+#--
+# Copyright (C)2009 Tony Arcieri
+# You can redistribute this under the terms of the MIT license
+# See file LICENSE for details
+#++
+
+module RequireAll
+  # A wonderfully simple way to load your code.
+  #
+  # The easiest way to use require_all is to just point it at a directory
+  # containing a bunch of .rb files.  These files can be nested under 
+  # subdirectories as well:
+  #
+  #  require_all 'lib'
+  #
+  # This will find all the .rb files under the lib directory and load them.
+  # The proper order to load them in will be determined automatically.
+  #
+  # If the dependencies between the matched files are unresolvable, it will 
+  # throw the first unresolvable NameError.
+  #
+  # You can also give it a glob, which will enumerate all the matching files: 
+  #
+  #  require_all 'lib/**/*.rb'
+  #
+  # It will also accept an array of files:
+  #
+  #  require_all Dir.glob("blah/**/*.rb").reject { |f| stupid_file(f) }
+  # 
+  # Or if you want, just list the files directly as arguments:
+  #
+  #  require_all 'lib/a.rb', 'lib/b.rb', 'lib/c.rb', 'lib/d.rb'
+  #
+  def require_all(*args)
+    # Handle passing an array as an argument
+    args.flatten!
+    
+    if args.size > 1
+      # If we got a list, those be are files!
+      files = args
+    else
+      arg = args.first
+      begin
+        # Try assuming we're doing plain ol' require compat
+        stat = File.stat(arg)
+        
+        if stat.file?
+          files = [arg]
+        elsif stat.directory?
+          files = Dir.glob File.join(arg, '**', '*.rb')
+        else
+          raise ArgumentError, "#{arg} isn't a file or directory"
+        end
+      rescue Errno::ENOENT
+        # If the stat failed, maybe we have a glob!
+        files = Dir.glob arg
+        
+        # Maybe it's an .rb file and the .rb was omitted
+        if File.file?(arg + '.rb')
+          require(arg + '.rb')
+          return true
+        end
+        
+        # If we ain't got no files, the glob failed
+        raise LoadError, "no such file to load -- #{arg}" if files.empty?
+      end
+    end
+
+    # If there's nothing to load, you're doing it wrong!
+    raise LoadError, "no files to load" if files.empty?
+    
+    files.map! { |file| File.expand_path file }
+            
+    begin
+      failed = []
+      first_name_error = nil
+      
+      # Attempt to load each file, rescuing which ones raise NameError for
+      # undefined constants.  Keep trying to successively reload files that 
+      # previously caused NameErrors until they've all been loaded or no new
+      # files can be loaded, indicating unresolvable dependencies.
+      files.each do |file|
+        begin
+          require file
+        rescue NameError => ex
+          failed << file
+          first_name_error ||= ex
+        rescue ArgumentError => ex
+          # Work around ActiveSuport freaking out... *sigh*
+          #
+          # ActiveSupport sometimes throws these exceptions and I really
+          # have no idea why.  Code loading will work successfully if these
+          # exceptions are swallowed, although I've run into strange 
+          # nondeterministic behaviors with constants mysteriously vanishing.
+          # I've gone spelunking through dependencies.rb looking for what 
+          # exactly is going on, but all I ended up doing was making my eyes 
+          # bleed.
+          #
+          # FIXME: If you can understand ActiveSupport's dependencies.rb 
+          # better than I do I would *love* to find a better solution
+          raise unless ex.message["is not missing constant"]
+          
+          STDERR.puts "Warning: require_all swallowed ActiveSupport 'is not missing constant' error"
+          STDERR.puts ex.backtrace[0..9]
+        end
+      end
+      
+      # If this pass didn't resolve any NameErrors, we've hit an unresolvable
+      # dependency, so raise one of the exceptions we encountered.
+      if failed.size == files.size
+        raise first_name_error
+      else
+        files = failed
+      end
+    end until failed.empty?
+    
+    true
+  end
+  
+  # Works like require_all, but paths are relative to the caller rather than 
+  # the current working directory
+  def require_rel(*paths)
+    # Handle passing an array as an argument
+    paths.flatten!
+    
+    source_directory = File.dirname caller.first.sub(/:\d+$/, '')
+    paths.each do |path|
+      require_all File.join(source_directory, path)
+    end
+  end
+end
+
+include RequireAll

data/lib/chingu/text.rb

@@ -0,0 +1,56 @@
+module Chingu
+  #
+  # Text is a class to give the use of Gosu::Font more rubyish feel and fit it better into Chingu.
+  # Pure Gosu:
+  #   @font = Gosu::Font.new($window, "verdana", 30)
+  #   @font.draw("A Text", 200, 50, 55, 2.0)
+  #
+  # Chingu
+  #   @text = Chingu::Text.new(:text => "A Text", :x => 200, :y => 50, :zorder => 55, :factor_x => 2.0)
+  #   @text.draw  # usually not needed as Text is a GameObject and therefore autodrawn
+  #
+  # @text comes with a number of changable properties, x,y,zorder,angle,factor_x,color,mode etc.
+  #
+  class Text < Chingu::GameObject
+    attr_accessor :text
+    attr_reader :height, :gosu_font
+
+    @@size = nil
+    @@font = nil
+    def self.font; @@font; end
+    def self.font=(value); @@font = value; end
+
+    def self.size; @@size; end
+    def self.size=(value); @@size = value; end
+    def self.height; @@size; end
+    def self.height=(value); @@size = value; end
+    
+    #
+    # Takes the standard GameObject-hash-arguments but also:
+    # - :text             - a string of text
+    # - :font_name|:font  - name of a systemfont (default: "verdana")
+    # - :height|size      - how many pixels high should the text be
+    #
+    def initialize(options)
+      super(options)
+      @text = options[:text] || "-No text specified-"
+      @font =  options[:font] || @@font || default_font_name()
+      @height = options[:height] || options[:size] || @@size || 15
+      
+      @gosu_font = Gosu::Font.new($window, @font, @height)
+    end
+    
+    def draw
+      @gosu_font.draw_rot(@text, @x.to_i, @y.to_i, @zorder, @angle, @factor_x, @factor_y, @color, @mode)
+    end
+    
+    #
+    # Returns the width, in pixels, the given text would occupy if drawn.
+    #
+    def width
+      @gosu_font.text_width(@text, @factor_x)
+    end
+
+  end
+  
+end

data/lib/chingu/traits/collision_detection.rb

@@ -0,0 +1,172 @@
+#--
+#
+# Chingu -- Game framework built on top of the opengl accelerated gamelib Gosu
+# Copyright (C) 2009 ippa / ippa@rubylicio.us
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#++
+
+
+module Chingu
+  module Traits
+    #
+    # Research:
+    # 1) QuadTrees: http://lab.polygonal.de/2007/09/09/quadtree-demonstration/
+    # 2) Sweep and Prune
+    #
+    # SEE: http://www.shmup-dev.com/forum/index.php?board=65.0
+    #
+    # Makes use of 3 attributes
+    #   @bounding_box      - a Rect-instance, uses in bounding_box collisions
+    #   @radius            -
+    #   @detect_collisions - [true|false], should object be checked for collisions with Object.each_collision
+    #
+    module CollisionDetection
+      attr_accessor :bounding_box, :radius
+      ## attr_accessor :detect_collisions # slowed down example9 with 3 fps
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      #
+      # Automaticly try to set a bounding_box and radius. Don't overwrite if they already exists.
+      #
+      def setup_trait(options)
+        if @x and @y and @image
+          @bounding_box ||= Rect.new(@x, @y, @image.width, @image.height)
+        end
+        
+        if @image
+          @radius ||= (@image.height + @image.width) / 2 * 0.80
+        end
+        
+        ## @detect_collisions = true
+        super
+      end
+      
+      #
+      # The standard method called when self needs to be checked for a collision with another object
+      # By default it calls bounding_box_collision? which will check for intersectons between the 
+      # two objects "bounding_box" attributs (a Chingu::Rect instance)
+      #
+      def collides?(object2)
+        bounding_box_collision?(object2)
+        #radius_collision?(object2)
+      end
+      
+      #
+      # Collide self with a given game object by checking both objects bounding_box'es
+      # Returns true if colliding.
+      #
+      def bounding_box_collision?(object2)
+        self.bounding_box.collide_rect?(object2.bounding_box)
+      end
+      
+      #
+      # Collide self using distance between 2 objects and their radius.
+      # Returns true if colliding.
+      #
+      def radius_collision?(object2)
+        distance(self.x, self.y, object2.x, object2.y) < self.radius + object2.radius
+      end
+      
+      #
+      # Have bounding box follow game objects x/y
+      #
+      def update_trait
+        if defined?(@bounding_box) && @bounding_box.is_a?(Rect)
+          @bounding_box.x = self.x
+          @bounding_box.y = self.y
+        end
+        
+        super
+      end
+
+      #
+      # Collides self with all objects of given classes
+      # Yields self and the objects it collides with
+      #
+      def each_collision(klasses = [])
+        Array(klasses).each do |klass|        
+          klass.all.each do |object|
+            yield(self, object)   if collides?(object)
+          end
+        end
+      end
+      
+      #
+      # Works like each_collsion but with inline-code for speedups
+      #
+      def each_radius_collision(klasses = [])
+        Array(klasses).each do |klass|
+          klass.all.each do |object|
+            yield(self, object) if distance(@x, @y, object.x, object.y) < @radius + object.radius
+          end
+        end
+      end
+
+
+      
+      module ClassMethods
+      
+        #
+        # Works like each_collsion but with inline-code for speedups
+        #
+        def each_radius_collision(klasses = [])
+          Array(klasses).each do |klass|
+            object2_list = klass.all
+            #total_radius = object1.radius + object2.radius  # possible optimization?
+            
+            self.all.each do |object1|
+              object2_list.each do |object2|
+                next  if object1 == object2  # Don't collide objects with themselves
+                yield object1, object2  if distance(object1.x, object1.y, object2.x, object2.y) < object1.radius + object2.radius
+              end
+            end
+          end
+        end
+        
+        #
+        # Class method that will check for collisions between all instances of two classes
+        # and yield the 2 colliding game object instances.
+        #
+        # It will not collide objects with themselves.
+        #
+        #   example:
+        #
+        #   Enemy.each_collision(Bullet).each do |enemy, bullet| enemy.die!; end
+        #
+        #
+        def each_collision(klasses = [])
+          # Make sure klasses is always an array.
+          Array(klasses).each do |klass|
+            object2_list = klass.all
+            
+            self.all.each do |object1|
+              object2_list.all.each do |object2|
+                next  if object1 == object2  # Don't collide objects with themselves
+                yield object1, object2  if object1.collides?(object2)
+              end
+            end
+          end
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/chingu/traits/effect.rb

@@ -0,0 +1,113 @@
+#--
+#
+# Chingu -- Game framework built on top of the opengl accelerated gamelib Gosu
+# Copyright (C) 2009 ippa / ippa@rubylicio.us
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#++
+
+
+module Chingu
+  module Traits
+    module Effect
+      #
+      # Adds .rotating .fading and .zooming to any GameObject.
+      #
+      # TODO: better naming? suggestions:
+      #
+      # basic gosu unit <-> automation name
+      # ==============================================
+      # angle <-> rotation? rotating? automatic_angle?
+      # factor <-> growth? scale? automatic_zoom?
+      # alpha <-> fade
+      #
+      attr_accessor :rotating, :fading, :zooming
+      
+      #def self.initialize_trait(options)
+      #  @effect_options = {:debug => false}.merge(options)
+      #  puts "Effect#initialize"    if @effect_options[:debug]
+      #  super
+      #end
+            
+      #
+      # Setup
+      #
+      def setup_trait(options)
+        @effect_options = {:debug => false}.merge(options)
+        puts "Effect#setup"     if @effect_options[:debug]
+        
+        @rotating = options[:rotating] || nil
+        @zooming = options[:zooming] || nil
+        @fading = options[:fading] || nil
+        super
+      end
+      
+      def draw_trait
+        puts "Effect#draw"      if @effect_options[:debug]
+        super
+      end
+      
+      def update_trait
+        puts "Effect#update"    if @effect_options[:debug]
+        
+        rotate(@rotating)    if @rotating
+        fade(@fading)        if @fading
+        zoom(@zooming)       if @zooming
+        super
+      end
+      
+      # Zoom - increase @factor_x and @factor_y at the same time.
+      def zoom(amount = 0.1)
+        @factor_x += amount
+        @factor_y += amount
+      end
+          
+      # Zoom Out - decrease @factor_x and @factor_y at the same time.
+      def zoom_out(amount = 0.1)
+        @factor_x -= amount
+        @factor_y -= amount
+      end
+    
+      # Rotate object 'amount' degrees
+      def rotate(amount = 1)
+        @angle += amount
+      end
+  
+      # Fade object by decreasing/increasing color.alpha
+      def fade(amount = 1)
+        return if amount == 0
+            
+        new_alpha = @color.alpha + amount
+        if amount < 0
+          @color.alpha =  [0, new_alpha].max
+        else
+          @color.alpha =  [0, new_alpha].min
+        end
+      end
+
+      # Fade out objects color by decreasing color.alpha
+      def fade_out(amount = 1)
+        fade(-amount)
+      end
+
+      # Fade in objects color by increasing color.alpha
+      def fade_in(amount = 1)
+        fade(amount)
+      end
+      
+    end
+  end
+end