chingu 0.7.0 → 0.7.5

data/lib/chingu/helpers/class_inheritable_accessor.rb

@@ -8,15 +8,15 @@ module Helpers
     def self.included(base)
       base.extend(ClassMethods)    
     end
-  
+
     module ClassMethods
       def class_inheritable_accessor(*args)
         @cattr_inheritable_attrs ||= [:cattr_inheritable_attrs]
         @cattr_inheritable_attrs += args
         args.each do |arg|
-          class_eval %(
-            class << self; attr_accessor :#{arg} end
-          )
+        class_eval %(
+          class << self; attr_accessor :#{arg} end
+        )
         end
         @cattr_inheritable_attrs
       end
@@ -24,8 +24,15 @@ module Helpers
       def inherited(subclass)
         @cattr_inheritable_attrs.each do |inheritable_attribute|
           instance_var = "@#{inheritable_attribute}" 
-          subclass.instance_variable_set(instance_var, instance_variable_get(instance_var))
+          subclass.instance_variable_set(instance_var, instance_variable_get(instance_var).dup)
+					
+          #if instance_var =~ /trait_options/
+          #	puts "#{self.to_s} -> #{subclass.to_s}: #{instance_var}"	# DEBUG
+          #	puts instance_variable_get(instance_var)
+          #	puts "------"
+          #end
         end
+        super
       end
     end
   end

data/lib/chingu/helpers/game_object.rb

@@ -52,18 +52,20 @@ module Chingu
     # Creates game objects from a Chingu-spezed game objects file (created with game state 'Edit')
     #
     def load_game_objects(options = {})
-      filename = options[:file] || "#{self.class.to_s.downcase}.yml"
+      file = options[:file] || "#{self.class.to_s.downcase}.yml"
+      debug = options[:debug]
       
       require 'yaml'
       
-      if File.exists?(filename)
-        game_objects = YAML.load_file(filename)
+      puts "* Loading game objects from #{file}" if debug
+      if File.exists?(file)
+        game_objects = YAML.load_file(file)
         game_objects.each do |game_object|
           game_object.each_pair do |klassname, attributes|
             begin
               klass = Kernel::const_get(klassname)
               unless klass.class == "GameObject"
-                puts "Creating #{klassname.to_s}: #{attributes.to_s}"
+                puts "Creating #{klassname.to_s}: #{attributes.to_s}" if debug
                 klass.create(attributes)
               end
             rescue
@@ -73,6 +75,45 @@ module Chingu
         end
       end
     end
+    
+    #
+    # Save given game_objects to a file. Hashoptions
+    # 
+    # :file - a String, name of file to write to, default is current game_state class name.
+    # :game_objects - an Array, game objects to save
+    # :classes      - an Array, save only game objects of theese classes
+    #
+    def save_game_objects(options = {})
+      file = options[:file] || "#{self.class.to_s.downcase}.yml"
+      game_objects = options[:game_objects]
+      classes = options[:classes]
+      
+      require 'yaml'
+      objects = []
+      game_objects.each do |game_object|
+        next if classes and !classes.include?(game_object.class)
+        
+        objects << {game_object.class.to_s  => 
+                      {
+                      :x => game_object.x, 
+                      :y => game_object.y,
+                      :angle => game_object.angle,
+                      :zorder => game_object.zorder,
+                      #:factor_x => game_object.factor_x,
+                      #:factor_y => game_object.factor_y,
+                      #:center_x => game_object.center_x,
+                      #:center_y => game_object.center_y,
+                      }
+                    }
+      end
+
+        
+      #Marshal.dump(previous_game_state.game_objects, File.open(@filename, "w"))
+      File.open(file, 'w') do |out|
+        YAML.dump(objects, out)
+      end
+    end
+    
   
   end
 

data/lib/chingu/helpers/gfx.rb

@@ -1,173 +1,151 @@
-#--
-#
-# Chingu -- OpenGL accelerated 2D game framework for Ruby
-# 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 Helpers
-    
-  #
-  # Various helper-methods to manipulate the screen.
-  # All drawings depend on the global variable $window which should be an instance of Gosu::Window or Chingu::Window
-  #
-  module GFX
-  
-    #
-    # Fills whole window with specified 'color' and 'zorder'
-    #
-    #def fill(color, zorder = 0)
-    #  $window.draw_quad(0, 0, color,
-    #                    $window.width, 0, color,
-    #                    $window.width, $window.height, color,
-    #                    0, $window.height, color,
-    #                    zorder, :default)
-    #end
-    #
-    
-    # Fills window or a given rect with a gradient between two colors.
-    #
-    #   :from         - Start with this color
-    #   :to           - End with this color
-    #   :rect         - Only fill rectangle :rect with the gradient, either a Rect-instance or [x,y,width,height] Array.
-    #   :orientation  - Either :vertical (top to bottom) or :horizontal (left to right)
-    #
-    
-    def fill(options, zorder = 99)
-      #
-      # if only 1 color-argument is given, assume fullscreen simple color fill.
-      #
-      if options.is_a?(Gosu::Color)
-        $window.draw_quad(0, 0, options,
-                        $window.width, 0, options,
-                        $window.width, $window.height, options,
-                        0, $window.height, options, 0, :default)
-        return
-      end
-      
-      default_options = { :colors => [Gosu::Color.new(0xFFFFFFFF), Gosu::Color.new(0xFF000000)],
-                          :orientation => :vertical,
-                          :rect => Rect.new([0, 0, $window.width, $window.height]),
-                          :zorder => 0,
-                          :mode => :default
-                        }
-			options = default_options.merge(options)
-      rect = Rect.new(options[:rect])
-      
-      if options[:orientation] == :vertical
-        x = rect.x
-        y = rect.y
-        right = rect.right
-        bottom = rect.bottom
-        
-        step = (rect.x + rect.right) / options[:colors].size
-        1.upto(options[:colors].size).each do |nr|
-          from = options[:colors]
-          to = 
-        
-          $window.draw_quad(  x, y, options[:from],
-                            x + step, rect.y, options[:from],
-                            x + step, rect.bottom, options[:to],
-                            x, rect.bottom, options[:to],
-                            options[:zorder], options[:mode]
-                          )
-        end
-      else
-        $window.draw_quad(  rect.x, rect.y, options[:from],
-                            rect.x, rect.bottom, options[:from],
-                            rect.right, rect.bottom, options[:to],
-                            rect.right, rect.y, options[:to],
-                            options[:zorder], options[:mode]
-                          )        
-      end
-    end
-    
-    #
-    # Draws an unfilled rect in given color
-    #
-    def draw_rect(rect, color, zorder)
-      $window.draw_line(rect.x, rect.y, color, rect.right, rect.y, color, zorder)
-      $window.draw_line(rect.right, rect.y, color, rect.right, rect.bottom, color, zorder)
-      $window.draw_line(rect.right, rect.bottom, color, rect.x, rect.bottom, color, zorder)
-      $window.draw_line(rect.x, rect.bottom, color, rect.x, rect.y, color, zorder)
-    end
-    
-    
-    #
-    # Draws an unfilled circle, thanks shawn24!
-    #
-    CIRCLE_STEP = 10
-    def draw_circle(cx,cy,r,color)      
-      0.step(360, CIRCLE_STEP) do |a1|
-        a2 = a1 + CIRCLE_STEP
-        $window.draw_line cx + Gosu.offset_x(a1, r), cy + Gosu.offset_y(a1, r), color, cx + Gosu.offset_x(a2, r), cy + Gosu.offset_y(a2, r), color, 9999
-      end
-    end
-    
-    #
-    # Fills a given Rect 'rect' with Color 'color', drawing with zorder 'zorder'
-    #
-    def fill_rect(rect, color, zorder = 0)
-      rect = Rect.new(rect)     # Make sure it's a rect
-      $window.draw_quad(  rect.x, rect.y, color,
-                          rect.right, rect.y, color,
-                          rect.right, rect.bottom, color,
-                          rect.x, rect.bottom, color,
-                          zorder, :default)
-    end
-    
-    #
-    # Fills window or a given rect with a gradient between two colors.
-    #
-    #   :from         - Start with this color
-    #   :to           - End with this color
-    #   :rect         - Only fill rectangle :rect with the gradient, either a Rect-instance or [x,y,width,height] Array.
-    #   :orientation  - Either :vertical (top to bottom) or :horizontal (left to right)
-    #
-    def fill_gradient(options)
-      default_options = { :from => Gosu::Color.new(255,0,0,0),
-                          :to => Gosu::Color.new(255,255,255,255), 
-                          :thickness => 10, 
-                          :orientation => :vertical,
-                          :rect => Rect.new([0, 0, $window.width, $window.height]),
-                          :zorder => 0,
-                          :mode => :default
-                        }
-			options = default_options.merge(options)
-      rect = Rect.new(options[:rect])
-      
-      if options[:orientation] == :vertical
-        $window.draw_quad(  rect.x, rect.y, options[:from],
-                            rect.right, rect.y, options[:from],
-                            rect.right, rect.bottom, options[:to],
-                            rect.x, rect.bottom, options[:to],
-                            options[:zorder], options[:mode]
-                          )
-      else
-        $window.draw_quad(  rect.x, rect.y, options[:from],
-                            rect.x, rect.bottom, options[:from],
-                            rect.right, rect.bottom, options[:to],
-                            rect.right, rect.y, options[:to],
-                            options[:zorder], options[:mode]
-                          )        
-      end
-    end
-  end
-  
-  end
+#--
+#
+# Chingu -- OpenGL accelerated 2D game framework for Ruby
+# 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 Helpers
+    
+  #
+  # Various helper-methods to manipulate the screen.
+  # All drawings depend on the global variable $window which should be an instance of Gosu::Window or Chingu::Window
+  #
+  module GFX
+  
+    #
+    # Fills whole window with specified 'color' and 'zorder'
+    #
+    #def fill(color, zorder = 0)
+    #  $window.draw_quad(0, 0, color,
+    #                    $window.width, 0, color,
+    #                    $window.width, $window.height, color,
+    #                    0, $window.height, color,
+    #                    zorder, :default)
+    #end
+    #
+    
+    # Fills window or a given rect with a gradient between two colors.
+    #
+    #   :from         - Start with this color
+    #   :to           - End with this color
+    #   :rect         - Only fill rectangle :rect with the gradient, either a Rect-instance or [x,y,width,height] Array.
+    #   :orientation  - Either :vertical (top to bottom) or :horizontal (left to right)
+    #
+    
+    def fill(options, zorder = 0)
+      #
+      # if only 1 color-argument is given, assume fullscreen simple color fill.
+      #
+      if options.is_a?(Gosu::Color)
+        $window.draw_quad(0, 0, options,
+                        $window.width, 0, options,
+                        $window.width, $window.height, options,
+                        0, $window.height, options, zorder, :default)
+      else
+        fill_gradient(options)
+      end
+    end
+    
+    #
+    # Draws an unfilled rect in given color
+    #
+    def draw_rect(rect, color, zorder)
+      $window.draw_line(rect.x, rect.y, color, rect.right, rect.y, color, zorder)
+      $window.draw_line(rect.right, rect.y, color, rect.right, rect.bottom, color, zorder)
+      $window.draw_line(rect.right, rect.bottom, color, rect.x, rect.bottom, color, zorder)
+      $window.draw_line(rect.x, rect.bottom, color, rect.x, rect.y, color, zorder)
+    end
+    
+    
+    #
+    # Draws an unfilled circle, thanks shawn24!
+    #
+    CIRCLE_STEP = 10
+    def draw_circle(cx,cy,r,color)      
+      0.step(360, CIRCLE_STEP) do |a1|
+        a2 = a1 + CIRCLE_STEP
+        $window.draw_line cx + Gosu.offset_x(a1, r), cy + Gosu.offset_y(a1, r), color, cx + Gosu.offset_x(a2, r), cy + Gosu.offset_y(a2, r), color, 9999
+      end
+    end
+    
+    #
+    # Fills a given Rect 'rect' with Color 'color', drawing with zorder 'zorder'
+    #
+    def fill_rect(rect, color, zorder = 0)
+      rect = Rect.new(rect)     # Make sure it's a rect
+      $window.draw_quad(  rect.x, rect.y, color,
+                          rect.right, rect.y, color,
+                          rect.right, rect.bottom, color,
+                          rect.x, rect.bottom, color,
+                          zorder, :default)
+    end
+    
+    #
+    # Fills window or a given rect with a gradient between two colors.
+    #
+    #   :from         - Start with this color
+    #   :to           - End with this color
+    #   :rect         - Only fill rectangle :rect with the gradient, either a Rect-instance or [x,y,width,height] Array.
+    #   :orientation  - Either :vertical (top to bottom) or :horizontal (left to right)
+    #
+    def fill_gradient(options)
+      default_options = { :from => Gosu::Color::BLACK,
+                          :to => Gosu::Color::WHITE,
+                          :thickness => 10, 
+                          :orientation => :vertical,
+                          :rect => Rect.new([0, 0, $window.width, $window.height]),
+                          :zorder => 0,
+                          :mode => :default
+                        }
+      options = default_options.merge(options)
+      
+      rect   = Rect.new(options[:rect])
+      colors = options[:colors] || options.values_at(:from, :to)
+      
+      case options[:orientation]
+      when :vertical
+        rect.height /= colors.count - 1
+        colors.each_cons(2) do |from, to|
+          $window.draw_quad(  rect.left,  rect.top,    from,
+                              rect.right, rect.top,    from,
+                              rect.right, rect.bottom, to,
+                              rect.left,  rect.bottom, to,
+                              options[:zorder], options[:mode]
+                            )
+          rect.top += rect.height
+        end
+      when :horizontal
+        rect.width /= colors.count - 1
+        colors.each_cons(2) do |from, to|
+          $window.draw_quad(  rect.left,  rect.top,    from,
+                              rect.left,  rect.bottom, from,
+                              rect.right, rect.bottom, to,
+                              rect.right, rect.top,    to,
+                              options[:zorder], options[:mode]
+                            )
+          rect.left += rect.width
+        end
+      else
+        raise ArgumentError, "bad gradient orientation: #{options[:orientation]}"
+      end
+    end
+  end
+  
+  end
 end

data/lib/chingu/helpers/input_client.rb

@@ -44,6 +44,13 @@ module Chingu
     #
     #
     module InputClient
+      #
+      # Returns true or false depending on if the key is pressed
+      #
+      def holding?(key)
+        $window.button_down?(Chingu::Input::SYMBOL_TO_CONSTANT[key])
+      end
+      
       def input=(input_map)
         @input ||= Hash.new
         #@input = input_map

data/lib/chingu/inflector.rb

@@ -21,7 +21,11 @@
 
 
 module Chingu
-  module Inflector    
+  module Inflector
+		
+		#
+		# "automatic_assets" -> "AutomaticAssets"
+		#
     def Inflector.camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
       if first_letter_in_uppercase
         lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
@@ -29,6 +33,16 @@ module Chingu
         lower_case_and_underscored_word.first.downcase + camelize(lower_case_and_underscored_word)[1..-1]
       end
     end
-
+		
+		#
+		# "FireBall" -> "fire_ball"
+		#
+		def Inflector.underscore(camel_cased_word)
+			camel_cased_word.to_s.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+			gsub(/([a-z\d])([A-Z])/,'\1_\2').
+			tr("-", "_").
+			downcase
+		end
+		
   end
 end